java基础篇之6----优化后的冒泡排序、插入排序、选择排序；多维数组及其拷贝

（一）排序：
这里所说的三种排序都是内部排序： 冒泡排序，插入排序，选择排序
1： 冒泡排序：
冒泡排序使之将相邻的两个数值相互比较，第一个数值比第二个大就交换位置，将最大的数值沉到最底下， 每一次这样循环一次之后都会有一个最大的数在后面，每确定一个最大的数，那个数在最后面不动它，这是内循环 然后将外循环的次数减少一次。

// 优化后的冒泡排序
// 最好情况时间复杂度：o(n)
// 最坏情况时间复杂度：o(n^2)
// 稳定性：稳定

 public static int[] bubbleSout(int[] array) {
        int i, j;  
        boolean swap = false;
        for (i = 0; i < array.length - 1; i++) {    //    用  i   控制外层循环
            for (j = 0; j < array.length - 1 - i; j++) {    //    用    j    控制内层循环，j< array.length-1-i;  是因为，再次排序之后内循环的次数要减少一次
                if (array[j] > array[j + 1]) {   //    如果前面的数大于后面的数，二者交换位置
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                    swap = true;      //  此处使用boolean变量来检查是否第一遍循环过程是否交换过数值，也就是说检验原始数据是否已经是有序数据
                }
            }
            if (swap) {   //优化代码     //   如果swap没有变换，说明原始数据是有序数据，
                break;
            }
        }
        return array;
    }

(2) : 插入排序：
插入排序从下表为1 的数值开始，依次和前面的数比较大小，大的数依次往后挪，小的数直接将要排序的数放到这个数后面
//插入排序
// 最好情况时间复杂度：o(n)
// 最坏情况时间复杂度：o(n^2)
// 稳定性：稳定

  public static int[] insertSort(int[] array) {  
        int i, j;
        int temp;
        for (i = 1; i < array.length; i++) {   //  用   i  控制外层循环
            temp = array[i]; 			//	将用插入比较的值放到temp 临时变量中去
            for (j = i - 1; j >= 0; j--) {			//   用   j    控制内层循环，依次向前走
                if (array[j] > temp) {      //     如果temp小于当前数值，
                    array[j + 1] = array[j];			//就将大的数往后挪
                } else {    
                    break;          //     如果不是，则停止循环
                }
            }
            array[j+1] = temp;			//     直接将temp也就是要插入的数放到该数后面
        }
        return array;
    }

(3): 选择排序:
选择排序相对简单一些，就是讲数字依次与后面的数值比较，将大的换到后面，小的挪到前面。
//选择排序
// 最好情况时间复杂度：o(n^2)
// 最坏情况时间复杂度：o(n^2)
// 稳定性：不稳定

public static int [] selectSort(int [] array) {
 int i, j;
        for (i = 0; i < array.length; i++) {
            for (j = i + 1; j < array.length; j++) { 
                if (array[i] > array[j]) {    //      每一次循环结束后都有一个小的数字放到前面去。
                    int temp = array[j];
                    array[j] = array[i];
                    array[i] = temp;
                }
            }

        }
        return array;
}

二： 多维数组：
（1）：
多为数组同一维数组一样，在使用new初始化之前，并不能使用它，
声明一个多位数组：
数据类型 [ ] [ ] balance =new 数据类型 [ ] [ ] ；
（2）： 初始化：
对于规则的基本类型多维数组，初始化为0；
对于引用类型的多维数组，初始化为null；

/   /数组的静态初始化
		int[][] a= {{1,2,3},{4,4,4},{5,5,5}};
		//数组的动态初始化
		int[][] b=new int[3][];  
		a[0] = new int[2];
		a[1] = new int[2];
		a[2] = new int[2];
		
		a[0][0]=0;
		a[0][1]=0;
		a[1][0]=1;
		a[1][1]=1;
		a[2][0]=2;
		a[2][1]=2;

（2）：多维数组的打印：
调用Arrays.deepToString( ); 方法；不过需要注意的是，如果不是基本数据类型，只能打印出地址；
（3）： 四种拷贝方式对多维数组的拷贝都属于浅拷贝：
一张图解析：
第一层数组只是存储了第二层数组的地址，所以此处的尽管使用for循环拷贝，System.arraycopy()方法、clone（）方法、Arrays.copyof（）方法都只是将第一层数组内储存的地址值引用过来，所以都是浅拷贝。

public static void main9(String[] args) {
        TestArray[] t1 = new TestArray[4];
        t1[0] = new TestArray();
        t1[1] = new TestArray();
        t1[2] = new TestArray();
        t1[3] = new TestArray();
        //   使用copyOf方法拷贝引用类型的数组：
        TestArray[] t2 = Arrays.copyOf(t1,t1.length);
        //   用arraycopy方法
        TestArray[] t3 = new TestArray[4];//t2[0]
        //用clone方法拷贝数组
	   System.arraycopy(t1,0,t3,0,t1.length);
   		 TestArray[] t4 = t1.clone();//t4[0]     	
   		 // 用for循环拷贝数组
   		 TestArray[] t5 = new TestArray[4];//t2[0]
        for(int i = 0;i < t1.length;i++) {
            t5[i] = t1[i];
        }
    }