学习java的第十二天，冒泡排序、稀疏数组的练习

一、冒泡排序

冒泡数组相当于一个比大小的方法！

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

    //冒泡排序的使用
    public static void main(String[] args) {
        //创建静态数组
        int[] array2 = {2,5,1,65,66,332,8,54,12,11};
        int[] a = a(array2); //调用完我们自己写的排序方法以后，返回一个排序后的数组！
        System.out.println(Arrays.toString(a)); //输出元素
    }
    public static int[] a(int[] array){
        //定义临时变量用来存放比较出来的数值
        int temp = 0;
        //执行循环，判断走了多少次循环

        for (int j = 0; j < array.length-1; j++) {
            //通过flag标识位减少没有意义的比较！
            boolean flat = false;
            //内层循环，用来比较两个数，第一个数比第二数大，交换位置
            //array.length-1是为了不让循环加1时溢出，j从0开始，所以当前array的长度为9，方便下面的+1操作！
            for (int i = 0; i < array.length-1; i++) {
                //如果 array数组的长度i+1长度的值，大于目前数组的长度i
                //比如{2,5,3,6},i目前是0，0+1，则下标是1（值是5），如果下标1的值大于i（i目前是0，值是2）,
                if (array[i+1]>array[i]){
                    //则i的值赋给temp变量！ temp = 2
                    temp = array[i];
                    //然后i+1的值再赋给i  i = 5
                    array[i]= array[i+1];
                    //然后temp的值再赋给i+1  i+1的值 = 2 即可完成了调换！
                    array[i+1] = temp;
                    flat = true;
                }
            }
            if (flat==false){  //如果flat等于false，那就不需要执行循环，直接跳出本次循环！
                break;
            }
        }
       return array;  //返回array数组
    }

冒泡排序相对于来说还是复杂了点，主要去理解内外循环是干什么的就可以了，外层是冒泡轮数，内层是依次比较！属于一个嵌套循环，这个算法的时间复杂度为O(n2)。

---

稀疏数组

• 当一个数组中大部分元素是0，或者为同一值的数组时，可以使用稀疏数组来保存该数组。
• 稀疏数组的处理方式是：

1. 记录数组一共有几行几列，有多少个不同值
2. 把具有不同值的元素和行列及值记录在一个小规模数组中，从而缩小程序的规模！

---

public class ArrayDemo21 {
    //稀疏数组
    public static void main(String[] args) {
        //先定义一个数组，用来存放有效数值以及输出
        // 一、输出棋盘， 0为未定义的数，1是黑棋，2是白棋
        int[][] array1 = new int[11][11];  //这里的长度是11
        array1[2][3] = 1;  //这里是赋值  第三行，第四列为数字1
        array1[4][2] = 2;  //这里是赋值  第五行，第三列是数字2
        array1[3][4] = 2;  //这里是赋值  第四行，第五列是数字2

        // 使用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();
        }
        System.out.println("分割线-------------------------------------------------");
        // 使用for循环增强版打印棋盘
        for (int[] sum : array1) {
            for (int j : sum) {
                System.out.print(j + "\t");
            }
            System.out.println();
        }
        System.out.println("分割线-------------------------------------------------");

        // 计算稀疏数组的有效数值
        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++;
                }
            }
        }
        System.out.println("有效的数组为：" + sum + "个");

        // 二 、创建稀疏数组
        int[][] array2 = new int[sum + 1][3];  //array2的一维数组长度为sum+1，也就是4个，因为那个1是计算的头，不做有效数据，二维为3，也就是3列
        array2[0][0] = 11;  //第0行的第一列数值是11，固定死   这里指的是总共的行数
        array2[0][1] = 11;  //第0行的第二列数值是11，固定死  这里指的是总共的列数
        array2[0][2] = sum; //第0行的第三列数值是3，可变   这个指的是有效数的总数

        //遍历二维数组，将非0的值存放在稀疏数组中！
        int count = 0; //定义一个初始变量来标记数据存放的第几行
        //这里是遍历array1的一维数组，可以说是外循环，这里只能遍历出地址
        for (int i = 0; i < array1.length; i++) {
            //这里是遍历array1的二维数组，可以时候是内循环，用来遍历array[i]中的值！
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j] != 0) {  //如果arry1数组中的i行j行，不等于0，则count加加
                    count++;  //用来标记当前有效数存放在稀疏数组中的第几行
                    array2[count][0] = i;  //i代表是行，将i行有效数据存在的下标给array2的稀疏数组中，代表着当前在原始数组中的第几行！
                    array2[count][1] = j; //j代表是列，将j列有效数据存在的下标给array2的稀疏数组中，代表着当前在原始数组中的第几列！
                    array2[count][2] = array1[i][j]; //这里代表着array1的有效数据的值给到array2稀疏数组中的第三列
                }
            }
        }
        //将稀疏数组打印出来
        System.out.println("稀疏数组：");
        for (int i = 0; i < array2.length; i++) {  //这里是遍历了array2的数组，因为array2数组的值中含有头列，所以直接调取了输出，这样方便理解！

            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];
        }
        //3.打印还原数组
        for (int[] prin : array3) {
            for (int print2 : prin) {
                System.out.print(print2 + "\t");

            }
            System.out.println();

        }
    }

}

总结：稀疏数组理解起来还是挺难的，主要去理解代码中的备注，从今天下午到现在，才理解了一点出来，这个稀疏数组，明天要继续加油了！

---

注：文章仅做个人学习日记，不做学习建议，学习来源：狂神说