数组的应用

增强型的for循环

快捷键：array.for---->for(int array:arrays)

冒泡排序

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

import javax.sql.rowset.FilteredRowSet;
import javax.swing.text.AbstractDocument;
import java.text.BreakIterator;
import java.time.temporal.Temporal;
import java.util.Arrays;
import java.util.concurrent.ForkJoinPool;

public class Demo01{

    public static void main(String[] args) {
        int[] a={124,245,1,3,5,24,34};
        int[] bubble = bubble(a);
        System.out.println(Arrays.toString(bubble));
    }

    //冒泡排序
    //1.比较数组中两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
    //2.每一次比较都会产生出一个最大或者最小的数字
    //3.下一轮则可以少一次排序
    //4.依次循环直到结束
    public static int[] bubble(int[] a){
        int temp=0;
        boolean flag=false;
        for (int i = 0; i < a.length-1; i++) {
            for (int j = a.length-1;j>i; j--) {
                if (a[j]<a[j-1]){
                    temp=a[j];
                    a[j]=a[j-1];
                    a[j-1]=temp;
                    flag=true;
                }
            }
            if (flag==false){  //当所有元素都按序排列时，直接停止循环，减少时间
                break;
            }
        }
        return a;
    }

}

稀疏数组

什么是稀疏数组？

稀疏数组可以看做是普通数组的压缩，但是这里说的普通数组是指无效数据量远大于有效数据量的数组
稀疏数组的存储规则

第0行保持原本二维数组的基本信息：即行数、列数、有效值的个数

从第1行开始，就记录着每个值的行下标、列下标、有效值的值

import java.util.Arrays;
import java.util.Formattable;

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

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

        //创建一个稀疏数组
        int[][] b = new int[sum + 1][3];
        b[0][0] = 11;
        b[0][1] = 11;
        b[0][2] = sum;

        //遍历二维数组，将非零的值存放到稀疏数组里面
        int count = 0;
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                if (a[i][j] != 0) {
                    count++;
                    b[count][0] = i;
                    b[count][1] = j;
                    b[count][2] = a[i][j];
                }
            }
        }

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

        System.out.println("还原");
        //1.读取稀疏数组
        int[][] c = new int[b[0][0]][b[0][1]];

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

        //3.打印还原后的数组
        System.out.println("输出还原后的数组");
        for (int i = 0; i <c.length ; i++) {
            for (int j = 0; j <c[i].length ; j++) {
                System.out.print(c[i][j]+"\t");
            }
            System.out.println();

        }
    }
}