数组和查找排序

数组的定义

数组是一个变量，存储相同数据类型的一组数据。

如何使用数组

使用数组四步走：

0. 声明数组      int [ ] a；

1. 分配空间      a=new int [ 5 ]；

2. 赋值             a [ 0 ]=8；

3. 处理数据      a [ 0 ]=a[ 0 ]*10；

声明数组

语法

数据类型      数组名 [  ]；

数据类型 [  ]     数组名；

分配空间

声明数组并分配空间

数据类型 [  ]  数组名 = new  数据类型 [ 大小 ]；

数组赋值

赋值

方法一：边声明边赋值

public static void main(String[] args) {
	int[] a = {4, 1, 5, 3, 6, 2}
	//冒泡排序：
    	//第一重循环表示要冒泡的次数，注意数组越界问题...
	for(int i=0; i<a.length-1; i++){
		for(int j=0; j<a.length-1-i; j++){
			if(a[j] > a[j+1]){  //将每相邻的两个数相比
				int t = a[j];
				a[j] = a[j+1];
				a[j+1] = t;
			}
		}
	}
}

int [] score={12,21,121};
int [] score=new int []{12,21,121};

方法二：动态地从键盘录入信息并赋值

Scanner input = new Scanner(System.in);
for(int i=0;i<30;i++){
    score[i] = input.nextInt();
    }

使用数组求平均值

方法一：

int [] score = { 1,2,3,4,5};
double avg;
avg=(score[0]+score[1]+score[2]+score[3]+score[4])/5;

方法二：

int []score = {1,2,3,4,5} ;
int sum = 0;
double avg;
for(int index=0;index<score.length;index++){
sum = sum+score[index];
}
avg = sum/score.length;

二维数组初始化

int books[][] = {{12,21},{22,22},{32,23},{42,24}};
int[][]arr = new int[][]{{1,2,3},{4,5,6}};

二维数组示例

int i,j;
int[][] student = new int[3][2];
Scanner in = new Scanner(System.in);
for(i=0;i<3;i++){
System.out.print("\n输入学号"+(i+1)+"两个学期的成绩：");
for(j=0;j<2;j++)
student[i][j]=in.nextInt();
}
System.out.print("\n 学员的学号及其两个学期的成绩为：\n ");
System.out.print("\n \t学号\t第一学期\t第二学期");
for(i = 0;i < 3;i++)
{
 System.out.print("\n\t");
 System.out.print ((i+1) +"\t");
    for(j = 0;j < 2;j++) System.out.print(student[i][j]+"\t\t");
 System.out.print("\n ");
}
}

总结

0. 数组是可以在内存中连续存储多个元素的结构，数组中的所有元素必须属于相同的数据类型；

1. 数组必须先声明，然后才能使用。声明一个数组只是为该数组留出内存空间；

2. 数组的元素通过数组下标访问；

3. 一维数组可用一个循环动态初始化，而二维数组可用嵌套循环动态初始化；

4. 二维数组可以看作是由一维数组的嵌套而构成的。

冒泡排序

基本思想：

依次比较相邻的两个数，将小数放在前面，大数放在后面；

继续重复第一步，直至比较最后两个数。

算法描述

冒泡排序算法的Java实现

public static void main(String[] args) {
    int[] a = {4, 1, 5, 3, 6, 2}
    //冒泡排序：
    //第一重循环表示要冒泡的次数，注意数组越界问题...
for(int i=0; i<a.length-1; i++){
	for(int j=0; j<a.length-1-i; j++){
		if(a[j] > a[j+1]){  //将每相邻的两个数相比
		int t = a[j];
		a[j] = a[j+1];
		a[j+1] = t;
	  }
       }
    }
}

顺序查找

基本思想：

一个一个找，直到找到匹配的元素或者直到找到最后一个元素为止，这就是“顺序查找”（Sequential Search）

顺序查找的Java实现

public static void main(String[] args) {
    int[] list = new int[] { 1, 5, 3, 6, 10, 55, 9, 2, 87, 12, 34 };
    int i, key = 12;       //设要查找的数字是12
    for ( i = 0; i < list.length; i++) {
        if (list[i] == key){
            break;
        }
    }
    if(i < list.length) {
        System.out.println("list[" + i + "] = " + key);
    } else {
        System.out.println("没找到！");
    }
} 

二分查找

基本思想：

将有序数列的中点设置为比较对象，如果要找的元素值小于该中点元素，则将待查询序列缩小为左半部分，否则为右半部分。即通过一次比较，将查找区间缩小一半。这就是二分查找，又叫折半查找（Binary Search）。

算法图示

二分查找的Java实现

public static void main(String[] args) {
	int[] list = { 1,3,6,10,33,47,55,75,87 };
	System.out.println("有序数组如下");
	for(int i=0; i<list.length; i++){
		System.out.print(list[i]);
	}
	
	int low = 0;
	int high = list.length - 1;
	int index = -1;
	int key;
	Scanner in=new Scanner(System.in);
	System.out.print("\n待搜索数字是: ");
	key = in.nextInt();
	
	//二分查找算法，见如下代码
}
  while(low <= high){	
      int mid = (low+high) / 2;
      if (key == list[mid] ) {
	index = mid;
	break;
      }else if( key > list[mid] ){
	low = mid + 1;	
      }else{
	high = mid - 1;
      }
  }
  if(index == -1){
     System.out.println("没找到");
  }else{
     System.out.println("list[" + index + "]=" + key);
  }