25、冒泡排序、稀疏数组

冒泡排序

public class ArrayDemo15 {
    public static void main(String[] args) {
        int[] a = {5,1,6,8,9,10,345,245,-6};
        int[] sort = bubbleSort(a);
        System.out.println("冒泡排序：" + Arrays.toString(sort));
    }

    //冒泡排序
    public static int[] bubbleSort(int[] array) {
        //定义一个临时变量
        int temp = 0;
        //外层循环，判断这个要走多少次
        for ( int i = 0; i < array.length - 1; i++ ) {
            //通过flag标识减少没有意义的比较
            boolean flag = false;
            //内层循环，比较两个数，如果第一个数大于第二个数，则交换位置
            for ( int j = 0; j < array.length - 1 - i; j++ ) {
                if ( array[j] > array[j+1] ) {
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                    flag = true;
                }
            }
            if ( flag == false ) {
                break;
            }
        }
        return array;
    }
}

稀疏数组

1、介绍

2、五子棋案例

public class ArrayDemo16 {
    public static void main(String[] args) {
        /*
            * 初始化二维数组
             * <p>
             *     0 0 0 0 0 0 0 0 0 0 0
             *     0 0 1 0 0 0 0 0 0 0 0
             *     0 0 0 0 2 0 0 0 0 0 0
             *     0 0 0 0 0 0 0 0 0 0 0
             *     0 0 0 0 0 0 0 0 0 0 0
             *     0 0 0 0 0 0 0 0 0 0 0
             *     0 0 0 0 0 0 0 0 0 0 0
             *     0 0 0 0 0 0 0 0 0 0 0
             *     0 0 0 0 0 0 0 0 0 0 0
             *     0 0 0 0 0 0 0 0 0 0 0
             *     0 0 0 0 0 0 0 0 0 0 0
             * </p>
         */
        //创建一个二维数组 11 * 11      0：没有棋子  1：黑棋    2：白棋
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][4] = 2;

        //输出原始数组
        System.out.println("原始数组为：");
        //普通for循环
        /*for ( int i = 0; i < array1.length; i++ ) {
            for ( int j = 0; j < array1[i].length; j++ ) {
                System.out.print(array1[i][j] + "\t");
            }
            System.out.println();
        }*/

        //foreach
        for ( int[] ints : array1 ) {
            for ( int i : ints ) {
                System.out.print(i + "\t");
            }
            System.out.println();
        }

        System.out.println("====================");

        //转换为稀疏数组保存
        //获取有效值的个数
        int count = 0;
        for ( int i = 0; i < array1.length; i++ ) {
            for ( int j = 0; j < array1[i].length; j++ ) {
                if ( array1[i][j] != 0 ) {
                    count++;
                }
            }
        }
        System.out.println("有效值个数为：" + count);

        System.out.println("===================");

        /*
         * 稀疏数组
         * <p>
         *     11 11 2
         *     1  2  1
         *     2  4  2
         * </p>
         */
        //创建一个稀疏数组的数组
        int[][] array2 = new int[count + 1][3];

        //遍历二维数组，将非零的值，存放在稀疏数组中
        array2[0][0] = array1.length;
        array2[0][1] = 11;
        array2[0][2] = count;
        int sum = 0;
        for ( int i = 0; i < array1.length; i++ ) {
            for ( int j = 0; j < array1[i].length; j++ ) {
                if ( array1[i][j] != 0 ) {
                    sum++;
                    array2[sum][0] = i;
                    array2[sum][1] = j;
                    array2[sum][2] = array1[i][j];
                }
            }
        }

        System.out.println("稀疏数组为：");
        //输出稀疏数组
        for (  int i = 0; i < array2.length; i++ ) {
            System.out.println(array2[i][0] + "\t" + array2[i][1] + "\t" + array2[i][2] + "\t");
        }

        System.out.println("====================");

        //还原稀疏数组
        System.out.println("还原稀疏数组：");

        //读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];

        //给其中的元素还原值
        for ( int i = 1; i < array2.length; i++ ) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }

        //打印
        for ( int[] ints : array3 ) {
            for ( int i : ints ) {
                System.out.print(i + "\t");
            }
            System.out.println();
        }
    }
}

3、案例

public class ArrayDemo17 {
    public static void main(String[] args) {
        /*  二维数组
            0  0  0  22  0  0   15
            0  11 0  0   0  17  0
            0  0  0  -6  0  0   0
            0  0  0  0   0  39  0
            91 0  0  0   0  0   0
            0  0  28 0   0  0   0
         */

        //定义一个6行7列的二维数组
        int[][] array1 = new int[6][7];
        array1[0][3] = 22;
        array1[0][6] = 15;
        array1[1][1] = 11;
        array1[1][5] = 17;
        array1[2][3] = -6;
        array1[3][5] = 39;
        array1[4][0] = 91;
        array1[5][2] = 28;

        System.out.println("原始数组为：");

        //遍历数组
        for ( int i = 0; i < array1.length; i++ ) {
            for ( int j = 0; j < array1[i].length; j++ ) {
                System.out.print(array1[i][j] + "\t");
            }
            System.out.println();
        }

        System.out.println("====================");

        //计算有效值的个数
        int count = 0;
        for ( int[] ints : array1 ) {
            for ( int i : ints ) {
                if ( i != 0 ) {
                    count++;
                }
            }
        }
        System.out.println("有效值的个数为：" + count);

        System.out.println("===================");

        /*  稀疏数组
            6   7   8
            0   3   22
            0   6   15
            1   1   11
            1   5   17
            2   3   -6
            3   5   39
            4   0   91
            5   2   28
         */

        //定义一个稀疏数组
        int[][] array2 = new int[count+1][3];
        array2[0][0] = array1.length;
        array2[0][1] = 7;
        array2[0][2] = count;

        //遍历数组
        int sum = 0;
        for ( int i = 0; i < array1.length; i++ ) {
            for ( int j = 0; j < array1[i].length; j++ ) {
                if ( array1[i][j] != 0 ) {
                    sum++;
                    array2[sum][0] = i;
                    array2[sum][1] = j;
                    array2[sum][2] = array1[i][j];
                }
            }
        }

        //输出稀疏数组
        System.out.println("稀疏数组为：");

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

        System.out.println("=====================");

        //还原稀疏数组
        System.out.println("还原稀疏数组：");

        //读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];

        //获取稀疏数组中的值
        for ( int i = 1; i < array2.length; i++ ) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }

        //打印数组
        for ( int[] ints : array3 ) {
            for ( int i : ints ) {
                System.out.print(i + "\t");
            }
            System.out.println();
        }
    }
}