有效的数独

题目描述和测试举例看这里，不重复啦！下面是一种解法的解释：

解法1：

for循环 好多指针解法

 var isValidSudoku = function (board) {
            var flag = 0;
            // 行和列的比较
            // 三层for循环 z + 1
            for (var i = 0; i < 9; i++) {
                for (var j = 0; j < 9; j++) {
                    for (var z = j + 1; z < 9; z++) {
                        // 行 上的元素比较 第一个都是i表示都一行
                        if (board[i][j] != '.' && board[i][j] === board[i][z]) {
                            flag = 1;
                            return false
                        }
                        // 列 上的元素比较 第二个都是i表示都一列
                        if (board[j][i] != '.' && board[j][i] === board[z][i]) {
                            console.log(board[j][i]);
                            console.log(board[z][i]);
                            flag = 1;
                            return false
                        }
                    }
                }
            }

            // 九宫格内部判断
            for (var row = 0; row < 9; row += 3) {
                for (var col = 0; col < 9; col += 3) {
                    var num = []
                    for (var a = row; a < row + 3; a++) {
                        for (var b = col; b < col + 3; b++) {
                            // 如果数字不是点进行判断
                            if (board[a][b] !== ".") {
                                // 数放到 num数组里面去
                                num.push(board[a][b])
                            }
                        }
                    }
                    
                    // 上面的逻辑是把数组里面所有的元素放到num数组
                    // 下面的逻辑是判断数组里面是否有重复的元素
                    // 这个for和上面的a处的for并列 表示 一个宫格内部判断 判断完毕就去下一个宫格
                    for (var x = 0; x < num.length; x++) {
                        for (var y = x + 1; y < num.length; y++) {
                            console.log(nums[i], nums[j]);
                            if (num[x] === num[y]) {
                                flag = 1;
                                return false
                            }
                        }
                    }
                }
                if (flag === 0) {
                    return true
                }
            }
        }

判断行是否重复的代码:

board[i][j] === board[i][z] 这个是关键，z总比j多1，z递增而让j固定，其实就是一个指针固定，另一个指针移动，看看有没有重复的值。

比如board[i][j]是 board[0][0] board[i][z]就是board[0][1] board[0][2] ……

判断列是否重复的代码

board[j][i] === board[z][i]是关键，行i不变，j和z改变，就是列索引改变。

比如

九宫格的代码部分判断：

  第一部分逻辑是把所有的代码放到num数组

  注意点1 -> 每次遍历完一个宫格，col+1，换下一个宫格。

  注意点2 -> col 和 row 循环是加3

  注意点3 -> a 和 b 的初始值分别是 col和row

  

row	col	a	b	board[a][b]
0	0	0	0	第一行第一个数
0	0	0	1	第一行第二个数
0	0	0	2	第一行第三个数
0	0	1	0	第二行第一个数
0	0	1	1
0	0	1	2
0	0	2	0
0	0	2	1
0	0	2	2

  下一个部分col是3，也是这样去取值，就很容易理解啦 

  第二个部分逻辑是，直接双指针，判断数组里面是否有重复的元素。

参考了这个大哥的写法：leetcode:36.有效的数独（js实现）_小峤的博客-CSDN博客