冒泡排序和数组基础内容

冒泡排序

比较数组中两个相邻的元素，若第一个数大，则交换位置，时间复杂度：O（n²）

package com.liyan;


import java.util.Arrays;

public class Demo01 {
    public static void main(String[] args) {
        int[] a = {1,5,7,4,6,74,15,24,58,65};
        int[] sort = sort(a);//把排好序的数组赋给sort
        System.out.println(Arrays.toString(sort));//输出排好序的数组
    }
    public static int[] sort(int[] array){
        int temp = 0;
        for (int i = 0;i < array.length;i++){
            for (int j = 0;j < array.length-i-1;j++){
                if(array[j+1] > array[j]){//排序由大到小
                    temp = array[j+1];
                    array[j+1] = array[j];
                    array[j] = temp;
                }
            }
        }
        return array;
    }
}

对排序的改进：

package com.liyan;


import java.util.Arrays;

public class Demo01 {
    public static void main(String[] args) {
        int[] a = {1,5,7,4,6,74,15,24,58,65};
        int[] sort = sort(a);//把排好序的数组赋给sort
        System.out.println(Arrays.toString(sort));
    }
    public static int[] sort(int[] array){
        int temp = 0;
        for (int i = 0;i < array.length;i++){

            boolean flag = false;

            for (int j = 0;j < array.length-i-1;j++){
                if(array[j+1] > array[j]){//排序由大到小
                    temp = array[j+1];
                    array[j+1] = array[j];
                    array[j] = temp;
                    flag = true;
                }
            }
            if(flag == false){
                break;
            }
        }
        return array;
    }
}

增强型的for循环：For-Each循环

//输入array.for按回车：（没有下标）
for (int[] ints : array) {
    System.out.println(array);//打印数组元素
}

稀疏数组

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

1. 记录数组几行几列，有多少不同的值；

2. 把不同值的元素的行列记录在小规模数组中，比如下图：

   第一行的意思是：数组是6行7列，有8个有效元素值

   第二行的意思是：数组第0行第三列的元素值是22

举个例子：

package com.liyan;

public class Demo09 {
    public static void main(String[] args) {
        //1.创建一个二维数组11*11   0：没棋子  1：黑棋   2：白棋
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        //输出原始的数组
        System.out.println("输出原始的数组");
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }

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

        //2.创建一个稀疏数组
        int[][] array2 = new int[sum+1][3];//有sum+1行，3列
        array2[0][0] = 11;//有11行
        array2[0][1] = 11;//有11列
        array2[0][2] = sum;//有sum个元素

        //遍历二维数组，将非零的值存储在稀疏数组中
        int count = 0;//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++;//代表的是行数
                    array2[count][0] = i;//指的是，输出行
                    array2[count][1] = j;//指的是，输出列
                    array2[count][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("稀疏数组：");
        for (int i = 0;i <array2.length;i++){
            System.out.println(array2[i][0]+"\t"
                    +array2[i][1]+"\t"
                    +array2[i][2]+"\t");
        }

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


        int[][] array3 = new int[array2[0][0]][array2[0][1]];//第一个中括号的值是11，第二个也是11

        //2.给其中的元素还原它的值
        for (int i = 1;i < array2.length;i++){
            array3[array2[i][0]][array2[i][1]] = array2[i][2];//array2[i][2]存放的是第三列的有效数据
        }

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

通过矩阵2在重新输出稀疏数组：