数组，Arrays类，冒泡排序，稀疏数组

 

数组可以用Arrays类做一些操作，比如排序Arrays.sort()等

 

冒泡排序

依次对比数组中相邻两个数，大的向后排，小的向前排，对比数组的length次，即全部对比完

public static void mysort(int[] t){
        int temp;
        for (int i = 0; i < t.length; i++) {
            //因为下面比较大小需要用到相邻的两个数即j+1,所以下面j要小与t.length-1,
            //-i 是因为每执行一次会把最大的数放到最后，后面就不用再执行最后一次比较
            for (int j = 0; j < t.length-1-i; j++) {
                if(t[j]>t[j+1]){
                    temp = t[j+1];
                    t[j+1] = t[j];
                    t[j] = temp;
                }
            }
        }
    }

 

稀疏数组

把一个较为复杂的数组压缩成精简一点的数组，但是我感觉比较试用二维数组中大部分值都为默认值0的情况，要是每个数都有值的话，感觉也压不起来。。。

稀疏数组的第一行第一列表示原数组的行数，第一行的第二列表示原数组的列数，第一行的第三列表示原数组有效值个数，

第二行第一列表示第一个有效值的行数，第二列表示第一个有效值的列数，第三个表示有效值的值

第三行第一列表示第二个有效值的行数，第二列表示第二个有效值的列数，第三个表示有效值的值

依次类推

//设置原数组行数类书
int[][] arrays = new int[11][11];
        //设置有效值
        arrays[1][2] = 1;
        arrays[2][3] = 2;
        //统计有效值个数
        int sum = 0;
        for (int i = 0; i < arrays.length; i++) {
            for (int j = 0; j < arrays[i].length; j++) {
                System.out.print(arrays[i][j] + "\t");
                if(arrays[i][j] != 0 ){
                    sum++;
                }
            }
            System.out.println();
        }
        System.out.println("===========================");
        //转化为稀疏数组，sum为有效值个数，稀疏数组还有第一行的原数组行列数，所以行数要加1
        int[][] zlarrays = new int[sum+1][3];
        //设置稀疏数组第一行数据
        zlarrays[0][0]=11;
        zlarrays[0][1]=11;
        zlarrays[0][2]=sum;
        //设置稀疏数组有效值数据
        int count = 0;
        for (int i = 0; i < arrays.length; i++) {
            for (int j = 0; j < arrays[i].length; j++) {
                if(arrays[i][j]!=0){
                    count++;
                    zlarrays[count][0] = i;//有效值行
                    zlarrays[count][1] = j;//有效值列
                    zlarrays[count][2] = arrays[i][j];//有效值
                }
            }
        }
​
        for (int i = 0; i < zlarrays.length; i++) {
            for (int j = 0; j < zlarrays[i].length; j++) {
                System.out.print(zlarrays[i][j]+"\t");
            }
            System.out.println();
        }
        System.out.println("=================================");
        //还原数组行列值
        int[][] hyarrays = new int[zlarrays[0][0]][zlarrays[0][1]];
        //稀疏数组第一行是行列，所以还原值从第二行开始
        for (int i = 1; i < zlarrays.length; i++) {
            hyarrays[zlarrays[i][0]][zlarrays[i][1]] = zlarrays[i][2];
        }
        for (int i = 0; i < hyarrays.length; i++) {
            for (int j = 0; j < hyarrays[i].length; j++) {
                System.out.print(hyarrays[i][j]+"\t");
            }
            System.out.println();
        }