Leetcode---每日打卡（20200912- 20200915）

1.20200912二叉树的层平均值

• 给定一个非空二叉树, 返回一个由每层节点平均值组成的数组。

• 示例 1：

输入：
    3
   / \
  9  20
    /  \
   15   7
输出：[3, 14.5, 11]
解释：
第 0 层的平均值是 3 ,  第1层是 14.5 , 第2层是 11 。因此返回 [3, 14.5, 11] 。

• 思路：本题如果会二叉树的层次遍历，那么就会简单很多。就是将每一层的节点值相加除以每一层的节点数，添加进集合即可。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
        List<Double> res = new ArrayList<>();

        if(root == null){
            return res;
        }

        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);

        while(!queue.isEmpty()){
            //记录层数
            int size = queue.size();
            double sum = 0;
            //确保它是在同一层进行加
            for(int i = 0; i < size; i++){
                TreeNode node = queue.poll();
                sum += node.val;
                if(node.left != null){
                    queue.offer(node.left);
                }
                if(node.right != null){
                    queue.offer(node.right);
                }
            }
            res.add(sum / size);
        }

        return res;
    }
}

2.20200913单词搜索（题解出自力扣大佬–数据结构与算法）

• 给定一个二维网格和一个单词，找出该单词是否存在于网格中。
• 单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。
• 示例

board =
[
[‘A’,‘B’,‘C’,‘E’],
[‘S’,‘F’,‘C’,‘S’],
[‘A’,‘D’,‘E’,‘E’]
]

给定 word = “ABCCED”, 返回 true 给定 word = “SEE”, 返回 true 给定 word = “ABCB”,
返回 false

• 提示：

• board 和 word 中只包含大写和小写英文字母。
• 1 <= board.length <= 200
• 1 <= board[i].length <= 200
• 1 <= word.length <= 10^3

思路： 回溯算法，就是一直遍历，看有没有符合条件的。以题目给定的条件为例

• 可以看到，就是从起点出发，向不同的方向开始寻找（上下左右），这个起点可以是任意的一个矩形中的点。下面看代码。

public boolean exist(char[][] board, String word) {
    char[] words = word.toCharArray();
    for (int i = 0; i < board.length; i++) {
        for (int j = 0; j < board[0].length; j++) {
            //从[i,j]这个坐标开始查找
            if (dfs(board, words, i, j, 0))
                return true;
        }
    }
    return false;
}

boolean dfs(char[][] board, char[] word, int i, int j, int index) {
    //边界的判断，如果越界直接返回false。index表示的是查找到字符串word的第几个字符，
    //如果这个字符不等于board[i][j]，说明验证这个坐标路径是走不通的，直接返回false
    if (i >= board.length || i < 0 || j >= board[0].length || j < 0 || board[i][j] != word[index])
        return false;
    //如果word的每个字符都查找完了，直接返回true
    if (index == word.length - 1)
        return true;
    //把当前坐标的值保存下来，为了在最后复原
    char tmp = board[i][j];
    //然后修改当前坐标的值
    board[i][j] = '.';
    //走递归，沿着当前坐标的上下左右4个方向查找
    boolean res = dfs(board, word, i + 1, j, index + 1) || dfs(board, word, i - 1, j, index + 1) ||
            dfs(board, word, i, j + 1, index + 1) || dfs(board, word, i, j - 1, index + 1);
    //递归之后再把当前的坐标复原
    board[i][j] = tmp;
    return res;
}

作者：sdwwld
链接：https://leetcode-cn.com/problems/word-search/solution/hui-su-suan-fa-qiu-jie-by-sdwwld-2/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

3.20200914 二叉树的中序遍历

• 给定一个二叉树，返回它的中序 遍历。
• 思路1：递归

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    List<Integer> res = new ArrayList<>();
    public List<Integer> inorderTraversal(TreeNode root) {
        inOrder(root);

        return res;
    }

    //递归函数
    public void inOrder(TreeNode root){
        //递归终止条件
        if(root == null){
            return;
        }

        //中序遍历的顺序为左根右
        inOrder(root.left);
        //加入结果集合
        res.add(root.val);
        inOrder(root.right);
    }
}

思路二：循环迭代，自己维护一个栈。

/*
	非递归解法比较绕，就是从根节点开始，沿着他的左子节点一直走下去，一直到某一个节点没有左子节点，然后把这个节点加入到集合中，接着访问他的右子节点，这个时候``这个右子节点我们可以把它按照访问根节点的方式进行访问
*/
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Deque<TreeNode> deque = new ArrayDeque<>();

        while(root != null || !deque.isEmpty()){
            //先将所有的左子树节点遍历完全
            while(root != null){
                deque.push(root);
                root = root.left;
            }
            //到达最后，就将其加入结果集
            root = deque.pop();
            res.add(root.val);
            //接下来遍历右子树
            root = root.right;
        } 

        return res;
    }
}

4.解数独https://leetcode-cn.com/problems/sudoku-solver/（凑数）

编写一个程序，通过已填充的空格来解决数独问题。

• 一个数独的解法需遵循如下规则：
  • 数字 1-9 在每一行只能出现一次。
  • 数字 1-9 在每一列只能出现一次。
  • 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。
  • 空白格用 ‘.’ 表示。

class Solution {
    public void solveSudoku(char[][] board) {
        if(board==null||board.length<=0||board[0].length<=0) return;
        char[] nums={'1','2','3','4','5','6','7','8','9'};//可放元素
        dfs(board,0,0,nums);
    }

    boolean dfs(char[][] board,int x,int y,char[] nums){
        if(y>=board[0].length) return dfs(board,x+1,0,nums);//一行找完了，找下一行
        if(x>=board.length) return true;//行列都找完了，结束
        if(board[x][y]!='.') return dfs(board,x,y+1,nums);//有数字，找下一个格子
        for(char num:nums){//依次遍历可放入的元素
            if(check(board,x,y,num)){//如果可选
                board[x][y]=num;//填入
                if(dfs(board,x,y+1,nums)){//下一个可填，也就是从最后一个格子依次返回的都是true
                    return true;
                }else{//回溯
                    board[x][y]='.';
                }
            }
        }
        return false;
    }

    boolean check(char[][] board,int x,int y,char c){//判断当前元素是否可放（x,y）位置
        for(int i=0;i<board.length;i++){//横竖
            if(board[x][i]==c||board[i][y]==c) return false;
        }
        for(int i=x/3*3;i<x/3*3+3;i++){//找到九宫格左上元素，依次遍历
            for(int j=y/3*3;j<y/3*3+3;j++){
                if(board[i][j]==c) return false;
            }
        }
        return true;
    }
}