五子棋算法模拟实现

1.棋盘算法图解

2.算法实现

package main.java.Demo01_棋盘算法;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class SparseArray {

    public static void main(String[] args) throws IOException {

        //11*11棋盘  1，2分别表示黑白棋
        int[][] chessArray1 = new int[11][11];

        chessArray1[1][0] = 2;
        chessArray1[2][4] = 1;
        chessArray1[4][5] = 2;

        System.out.println("原始棋盘二维数组数据为:");
        //遍历二维数组
        for (int[] row : chessArray1) {
            for (int data : row) {
                System.out.printf("%d\t", data);
            }
            //对每一行数据进行换行
            System.out.println();
        }

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

        //将二维数组转换为稀疏数组
        /**
         * 1.计算出二维数组中非0数字的个数 sum,稀疏数组的行是(sum+1）个,列固定是3
         * 2.创建稀疏数组:spraseArray[sum+1][3]
         */

        //遍历二维数组获取sum
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (chessArray1[i][j] != 0) {
                    sum++;
                }
            }
        }

        //创建稀疏数组
        int[][] sparseArray = new int[sum + 1][3];

        //稀疏数组第一行数据初始化
        sparseArray[0][0] = 11;
        sparseArray[0][1] = 11;
        sparseArray[0][2] = sum;

        //遍历二维数组,将二维数组中的非0数字的行列和数值为稀疏数组初始化

        //count 用于记录是第几个非0数据,count即为在稀疏数组中的第几行，确定row的值
        int count = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (chessArray1[i][j] != 0) {
                    count++;
                    //为稀疏数组的第count行第一列赋值
                    sparseArray[count][0] = i;
                    //为稀疏数组的第count行第二列赋值
                    sparseArray[count][1] = j;
                    //为稀疏数组的第count行第三列赋值
                    sparseArray[count][2] = chessArray1[i][j];

                }
            }
        }
        //初始化赋值完毕

        //遍历稀疏数组
        System.out.println("转换后的稀疏数组为:");
        for (int[] row : sparseArray) {
            for (int data : row) {
                System.out.printf("%d\t", data);
            }
            System.out.println();
        }

        /******************将稀疏数组的数据保存到文件中 开始*********************/
        File file = new File("sparseArray.txt");
        BufferedWriter bw = new BufferedWriter(new FileWriter(file));
        for (int[] row : sparseArray) {
            for (int data : row) {
                bw.write(data + "\t");
            }
            bw.newLine();
        }
        bw.close();
        /******************将稀疏数组的数据保存到文件中 结束*********************/


        /******************将文件中的数据逆解析为稀疏数组 开始*********************/
        BufferedReader br = new BufferedReader(new FileReader(file));

        String len;
        //将文件中的数据先按照顺序存储到list集合中
        List<Integer> list = new ArrayList<>();

        while ((len = br.readLine()) != null) {
            String[] strArr = len.split("\t");
            for (String data : strArr) {
                list.add(Integer.parseInt(data));
            }
        }
        System.out.println("---------------------------------------------");
        System.out.println("list数据为:");
        System.out.println(list);
        System.out.println("---------------------------------------------");

        //将list中的数据转换成稀疏数组,首先创建稀疏数组,并为稀疏数组赋值
        int[][] sparseArray2 = new int[list.get(2) + 1][3];

        /**
         * 1.每次循环取出list中3个数据填充到稀疏数组中，所以i+=3
         * 2.稀疏数组的列是固定的，不需要考虑，要确保每次循环行都是固定加1，则需要计算
         * 3.思路如下：i-2*skip ,skip初始为0,每次循环后加1  i+=3
         */
        int skip = 0;
        for (int i = 0; i < list.size(); i += 3) {
            sparseArray2[i - 2 * skip][0] = list.get(i);
            sparseArray2[i - 2 * skip][1] = list.get(i + 1);
            sparseArray2[i - 2 * skip][2] = list.get(i + 2);
            skip++;
        }

        System.out.println("文件转换后的稀疏数组为:");
        for (int[] row : sparseArray2) {
            for (int data : row) {
                System.out.printf("%d\t", data);
            }
            //对每一行数据进行换行
            System.out.println();
        }


        /******************将文件中的数据逆解析为稀疏数组 结束*********************/

        //最后将稀疏数组还原成二维数组
        //创建二维数组
        int row = sparseArray2[0][0];
        int col = sparseArray2[0][1];
        int[][] chessArray2 = new int[row][col];

        //遍历稀疏数组为二维数组赋值
        for (int i = 1; i < sparseArray2.length; i++) {
            chessArray2[sparseArray2[i][0]][sparseArray2[i][1]] = sparseArray2[i][2];
        }

        System.out.println("---------------------------------------------");
        System.out.println("还原后的二维数组为:");
        for (int[] ro : chessArray2) {
            for (int data : ro) {
                System.out.printf("%d\t", data);
            }
            //对每一行数据进行换行
            System.out.println();
        }

    }
}

3.运行结果

4.个人总结

此算法的所有运行过程和分析都在代码中有详细注释，有不明白的可以留言，如有错误欢迎指出，不甚感激!