Java 稀疏矩阵(五子棋存盘)和增强for循环

目录

• 稀疏数组的作用：
• 二维数组转稀疏数组：
• 稀疏数组转二维数组：
• 俺的理解如图​
•  实例：五子棋存盘功能
• 实例代码如下： 
• 增强for循环（foreach）
• 一维数组循环：
• 二维数组循环

---

稀疏数组的作用：

• 一个数组中有大部分无意义数据/0，可以用稀疏数组对这个二维数组进行压缩；
• 将有用的数据存放在一个列为3的稀疏数组中，用这个数组来记录有用的数字在二维数组中所处的位置；
• 大大缩小了存放数组的规模；

二维数组转稀疏数组：

1. 设置棋盘，棋子；
2. 遍历棋盘，记录下棋子的个数count；
3. 将棋子的行，列，值存放在稀疏数组的3列中；
4. 稀疏数组的第一行需要记录棋盘的行，列和棋子的个数，则稀疏数组的行长为count+1；

稀疏数组转二维数组：

1. 通过查看稀疏数组第一列前两个数的值，得到二维数组的行长，列长；
2. 通过稀疏数组剩下每行的3个数(行，列，值),确定棋子在二维数组中的位置；

俺的理解如图

 实例：五子棋存盘功能

        即将棋盘看做二维数组 ，棋子保存在一个稀疏数组中

实例代码如下： 

//数组模拟环形队列的代码实现案例：保留一个二维矩阵
public class Main {
    public static void main(String[] args) {
        //创建棋盘，设置旗子
        int[][] arr=new int[5][5];
        arr[3][3]=1;
        arr[4][4]=1;
        arr[1][1]=1;
        arr[0][0]=1;
        arr[2][2]=1;

        System.out.println("原始二维数组展示");
        // 增强for循环练习：这个循环只能遍历，其余做什么都不可以
        for(int[] row:arr){        //一次循环得到将每一行保存在一维数组row[]中
            for (int is : row) {            //二次循环将一维数组中的每个数字保存在单个变量is中
                System.out.printf("%d\t",is);             
            }
            System.out.println();
        }
        //得到非零数据的个数
        int count=0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length; j++) {
                if(arr[i][j]!=0){
                    count++;
                }
            }
        }
        System.out.println("—————————————————————————————————");
        System.out.println("二维数组转换为稀疏数组");
        //稀疏数组的结构：行长：count+1,列长：3
        int[][] Sparse=new int[count+1][3];
        //确定第0行的数据
        Sparse[0][0]=5;//arr行长
        Sparse[0][1]=5;//arr列长
        Sparse[0][2]=5;//arr中的非零数字个数
        int num=0;
        //填充数据，将棋子的位置填在稀疏数组中
        for (int i = 0; i < arr.length; i++) {   //行
            for (int j = 0; j < arr.length; j++) {    //列
                if(arr[i][j]!=0){
                    num++;      //一个数字的行列数据储存在一行中
                    Sparse[num][0]=i;
                    Sparse[num][1]=j;
                    Sparse[num][2]=arr[i][j];
                }
            }
        }
            //输出    
        for (int i = 0; i < Sparse.length; i++) {
            System.out.printf("%d\t%d\t%d\n",Sparse[i][0],Sparse[i][1],Sparse[i][2]);
        }
        
        
        System.out.println("—————————————————————————————————");
        System.out.println("将稀疏数组转换为二维数组");
        int[][] arr2=new int[Sparse[0][0]][Sparse[0][1]];//通过第一列得到行列长度和数字个数
        for (int i = 1; i < Sparse.length; i++) {   //行
            //一行一行的录入数据
            arr2[Sparse[i][0]][Sparse[i][1]]=Sparse[i][2];
        }
            //遍历：foreach练习
        for (int[] is : arr2) {
            for (int i : is) {
                System.out.printf("%d\t",i);
            }
            System.out.println();
        }
    }
}

增强for循环（foreach）

  for(循环体类型   存放的位置 ： 循环体名字)

一维数组循环：

• 进行一次循环，这次循环将把数组中的每个值单独遍历
  • for(int i:arr);

二维数组循环

需进行两次foreach循环：

• 将每一行存放在存放在一维数组中；
  • for(int[] is : arr){}
  • for[int i:is]{}
• 将一维数组中的每个数值单独遍历；

        //创建二维数组
        int[][] arr=new int[5][5];
        //没有存放数据的话默认为全0
        
        //一次循环得到将每一行保存在一维数组row[]中
        for(int[] row:arr){        
            //二次循环将一维数组中的每个数字保存在单个变量is中
            for (int is : row) {         
                System.out.printf("%d\t",is);             
            }
            System.out.println();
        }

 学习适配：B站尚硅谷公开课程