数组扩展（冒泡排序，稀疏数组）

1、冒泡排序（复杂度o2）

　　冒泡排序的算法的原理如下： 

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。 
   
2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。 
   
3. 针对所有的元素重复以上的步骤，除了最后一个。 
   
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。 

int[] arrays ={3,2,1,5,6};
        int temp =0;

        for (int i = 0; i < arrays.length-1; i++) { //确定比较次数
            for (int j = 0; j < arrays.length-1-i; j++) { //每次需要比较的次数
                if (arrays[j]>arrays[j+1]){
                    temp = arrays[j];
                    arrays[j] = arrays[j+1];
                    arrays[j+1] = temp;
                }
                if (temp == 0){
                    break;
                }
            }
        }
        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i]);
        }

2、稀疏数组（压缩）

把这样没有价值的数据起来，不但会浪费存储空间的大小，如果写入到磁盘中，还会增大 IO 的读写量，影响性能，这就是用普通二维数组来表示棋盘数据的不足之处。所谓稀疏数组，从字面上我们也可以得知，它仍然是一个数组，他的作用就是将一个对应的数组数据进行优化。

 

int[][] arrays =new int[11][11];
        int sum=0;
        arrays[1][1]=1;
        arrays[2][2]=2;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                System.out.print(arrays[i][j]+"\t");
                if (arrays[i][j]!=0){
                    sum++;
                }
            }
            System.out.print("\n");
        }
        //转化为稀疏数组
        System.out.println("=========================");
        int[][] arrays1 =new int[sum+1][3];
        arrays1[0][0]=11;
        arrays1[0][1]=11;
        arrays1[0][2]=3;
        int count=0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (arrays[i][j]!=0){//难点
                    count++;//难点
                    arrays1[count][0]=i;
                    arrays1[count][1]=j;
                    arrays1[count][2]=arrays[i][j];
                }
            }
        }
        for (int i = 0; i < sum+1; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.print(arrays1[i][j]+"\t");
            }
            System.out.println();
        }
        System.out.println("=========================");
        //将稀疏数组转化为原来的数组
        int[][] arrays2 = new int[arrays1[0][0]][arrays1[0][1]];
        for (int i = 1; i < arrays1.length; i++) {
            arrays2[arrays1[i][0]][arrays1[i][1]]=arrays1[i][2];//难点
        }
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                System.out.print(arrays2[i][j]+"\t");
            }
            System.out.println();
        }