第6章 数组应用

数组应用

数组是相同数据类型的集合。数组中的每个元素必须具有相同的数据类型【Javascript除外】。可以按照数组的维数分为：一维数组、二维数组.....

一、为什么使用数组

例子：孙悟空操练猴子，要求每天记录猴子翻跟头的数目，然后比较出来最大的天数。记录范围1个月。

public static void main(String[] args) {

int i1=30;

int i2=32;

.......

if(i1>i2){

//拿取i1

}else

//拿取i2

if(i2>i3)

//拿取i3

}

二、一维数组

一维数组使用时必须先定义数组变量所属类型。语法规则：

数组类型变量名[];

或

数组类型[]变量名;

数组类型用于决定数组元素的数据类型。它可以是Java中的任何数据类型，包括基本类型和引用类型。String [] args。

单个[]表示的是一维数组。

Int [] arr;

Short []arr;

People [] people;

声明数组后，还不能访问元素，必须通过new的方式进行分配。

其语法格式如下：

变量名称= new 数组类型[数组长度];

Int a[]=new int[10];

Int b[]=new short[5]; 错误

数组的下标相当于索引，第一个数小标为0，最后一个数的下标为数组的长度-1。数组中常见异常：https://www.doczj.com/doc/2817274855.html,ng.ArrayIndexOutOfBoundsException

数组元素的赋值

①直接针对下标元素指定元素赋值

public static void main(String[] args) {

int []arr=new int[6];

arr[0]=30;//第一天跟斗的数目

arr[1]=20;

arr[2]=40;

arr[3]=28;

for(int i=0;i<6;i++){

System.out.println(arr[i]);

}

}

②直接初始化赋值

public void init2(){

int []arr=new int[]{30,20,40,28};

for(int i=0;i<6;i++){

System.out.println(arr[i]);

}

}

会出现下标越界，如何进行修正？

利用数组的length属性访问，用于判断数组的长度。

public void init3(){

int []arr=new int[]{30,20,40,28};

for(int i=0;i

System.out.println(arr[i]);

}

}

③直接利用代码块赋值

public void init4(){

int []arr={30,20,40,28};

for(int i=0;i

System.out.println(arr[i]);

}

}

作业：打印出每个月多少天数？

public static void main(String[] args) {

int month[]=new int[]{31,28,31,30,31,30,31,31,30,31,30,31};

for (int i = 0; i < month.length; i++) {

System.out.println(i+1+"月有"+month[i]+"天");

}

}

返回类型为数组,如何进行处理？

private static int[] b(){

int a[]=new int[]{2,3,4};

return a;

}

作业：

1.利用数组输出1 1 2 3 5 8...这样的序列。

2.判断数组元素是否对称。例如{1}、{1，2,1}、{1,2,3,2,1}都是对称数组

3.判断一个数组元素中是否有相同的数值，如果有的话输出重复。

4.统计一个数字中出现数字最多的数字，如果数字相同的话，则输出数值最大的值。例如231输出结果为3,2312输出结果则为2.

●对数字进行拆分

●统计数字出现的次数

●求取数字的最大值

For.....each

语法格式：

for([数据类型：：数组中存放数据的类型]

[数组中存放的值已value变量进行显示]value : [数组的变量]){

System.out.print(value+"\t");

}

public static void main(String[] args) {

Monkey monkeys[]=new Monkey[2];

Monkey m1=new Monkey("金丝猴");

Monkey m2=new Monkey("长尾猴");

monkeys[0]=m1;

monkeys[1]=m2;

for(int i=0;i

System.out.println(monkeys[i].getName());

}

for(Monkey m : monkeys){

System.out.println(m.getName());

}

}

但是foreach不支持下标，如果要有下标值的话，那么再foreach外面设置变量。

int i=0;

for(Monkey m : monkeys){

System.out.println(m.getName());

i++;

}

扩展：下面题目的结果是什么？

public static void main(String[] args) {

Teacher[] teas = new Teacher[10];

Teacher t1 = new Teacher("MR l", "1");

Teacher t2 = new Teacher("MS l", "2");

teas[0] = t1;

teas[1] = t2;

int age = 50;

for (Teacher teacher : teas) {

if (teacher != null) {

teacher.setAge(++age);

}

}

for (Teacher teacher : teas) {

if (teacher != null) {

System.out.println(teacher.getUsername() + "---"

+ teacher.getPassword() + "---"+ teacher.getAge());

}

}

for (Teacher teacher : teas) {

teacher=null;

}

for (Teacher teacher : teas) {

if (teacher != null) {

System.out.println(teacher.getUsername() + "---"

+ teacher.getPassword() + "---"

+ teacher.getAge());

}

}

}

答案是：

MR l---1---51

MS l---2---52

MR l---1---51

MS l---2---52

为什么会出现这样的结果，其实原因在于for...each循环中，只是一个变量。因此在栈内存中分配，指向堆内存中数组元素。因此当其进行set写操作时，其堆内存中值会跟随发生改变。但是当其将引用变量改为null，并不是删除数组中的元素，只是将引用变量与堆内存中的元素联系进行切断。

作业：歌唱比赛开始了，某歌手唱完之后，分数已经出炉，此时将该歌手的分数扣除掉一个最大分数，并且扣除掉一个最小的分数，然后将剩余分数求和求取出平均分数。

考点：

1.求取数组中最大值

2.求取出数组中最小值

3.求取出数组元素值的和

4.求取数组元素个数

大作业：

1.有一登陆界面，需要输入用户名和密码和所属角色，此时用户从控制台进行用户名和密码的输入，从而判断出是否能进入管理后台。如果判断不通过的话，则要求重新输入用户信息。如果判断能通过的话，则根据角色分别进入不同的后台页面。

2.管理员角色进去之后，能查看到的管理页面为

0.学生管理

●添加学生【ID、Name、】

●显示学生

●修改学生【指定学生ID属性】

●删除学生【指定学生ID】

●关联教师

1.管理教师

●添加教师

●显示所有教师

●修改教师【指定教师ID属性】

●删除教师

●关联学生

3.学生角色进入系统之后，提供以下权限：

1.信息查看

2.密码修改

4.教师角色进入系统之后，提供以下权限：

1.信息查看

2.密码修改

3.所教学生信息

三、数组API

数组常用操作类Arrays，其提供的方法均是静态方法。来自于java.util包下

具有以下功能：

1.给数组赋值，通过fill方法。

2.对数组排序，通过sort方法。

3.查找数组元素，通过binarySearch【二分查找】方法。

4.比较数组，通过equals方法。

?Fill方法

public static void main(String[] args) {

int []arr=new int[5];

for(int value : arr){

System.out.print(value);

}

System.out.println();

Arrays.fill(arr, 2);

//将指定的 int 值分配给指定 int 型数组的每个元素。

for(int value : arr){

System.out.print(value);

}

Arrays.fill(arr,0,3, 5);//修改从第一个元素到第三个元素的值修改为5

for(int value : arr){

System.out.print(value);

}

}

?Sort方法

public static void main(String[] args) {

int []arr=new int[]{1,4,3,8,5};

Arrays.sort(arr,1,4);//指定索引范围内的数字排序【升序】

for(int a : arr){

System.out.print(a+"\t");

}

// System.out.println(arr.length);

Arrays.sort(arr);//按数字升序进行排序

for(int a : arr){

System.out.println(a);

}

}

?Equal s

public static void main(String[] args) {

int []arr=new int[]{1,4,3,8,5};

int []arr1=new int[]{1,4,3,8};

System.out.println(Arrays.equals(arr, arr1));

//比较两个数组是否相等，前提是数组元素必须要相同，数组元素的个数必须要相等

}

?binarySearch二分搜索法

二分搜索前提是有序数组序列。

二分查找又称为折半查找。优点是比较次数少，查找速度快。但是必须是有序表。

public static void main(String[] args) {

int []arr=new int[]{1,4,3,8,5};//1 3 4 5 8

Arrays.sort(arr);//对数组进行排序，因为二分查找要求必须是有序

int key=Arrays.binarySearch(arr, 5);

System.out.println(key);

}

四、排序算法

冒泡

利用数组中元素两个数进行比较，查找出最大值，然后交换位置。同时拿最大值与下一个元素进行比较，依次类推，直到将最大的元素放置于最右端。此时第一轮循环结束，然后接着第二轮循环，但是数组的长度要在原长度的基础上减一，因此最大的元素已经提取出来，不需要再进行处理。

时间比较：

交换次数：

public static void sortByPop(int []arr){

for (int i = 0; i < arr.length-1; i++) {

for(int j=0;j

//嵌套循环每次做完循环之后数组的长度减1

if(arr[j]>arr[j+1]){

int temp=arr[j];//缓存起来

arr[j]=arr[j+1];//将第二个元素赋值给第一个元素

arr[j+1]=temp;//将缓存值赋值给数组中第二个元素

}

}

}

}

选择

选择排序的思路就是获取最大值或者最小值的索引，然后根据该索引值与第一个值或者最后一个值进行交换，从而获取交换次数的减少，但是比较时间次数仍然是平方级别。

public static void sortBySelection(int []arr){

int index,max=arr.length-1;

for (int i = 0; i < arr.length-1; i++) {

index = 0 ; //index=0

/**

* 执行一轮循环，找到最大值的索引

*/

for(int j=0;j

if(arr[index]< arr[j+1]){

index=j+1;

}

}

int temp=arr[index];//缓存起来

arr[index]=arr[max];//将第二个元素赋值给第一个元素

arr[max]=temp;//将缓存值赋值给数组中第二个元素

max--; //缓存目前数组未提取最大值的长度

}

}

插入

插入排序是基本排序中最好的一种，其关键在于一次又一次排序过程中，交换出有序和无序两种状态。然后无序的逐渐向有序的进行交换。

因此对于有序或者基本有序的数组元素排列，插入排序有利的很。但是对于逆序的则基本和冒泡排序效率一样。

public static void sortByInsert(int []arr){

for(int i=1;i

int temp=arr[i];

int j=i; //记录当前值前面有几个值

while(j>0 && arr[j-1] >= temp){

arr[j]=arr[j-1];

j --;

}

arr[j]=temp;

}

}

五、栈

栈介绍

栈是一种特殊的表，只能在表头进行插入和删除操作。因此表头称为栈顶，表尾称为栈底。不含任何元素的栈称为空栈。出栈的元素都是栈顶元素，出栈的顺序是先进后出（Last In First Out）。

API

Stack类：

例子

输入字符串按照栈的顺序进行出栈。利用栈的API。

public static void main(String[] args) {

Stack s=new Stack();

String str="abcdef";

int length=str.length();// 求取字符串的长度

for(int i=0; i< length; i++){

char cc=str.charAt(i);

s.push(cc);//压栈操作

}

for(int i=0; i< length; i++){

System.out.println(s.pop());//出栈操作

}

}

模拟实现【用数组实现】

public class Stack {

private Object [] stackArray=null;//定义存放的数据数组private int maxSize;//定义数组的最大长度

private int top; //用于验证栈中是否有元素

public Stack(int maxSize){

this.maxSize = maxSize ;

stackArray = new Object[maxSize];

top=-1;

}

/**

* 验证栈是否为空

* @return

*/

public boolean empty(){

return top==-1;

}

/**

* 查看栈顶元素

* @return

*/

public Object peek(){

return stackArray[top];

}

* 查看出栈的元素，元素会从栈中移除

* @return

*/

public Object pop(){

Object obj=stackArray[top];

stackArray[top--]=null;

return obj;

}

/**

* 将元素压入栈顶

* @return

*/

public Object push(Object obj){

if(isFull()){

System.out.println("已到最大元素");

}else

stackArray[++top]=obj;

return obj;

}

/**

* 返回数组长度是否已达到最大值

* @return

*/

private boolean isFull(){

return top==maxSize-1;

}

public void display(){

for (Object obj : stackArray) {

if(obj!=null){

System.out.println(obj);

}

}

}

public static void main(String[] args) { Stack s=new Stack(20);

s.push(1);//进栈操作

s.push(2);

s.push(3);

s.push(4);

System.out.println(s.peek());//打印栈顶元素

s.pop();//出栈

s.pop();

s.display();

String str="abcdef";

int length=str.length();// 求取字符串的长度

for(int i=0; i< length; i++){

char cc=str.charAt(i);

s.push(cc);//压栈操作

}

for(int i=0; i< length; i++){

System.out.println(s.pop());//出栈操作}

}

}

六、队列

队列

队列也是一种数据结构，其顺序为先进先出。

API

Queue接口类：

例子

把字符串用顺序方式打印出来？

模拟实现

public class Queue {

private Object[] arrayQueue = null;//存放数据的数组private int maxSize ;//定义数组的最大长度

private int index ;//放置索引值，用于判断是否为空

public Queue(int maxSize){

this.maxSize = maxSize ;

index = 0 ;

arrayQueue = new Object[maxSize];

}

/**

* 往队列中添加元素

*

* @param obj

*/

public void add(Object obj) {

if(isFull()){

System.out.println("已满!");

return ;

}

arrayQueue[index++]=obj;

/**

* 从队列中删除元素

*

* @return

*/

public Object remove() {

if(empty()){

System.out.println("队列中无数据!");

return null;

}else{

Object obj= arrayQueue[0] ;

for (int i = 0; i < index; i++) {

if(isFull(i+1)){

arrayQueue[i]=null;

}else{

arrayQueue[i]=arrayQueue[i+1];

}

}

index--;

return obj;

}

}

/**

* 获取队列的头

*

* @return

*/

public Object peek() {

if(empty()){

return null;

}

return arrayQueue[0];

}

public boolean empty() {

return index == 0;

}

private boolean isFull() {

return isFull(index);

private boolean isFull(int i){

return i == maxSize;

}

/**

* 打印队列中元素信息

*/

public void display() {

for (Object obj : arrayQueue) {

if (obj != null) {

System.out.println(obj);

}

}

}

public static void main(String[] args) { Queue q = new Queue(10);

q.add(1);

q.add(2);

q.display();

System.out.println(q.peek());

q.remove();

System.out.println(q.peek());

q.add(3);

q.add(4);

q.remove();

q.add(5);

q.add(6);

q.display();

}

}

七、二维数组

二维数组可以看成一个特殊的一维数组，常用于表，以行和列的形式进行组织。第一个下标代表元素所在的行，第二个下标代表元素所在的列。

创建二维数组

语法：

【数据类型】【变量名】【[][]】

【数据类型】【[][]】【变量名】

Int [][] myArr = new int[3][3];

初始化：

1.myArr[0][0]=1

2.myArr = new int[][]{{1,2,3},{4,5,6},{7,8,9}};

3.int [][] aa={{1,2,3},{4,5,6},{7,8,9}};

注意第三种只能这样写，声明的值必须放在初始化的位置。

分配内存：

1.int [][] myArr = new int[3][3];对行和列数目均确定

2.int [][] bb =new int[3][];//先定义了有几行只是确定行

bb[0]= new int[1];//第一行分配1列

bb[1]= new int[2];//第二行分配2列

bb[2]= new int[3];//第三行分配3列

例子

【填充3行3列的数组，数据为1-9。1.填充数据 2.遍历数据】

public static void main(String[] args) {

int [][] myArr = new int[3][4];

System.out.println(myArr.length);//测试的是行的数目

for (int i = 0; i < myArr.length; i++) {

for (int j = 0; j < myArr[i].length; j++) {

myArr[i][j] = (j+1)+4*i;

}

}

for (int i = 0; i < myArr.length; i++) {

for (int j = 0; j < myArr[i].length; j++) {

System.out.print(myArr[i][j]+"\t");

}

System.out.println();

}

}

【作业】

1.杨辉三角形利用二维数组？

public static void main(String[] args) {

int arr[][]=new int[10][10];

for(int row = 0 ;row< arr.length; row++){//指定行

for(int col =0 ; col <= row ; col++){//指定列

if(col == 0){

arr[row][col] = 1;

}else{

arr[row][col]=arr[row-1][col-1]+arr[row-1][col];

}

}

}

for(int row = 0 ;row

for(int col =0 ; col <= row ; col++){

System.out.print(arr[row][col]+"\t");

}

System.out.println();

}

}

public static void main(String[] args) {

int arr[][]=new int[10][];//指定10行

for(int row = 0 ;row

arr[row]=new int[row+1]; //指定行上面有多少列

for(int col =0 ; col < arr[row].length ; col++){

if(col == 0|| row==1 || row ==col){

arr[row][col] = 1;

}else{

arr[row][col]=arr[row-1][col-1]+arr[row-1][col];

}

}

}

for(int row = 0 ;row

for(int col =0 ; col < arr[row].length ; col++){

System.out.print(arr[row][col]+"\t");

}

System.out.println();

}

}

2.通过一维数组定义考试科目，通过二维数组方式定义n个学生对应的学生成绩，同时初始化。循环遍历打印学生的考试情况，用表格方式进行展示。同时计算出每门成绩的平均值，以及每门成绩的最高分及最低分。以及每个学生总分进行打印。

public static void main(String[] args) {

String[] courses = new String[] { "语文", "数学", "英语", "地理", "历史" };//数据定义

double[][] scores = new double[][] { { 87, 91, 60, 78, 82 }, { 85, 71, 80, 88, 80 }, { 76, 32, 92, 75, 92 },

{ 89, 67, 50, 71, 100 } };

int courseLength = courses.length;//科目的长度

System.out.print("\t\t");

/**

* 打印科目信息

*/

for (int i = 0; i < courseLength; i++) {

System.out.print(courses[i] + "\t|\t");

}

System.out.print("总分");

System.out

.println("\n-----------------------------------------------------------------------------------------");

/**

* 循环遍历二维数组分数

*/

for (int i = 0; i < scores.length; i++) {//打印行

int sum = 0;

System.out.print("\t\t");

for (int j = 0; j < scores[i].length; j++) {//打印列

System.out.print(scores[i][j] + "\t|\t");

sum += scores[i][j];

}

System.out.print(sum);

System.out.println();

}

System.out

.println("\n-----------------------------------------------------------------------------------------");

double result[][]=new double[3][courses.length];

for (int i = 0; i < courses.length; i++) {//判断有多少列数据int sum = 0;

double max = 0;

double min = 101;

for (int j = 0; j < scores.length; j++) {//判断有多少行数据sum += scores[j][i];

max = max > scores[j][i] ? max : scores[j][i];

min = min < scores[j][i] ? min : scores[j][i];

}

double averageScore = sum / scores.length;

result[0][i] = averageScore;//存放平均值、最大值、最小值

result[1][i] = max;

result[2][i] = min;

}

for (int i = 0; i < result.length; i++) {

print(i);

for (int j = 0; j < result[i].length; j++) {

System.out.print(result[i][j] + "\t|\t");

}

System.out.println();

}

}

private static void print(int key){

switch (key) {

case 0:

System.out.print("平均分 \t\t");

break;

case 1:

System.out.print("最高分 \t\t");

break;

case 2:

System.out.print("最低分 \t\t");

break;

default:

break;

}

}

3.课后作业

一堂考试，目前学生已经交卷，其答案统计数据如下：

此时正确答案也已经出炉，需要统计下每个学生答案正确情况？

请用二维数组结合一维数组知识进行解答。

【有兴趣同学可以解决下九宫图算法！！！！！！！】

八、多维数组

创建三维数组

数据类型变量名[][][];

int arr[][][]=new int[][][]{

{

{1,2,3,4},{4,5,6}

},{

{7,8,9},{10,11,12}

},{

{13,14,15},{16,17,18}

},{

第六讲 枚举算法和数组变量的应用

第六讲 枚举算法和数组变量的应用 本讲任务： 1．知道枚举算法的结构特点、设计步骤和优缺点。 2．不同类型的枚举算法应用举例和上机编程。 3、数组变量的引入，数组组成的要素以及数组的功能和特点。 4、用数组处理批量数据的基本方法。 一、枚举算法相关内容 (1)枚举算法的结构特点 ①枚举法的关键就是列举和检验这两个操作，如图3—1所示。 图3-1列举和检验 ②为了保证对所有可能的情况逐一列举和检验，势必要重复地进行这两个操作，直到所有情况都检验完为止。因此一般用循环结构来实现，如图3—2所示。 图3—2循环检验 ③检验就是对某一给定的条件进行判断，根据判断的不同结果执行不同的操作，所以上图中的“检验”部分可以用分支结构来实现，如图3—3所示。 图3-3用分支实现检验 操作 1

由此可以看出，枚举算法的一般结构是循环结构中嵌套分支结构。其中循环结构用于实现逐一列举，分支结构用于实现检验，列举和检验是循环体中的一部分，当然具体的判断条件和列举内容等应根据实际问题来进行设置。另外一些比较复杂的枚举问题，可能会涉及到循环结构的嵌套。 (2)枚举算法的一般设计步骤 ①确定列举的范围：确定列举的对象的范围，不能随意扩大和缩小列举范围，否则可能会造成多解或漏解后果。 ②明确检验的条件：分析题目，明确检验的对象、检验的条件以及检验后需执行的相关操作；检验的对象可能是循环变量，也可能是其他变量。 ③确定循环控制方式和列举的方式：根据列举的范围，选择合适的方法控制循环；列举的方式是不唯一的，很多时候，可以借助循环变量的变化来进行列举，而有时可能需要通过其他方法来进行列举，如输入等。具体见应用示例中的示例l(求1~2008中，能被37整除的数)。 (3)枚举法的优缺点 枚举法充分利用了计算机快速高效的特点，让计算机进行重复运算，以求得问题的解。由于枚举法是将所有可能的解无一例外地进行检验，因此只要列举正确，枚举法具有非常高的准确性和全面性，然而也正是这个特点决定了枚举法的局限性——效率不高。它的准确性和全面性是以消耗时间为代价获得的。 当然，有些比较复杂的问题可能一时无法找到直接的求解公式，建立有效的数学模型。枚举法的优越性又得以体现。因此，枚举法既有其优越性，又有其局限性。只有认清了这点，我们才能在设计算法时灵活运用，设计出有效、高效的算法。 当然，并不是所有的问题都可以使用枚举算法来寻找答案，仅当问题的所有可能解的个数不太多时，才有可能使用枚举算法，在设计枚举算法时应特别注意时间的消耗问题，当问题可能解的个数较多，所需花费的时间较长时(如需几个月甚至几年乃至更长)，这样的枚举算法是没有实际意义的，换言之枚举法适用于可能解的个数不太多的情况，在可以接受的时间内得到问题的所有解。 (4)几种不同类型的枚举算法 按列举方式可分为以下两种枚举算法。 ①列举的变量和循环变量相关的枚举算法 某些问题中，列举的对象和循环次数之间存在着某种内在的联 系，此时可以直接用循环变量表示，或者由循环变量参与运算得到。 例如求自然数中前25个偶数中所有能被3整除的数，则流程图如 图3—4所示。 其中n是循环变量，用于控制循环，x则用于列举可能的解。 每次循环列举一个可能解，列举的x由循环变量运算得到。当然此 题的列举方式并不唯一，这里只是以此来说明列举的不同方式。 ②列举的变量和循环变量无关的枚举算法 某些问题中，需列举的对象和循环变量间无内在的联系，此时 需使用另外的变量，循环变量则单纯地用于控制循环的次数即列举 的个数。例如，将输入的100个数中的所有正数输出，列举的方式 为输入一个数，循环变量则控制100次循环。图3—4枚举算法流程图 按算法结构可分为以下两种枚举算法。 ①单重循环结构的枚举算法

第6讲数组

第6讲数组 数组是具有相同类型的一组数据。数组按照数组名、数据元素的类型和维数来进行描述。当访问数组中的数据时，可以通过下标来指明。数组具有以下属性。 （1）数组可以是一维、多维或交错的。 （2）数值数组元素的默认值设置为0或空。 （3）数组的索引从0开始：具有n个元素的数组的索引是0～n-1。 （4）数组元素可以是任何类型，包括数组类型。 一、一维数组 1．数组的声明 数据类型[] 数组名 如： int[] myArray; 数组的大小不是其类型的一部分，声明一个数组时，不用管数组长度如何。 2．数组对象的创建 声明数组并不实际创建它们。在C＃中，使用new关键字创建数组的对象。 数组名=new 数据类型[数组大小表达式]; 如： myArray=new int[5]; 此数组包含myArray[0]～myArray[4] new运算符用于创建数组并将数组元素初始化它们的默认值。此例初始化为0。 如： String[] myStringArray=new string[6] 此数组包含myStringArray[0]～myStringArray[5]，数组元素初始化为空。 3．一维数组的初始化 数据类型[] 数组名=new 数据类型[] {初值表}; 例： int[] myArray = new int[]{1,3,5,7,9}; 或 int[] myArray; myArray = new int[]{1,3,5,7,9}; 或 int[] myArray= {1,3,5,7,9}; 4．一维数组元素的访问 数组名[下标] （1）用foreach遍历数组： int[] myArray= {1,3,5,7,9}; foreach (int i in myArray)

第六章：数组

一维数组： 1、定义一个10个元素的整数数组，赋值为1-10，按如下格式输出数组中的全部数据。 a[0]=1 a[1]=2 ………… 2、打印出Fibonacci数列：从第3个数开始的每个数的值为前两个数之和。 1 1 2 3 5 8 …… 3、输入10个学生的成绩到一个数组中，查找出最低分数及最高分数，计算出总分以及平 均分，计算出及格人数以及成绩在平均分以上的人数。 4、有一个数组，内放10个整数。要求找出最小的数和它的下标，然后把它和数组中最前 面的元素对换位置，找出最大的数和它的下标，然后把它和数组中最后面的元素对换位置。 5、利用随机函数产生10个1-100随机数，并存入数组中。 注解：产生随机数的方法 1）包含库文件#include "Stdlib.h" 使用用randomize()随机种子函数及随机数生产函数random(101)，参数表示范围2）使用用randomize()随机种子函数 随机数生产函数rand ()，无参数，产生int数据类型范围内的随机数 6、将数组中所有元素的值向后移动一位，最后一个元素的值移动到第一个元素中；（将数 组中所有元素的值向前移动一位，第一个元素的值移动到最后一个元素中） 7、将数组中元素的值先按原序输出，逆置（第一个与最后一个交换，第二个与倒数第二个 交换，依次类推）后再输出一次； 8、将一个数组中的元素反向复制到另一个数组中，输出这两个数组。 9、编程输入一个小写字母，以该字母为第一个字母按字母表逆序输出字母表中所有小写字 母。（例：输入m ，则输出：mlkjihgfedcbazyxwvutsrqpon）（利用数组或不利用数组两种方式编程） 10、输入一个数，在数组中找到第一个比它大的数，将输入的数据插入到这个数的前面。 11、将两个数组中的元素交叉复制到一个新的数组中。 12、定义一个整数数组，求出奇数和偶数个数 13、有30个0-9之间的数字，分别统计0-9出现的次数 14、用筛选法求100之内的素数 筛选法又称筛法，是求不超过自然数N（N>1）的所有质数的一种方法。据说是古希腊的埃拉托斯特尼（Eratosthenes，约公元前274～194年）发明的，又称埃拉托斯特尼筛子。具体做法是：先把N个自然数按次序排列起来。1不是质数，也不是合数，要划去。第二个数2是质数留下来，而把2后面所有能被2整除的数都划去。2后面第一个没划去的数是3，把3留下，再把3后面所有能被3整除的数都划去。3后面第一个没划去的数是5，把5留下，再把5后面所有能被5整除的数都划去。这样一直做下去，就会把不超过N的全部合数都筛掉，留下的就是不超过N的全部质数。 15、下面的程序从键盘接收任意5个数放入数组A中，假设这5个数为：8 1 4 2 5，则要输 出一个具有如下内容的方阵。 16、十五个猴子围成一圈选大王，依次1-7 循环报数，报到7 的猴子被淘汰，直到最后一

第一讲数组习题

第一讲数组习题 第一讲数组 一、选择题 1.在C语言中，引用数组元素时，其数组下标的数据类型允许是。 A）整型常量 B）整型常量或整型表达式C）整型表达式 D）任何类型的表达式 2.以下对一维整型数组a的正确说明是。 A）int a(10); B）int n=10,a[n]; C）int n; scanf(“%d”,&n); int a[n]; D ) #define SIZ E 10 int a[SIZE];以下能对一维数组a 进行正确初始化的语句 是。 A）int a[10]=(0,0,0,0,0); B）int a[10]={ }; C）int a[ ]={0}; D）int a[10]={10*1}; 4.不是给数组的第一个元素赋值的语句是。 A）int a[2]={1}; B) int a[2]={1*2}; C） int a[2];scanf (“%d”,a); D）a[1]=1; 5．下面程序的运行结果是。* main() {int a[6],i; for(i=1;i3))%5; printf(\} }

A)-4 0 4 0 4 B)-4 0 4 0 3 C)-4 0 4 4 3 D)- 4 0 4 4 0 6．下列定义正确的是。* A） static int a[]={1,2,3,4,5} B) int b[]={2,5} C) int a(10) D) int 4e[4] 7．若有说明int a[][4]={0,0};则下列叙述不正确的 是。 A) 数组a的每个元素都可以得到初值0 B) 二维数 组a的第一维的大小为1 C) 因为对二维数组a的第二维大小的值除以初值个数的商为 1，故数组a的行数 为1 D) 只有元素a[0][0]和a[0][1]可得到初值0，其余元素均得 不到初值 8．设有char str[10]，下列语句正确的是。* A) scanf(\ B) printf(\ C) printf(\ D) printf(\ 9．下列说法正确的是。 A) 在C语言中，可以使用动态内存分配技术定义元素个数可 变的数组 B) 在C语言中，数组元素的个数可以不确 定，允许随机变动

第七讲 数组

第七讲数组 数组是可以同时储存多个同类型数据的单个数据类型，其中所有的数据可以通过数组的下标来访问，并且这些数据在内存中占用的是一块连续的存储空间。数组可以是一维、二维或者三维的。 ●掌握数组的基本概念 ●掌握定义和初始化数组的方法 ●掌握访问数组元素的方法 ●熟练使用System.Array 类的属性和方法 一、一维数组 一维数组的定义 ： 数组必须“先定义，后使用”。定义一维数组的格式如下： 数据类型[] 数组名; 如int[] x; 注意：数据类型可以是任意数据类型，包括数值类型和引用类型； 数组名命名遵循C#变量命名规则； int[] arry;//定义了一个名为arry的数组，这个数字可以存放多个整数，但是此时并没有为存储变量在内存中分配空间。 定义数组和C语言的区别： C语言中：数据类型数组名[数组长度];在定义中包含了数组元素个数，这种定义意味着内存事先按数组长度分配空间，而C# 事先并不为数组元素分配空间，而是在使用数组的过程中动态的分配数组元素的个数，控制数组占用的内存的大小。 一维数组的初始化： 在C#语言中，定义数组后必须对其初始化（为数组分配空间）才能使用。初始化有两种方法：静态初始化和动态初始化。 1.静态初始化 如果数组包含元素不多，且初始数组元素已知，则可以采用静态初始化方法。 数据类型[] 数组名={元素1,元素2，元素3，。。。。。。。，元素n}； 无需说明数组个数，系统自动计算分配数组所需的内存空间。 Int[] arry={1,2,3,4}; String[] str={“china”,”American”,”Korea”};

2.动态初始化 需要使用new 关键字将数组实例化一个对象，再为该数组对象分配内存空间，并为数组元素赋初值。 格式：数据类型[] 数组名；// 数组定义 数组名=new 数据类型[表达式]; //数组动态初始化 或者 数据类型[] 数组名= new 数据类型[表达式]; “表达式”代表数组长度，为整型表达式。 New 运算符用来为数组对象在内存中分配一定的空间。数据占据的内存空间由数组的数据类型和表达式的数值共同决定。 int[] arry;//定义一个名为arry的数组。 arry=new int[10];//为arry数组在内存中分配4*10=40个字节的存储空间，元素值为0. 或 int[] arry=new int[10];//定义一个名为arry的整型数组，并为其分配40个字节的空间。 也可以在初始化得同时赋其他初始值。 Int[] arry=new int[] {1,2,3,4}; 注意：在数组初始化语句中，如大括号中已经明确列出了数组中的元素值，即确定了数组元素个数，则数组元素的个数（方括号中的数值）必须为常量，并且与数组元素个数一致。 Int i=4; Int[] x=new int[4]{1,2,3,4} Int[] y=new int[4] {1,2,3} Int[] z=new int[i]{1,2,3,4} 利用动态初始化的方法，可以动态的修改数组的长度： int[] x=new int[5]; int n=10; x=new int[n]; 一维数组元素的引用： 格式：数组名[下标]； 例：给定10个数字：3，5，34，65，15，74，28，59，122，42，将它们存放在一个数组中，并将其按从小到大的顺序输出。 选择法：先找出10个数中最小数的数组元素位置，将此最小数与数组中的第一个元素对调；再从第2个数到第10个数中找出最小数，按同样的办法，将次最小数与第2个位置上的数对调。 using System; using System.Collections.Generic; using System.Text;

第5章 数组c语言老师讲的不错

第5章数组 学习目标 ◆掌握数组的概念 ◆掌握一维数组的使用 ◆掌握二维数组的使用 在前面所学的章节中，所使用的数据都属于基本数据类型，除此之外，C语言还提供了构造类型的数据，构造类型的数据包括数组类型、结构体类型和共用体类型。本章就针对其中的数组类型进行讲解。 5.1 什么是数组 在程序中，经常需要对一批数据进行操作，例如，统计某个公司100个员工的平均工资。如果使用变量来存放这些数据，就需要定义100个变量，显然这样做很麻烦，而且很容易出错。这时，可以使用x[0]、x[1]、x[2]……x[99]表示这100个变量，并通过方括号中的数字来对这100个变量进行区分。 在程序设计中，使用x[0]、x[1]、x[2]……x[n]表示的一组具有相同数据类型的变量集合称为数组x，数组中的每一项称为数组的元素，每个元素都有对应的下标（n），用于表示元素在数组中的位置序号，该下标是从0开始的。 为了大家更好地理解数组，接下来，通过一张图来描述数组x[10]的元素分配情况，如图5-1所示。 图5-1数组x[10] 从图5-1中可以看出，数组x包含10个元素，并且这些元素是按照下标的顺序进行排列的。由于数组元素的下标是从0开始的，因此，数组x的最后一个元素为x[9]。 需要注意的是，根据数据的复杂度，数组下标的个数是不确定的。通常情况下，数组元素下标的个数也称为维数，根据维数的不同，可将数组分为一维数组、二维数组、三维数组、四维数组等。通常情况下，我们将二维及以上的数组称为多维数组。 5.2 一维数组 5.2.1一维数组的定义与初始化 一维数组指的是只有一个下标的数组，它用来表示一组具有相同类型的数据。在C语言中，一维数组的定义方式如下所示： 类型说明符数组名[常量表达式]; 在上述语法格式中，类型说明符表示数组中所有元素的类型，常量表达式指的是数组的长度，也就是 1