20171203：数组拷贝、三种重要排序（冒泡、插入、快排）、二维数组的学习

一、数组的拷贝（数组拷贝的方法十分简单，Lsit集合在实现它时用到了这个所以得知道这个）

方法：System.arraycopy(参数);

参数有：源数组，源数组的起始位置，目标数组，目标数组的起始位置，复制的元素个数，

运行一下：

package 数组拷贝;

import java.util.Arrays;

public class ArrayCopy {
	
	public static void main(String[] args) {
		
		int[] a = {1,2,3,4,5,6,7,8,9};
		int[] b = {0,0,0,0,0,0,0,0,0};
		System.arraycopy(a,0,b,0,9); //参数为：源数组、源数组的起始位置、目标数组、目标数组的起始位置、复制元素的个数
		Arrays.toString(b);
	}
	
	
}

二、三种重要排序（排序的都先设为整型数组中的数据）

2.1 冒泡排序

冒泡排序的主要思想是“两两比较，大数冒到最后边去”，两层循环，外层循环控制“冒泡”的次数：共n-1次，内层循环控制比较的次数，和每次需要比较的数的下标

具体代码如下：

//整一个冒泡排序:3,5,1,9,4,8,7,2
	public static void bubbleSort1(int a[]){
		
		for(int i=1;i<=a.length-1;i++){  //外层循环控制比较的次数，i从1开始主要是为了在内层比较时，
			for(int j=0;j<a.length-i;j++){ // j控制内层循环的下标，同时控制元素每次循环时冒泡到的位置
				if(a[j]>a[j+1]){
					int temp = a[j];
					a[j] = a[j+1];
					a[j+1] = temp;
				}
			}
			System.out.print("第"+i+"趟排序");
			System.out.println();
			for(int x : a){
				System.out.print(x+"  ");
			}
			
		}
	}

运行结果为：

这个冒泡排序是最直接的排序，但这个方法的缺点就是如果在某次循环完成结束以后（比如上述的第六次排序）由于循环尚未结束，导致进行了几次无用的比较，因此，应该想一个办法，在某次排序完成以后判断是否排序完成，这样就可以避免重复无用的循环比较：可以在外层循环加一个标志位，只要程序进入内层循环中的条件判断就表明冒泡尚未完成，继续循环，如果一次也未进入说明排序完成，跳出循环即可，因此，改进之后的代码为：

//改进版的冒泡排序，能够在某次已经排好序之后，结束比较
	public static void bubbleSort2(int a[]){
		
		for(int i=1;i<=a.length-1;i++){  //外层循环控制比较的次数
			
			boolean flag = true; //建立一个标志位
			for(int j=0;j<a.length-i;j++){ // j控制内层循环的下标，同时控制
				if(a[j]>a[j+1]){
					int temp = a[j];
					a[j] = a[j+1];
					a[j+1] = temp;
					flag=false;  //改变标志位
				}
			}
			
			if(flag){
				break;
			}
			
			System.out.print("第"+i+"趟排序");
			
			for(int x : a){
				System.out.print(x+"  ");
			}
			System.out.println();
		}
	}

运行结果为：

改进之后，代码的效率明显提升，但是要注意，这个改变并没有在某次循环完成之后立即结束，而是又进行了一次循环判断，结果由于没有进入到if判断，标志位未发生改变导致flag为true，所以跳出了循环

2.2插入排序

插入排序的思想是将每一个待排序的元素看成一个“指示灯”元素，该元素前面的序列为有序序列（所以循环应该从数组的第二个元素开始），将该“指示灯”元素挂起来，和它前面的有序序列进行比较，比它大的元素就后移，直到找到比它小的元素，放在该元素后面即可，具体实现代码如下：

 //插入排序
	public static void insertSort1(int[] a){
		
		for(int i=1;i<=a.length-1;i++){
			int data=a[i];  //获取当前“指示灯元素”
			int j=i-1;  //获取当前“指示灯元素”前面的元素的下标
			while(j>=0 && a[j]>data){  //当指示灯元素前面的元素比指示灯元素大时，前面的元素后移
				a[j+1] = a[j];
				j--;
			}
			a[j+1] = data;
		}
	}

我自己也实现了一种方法：

public static void insertSort2(int[] a){
		
		for(int i=1;i<=a.length-1;i++){ 
			for(int j=i-1;j>=0;j--){ //内层循环直接拿“指示灯元素”它前面元素进行比较，比它大就交换，同时指示灯元素位置-1
				if(a[j]>a[i]){
					int temp = a[i];
					a[i] = a[j];
					a[j] = temp;
					i--;
				}
			}
		}
	}

2.3快速排序

快速排序是排序方法中较为复杂的一种方法，但效率却是极其高的，能够在很短的时间里将顺序排好

快速排序的基本思想：

1.从序列中找到一个基准元素（一般为数组的第一个元素）

2.重新排列序列，所有比基准元素小的元素放在基准元素前面，比基准元素大的放在基准元素后面，分区结束后基准元素在中间，左边是比它小的元素，右边是比它大的元素，

3.递归的将小于基准值的子序列和大于基准值的子序列排序

4.知道序列的大小是0或1表明排序完成

//快速排序
	public static void quickSort(int[] a,int low,int high){
		//递归出口
		if(low>=high){
			return;
		}
		
		int data=a[low]; //找到基准元素
		//拿两个指向去寻找对应元素（i去找比基准元素大的，j寻找比基准元素小的）
		int i=low+1;
		int j=high;
		
		//交换操作，
		while(i<=j){
			
			//for(;i<=high && a[i]<data;i++);
			//for(;j>=low+1 && a[j]>data;j--);
			
			while(i<=high && a[i]<data) i++;
			while(j>=low+1 && a[j]>data) j--;
			if(i<j){
				int temp=a[i];
				a[i]=a[j];
				a[j] = temp;
			}
		}
		//while循环在j和i的大小关系发生改变之后即此时j<i,此时将a[j]与基准元素交换即可
		a[low] = a[j];
		a[j] = data;
		quickSort(a, 0, j-1);
		quickSort(a, j+1,high);
		
	}

三、二维数组的学习

3.1二维数组：

二维数组的声明与实例化：

数据类型[]][] 数组名 = new 数据类型[行数][列数];

注：1.二维数组的长度是二维数组包含的一维数组的个数

2.二维数组的访问：数组名 [行号][列号]

3.二维数组在实例化时已经有了初值，初值根据定义的类型而定;但在静态实例化时只有赋值的位置才有值，其他位置没有初值

3.2二维数组的静态实例化

3.3二维数组的遍历