排序算法

冒泡排序

1. 比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换它的位置
2. 每一次比较，都会产生一个最大，或者最小的数字
3. 下一轮则可以减少一次排序
4. 一次循环直到结束

代码实现

    public static int[] T(int[] a){  //名为T的冒泡排序
        int Y = 0;//临时变量

        for (int Q = 0;Q<a.length-1;Q++){ //列表多少个元素，循环次数的作用
            for (int W = 0;W<a.length-1-Q;W++){ //每次循环减少，循环次数
                if (a[W]>a[W+1]){//比大小
                    Y = a[W] ; //大的值赋给临时变量
                    a[W] = a[W+1] ; //小的值前移
                    a[W+1] = Y ; //大的值赋给后面
                }
            }
        }
        return a ;
    }

完整代码

public class Demo1 {
    public static void main(String[] args) {
    int [] a = {1,3,4,2,5,6,9,7} ;
    Text(T(a)) ;
    }


    public static int[] T(int[] a){  //名为T的冒泡排序
        int Y = 0;//临时变量

        for (int Q = 0;Q<a.length-1;Q++){ //列表多少个元素，循环次数的作用
            for (int W = 0;W<a.length-1-Q;W++){ //每次循环减少，循环次数
                if (a[W]>a[W+1]){//比大小
                    Y = a[W] ; //大的值赋给临时变量
                    a[W] = a[W+1] ; //小的值前移
                    a[W+1] = Y ; //大的值赋给后面
                }
            }
        }
        return a ;
    }

    public static void Text (int[] a){
        for (int b = 0 ;b<a.length;b++){  //遍历数组元素显示
            System.out.print(a[b] + "\n");
        }
    }

}

稀疏数组

定义

当一个数组中大部分的元素为0，或为同一个值的数组时，可以使用稀疏数组来保存该数组。

代码

打印输出二维数组

public class Demo1 {
    public static void main(String[] args) {
        /** 创建一个原始的二维数组(11行11列)
         0:表示没有棋子
         1:表示黑子
         2:表示白子*/
        int Arrays[][] = new int[11][11];
        Arrays[10][2] = 1;
        Arrays[3][3] = 2;

        System.out.println("最初的二维数组为:");

        int Value = 0;
        for (int row = 0;row < Arrays.length;row++) {//循环行（遍历）
            for (int column =0;column < Arrays[row].length;column++) {//循环列（遍历）
                System.out.printf("%d\t", Arrays[row][column]);//遍历数组输出 , %d表示转为十进制数，\t是制表符
                Value ++ ;
            }
            System.out.println();
        }
        System.out.println("=================================");
        int[][] Array1 =new  int[Value+1][3];

        int Time = 0 ;
        for (int row = 0;row < Arrays.length;row++) {//循环行（遍历）
            for (int column = 0; column < Arrays[row].length; column++){//循环列（遍历）
                if(Arrays[row][column] != 0){
                    Array1[Time][0] = row;
                    Array1[Time][1]= column;
                    Array1[Time][2] = Arrays[row][column];
                    Time ++ ;
                }
            }
        }

        System.out.println("稀疏数组");

        Array1[3][0] = 11;
        Array1[3][1] = 11 ;
        Array1[3][2] = 2 ;
        for (int i = 0;i<Array1[i].length;i++){
            System.out.println(Array1[i][0] + "\t"+ Array1[i][2] + "\t" + Array1[i][2] + "\t");
        }

    }
}

输出结果：