Java数组的基础知识（二）及几种排序方法

数组：

1. 数组创建时必须知道大小（知道分配多少空间）
2. 数组是有角标的，角标从0开始到长度-1为止
3. 数组一旦创建就不能改变其大小（内存溢出）
4. 数组是一个对象

//静态数组
int[] array2 = {1,2};
//动态数组
int[] array = new int[2];      //所有字符串未赋值之前都是null
array[0] = 1;
array[1] = 2;

4. 对于容器的操作，一般分为三种操作类型：定位、替换、求长。

• 定位、替换、求长：

int[ ] arrays = new int[6];

//1.定位
int item1 = arrays[4];
//int item2 = arrays[6];     越界
int item3 = arrays[-1]; 

//2.替换
arrays[3] = 100;

//3.求长
int length = arrays.length;

5. 反转、遍历、求和、求最值：

//1.数组反转：

  //1）空间效率高，在原有位置上做反转，不新建新的数组
for (int i = 0;i < l/2;i++) {
	int temp = arrays[i];
	arrays[i] = arrays[l - 1 - i];
	arrays[l - 1 - i] = temp;
}

  //2）时间效率高，新建数组做反转
int[] result = new int[l];
for (int i = 0;i < l;i++) {
	result[i] = arrays[l-1 - i];
}

//2.数组遍历

  //1）
for (int i =0;i < l;i++) {
	System.out.print(arrays[i]+"\t");
	System.out.print(result[i]+"\t");
}

  //2）增强for循环：for each 
for (int item : result) {
	System.out.print(item+"\t");
}

//3.遍历求和
int[] arr = {1,2,3,4,5,6,7};
int sum = 0;
for (int item : arr) {
	sum = sum + item;
}
System.out.println(sum);

//4.求最值
int[] arrs = {1,8,4,4,5,16,7};
int max = arrs[0];        //或者求最小值，min此时设置为最大值
int index = 0;
for (int i = 0;i < arrs.length;i++) {
	if (max < arrs[i]) {
		max = arrs[i];
		index = i;
	}
}
System.out.println(max+","+index);

6. 几种排序方法(直接、选择、冒泡、插入、快速）：

（1）直接排序：

//两个for循环的嵌套，外层for循环确定循环中需要替换的位，内层负责比较
for (int i = 0;i < arrays.length;i++) {
	for (int j = i;j < arrays.length;j++) {
		if (arrays[i] < arrays[j]) {
			int temp = arrays[i];
			arrays[i] = arrays[j];
			arrays[j] = temp;
		}
	}
}

（2）选择排序（数据量小时）：

for (int i = 0;i < arrays.length;i++) {
	int max = arrays[i];
	int index = i;
	for (int j = i;j < arrays.length;j++) {
		if (max < arrays[j]) {
			max = arrays[j];
			index = j;
		}
	}
	max = arrays[i];
	arrays[i] = arrays[index];
	arrays[index] = max;
}

（3）冒泡排序：

for (int i = 0;i < arrays.length;i++) {
	for (int j = 0;j < arrays.length-1 - i;j++) {
		if (arrays[j] < arrays[j + 1]) {
			int temp = arrays[j];
			arrays[j] = arrays[j + 1];
			arrays[j + 1] = temp;
		}
	}
}

（4）插入排序：

for (int i = 1;i <= arrays.length;i++) {
	for (int j = i;j > 0;j--) {
		if (arrays[j] < arrays[j-1]) {
			int temp = arrays[j];
			arrays[j] = arrays[j-1];
			arrays[j-1] = temp;
		}else{
			break;
		}
	}

（5）快速排序：

//1、不立即交换
//设置基准数
int left = start;     //左游标找比基准数大的
int right = end;      //右游标找比基准数小的
int temp = arr[left];
while(left < right) {     //因为基准数在左边，所以右游标先启动
      while(arr[right] >= temp && left < right) {
			right--;
	   }   		    
	 //左哨兵启动
	 while(arr[left] <= temp && left < right) {
		   left++;
	 }    
	 //交换
	 int t = arr[left];
	 arr[left] = arr[right];
	 arr[right] = t;
}
	//将相遇位置的元素放到基准数的位置
	arr[start] = arr[left];
	arr[left] = temp;
	//左右再来一遍
	quickSort(arr,start,left-1);
	quickSort(arr,left+1,end);
}

//--------------------------------------

//2、立即交换
int left = start; 
int right = end; 
int temp = arr[left];		
while(left < right) {
	  while(arr[right] >= temp && left < right) {
			right--;
	  }	   
	  //立即交换
	  arr[left] = arr[right];     
	  while(arr[left] <= temp && left < right) {
		    left++;
	  }		
	  //立即交换
	  arr[right] = arr[left]; 	    
}
arr[left] = temp;            //1、2	
quickSort(arr,start,left-1);
quickSort(arr,left+1,end);

注： 当基准数在左边时，先移动右游标；当基准数在右边时，先移动左游标。正常移动后，左右游标会在基准数应该归位的位置上相遇，非正常移动后则刚好在这个位置的旁边一位相遇，导致排序错误。

（6）基于桶排序统计元素重复次数：

int max = Collections.max(list);     //查找列表中最大、小的元素
int min = Collections.min(list);
int[] array = new int[max - min + 1];     //创建一个新的数组存储排序后的数字   
for(int item : list) {     //遍历列表，统计元素重复次数
	array[item - min]++; 
String result = "";
for(int i = 0;i < array.length;i++) {
	if(array[i]!=0) {
		result += i + min + "(" + array[i] + ")"+"   ";
	}
}
System.out.println(result);

---

二维数组：

二维数组是由一维数组拼接而成的连续的空间

1.数组的动态初始化过程:不能没有行号，可以没有列号

int[][] arrays = new int[5][5];
int[][] arrays = new int[5][ ];    //ok
int[][] arrays = new int[ ][5];      //error

2.数组的静态初始化过程

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

3.二维数组的遍历 00 01 10 11 20 21

int[][] arr = {{1,2},{3,4},{5,6}};
for (int i = 0;i < arr.length;i++) {
	for (int j = 0;j < arr[i].length;j++) {
		System.out.print(arr[i][j]+" ");
	}
	System.out.println();
}