剑指 offer——树与图篇

Posted 2020-12-17 yzihan

7. 重建二叉树

题意：面试题07. 重建二叉树
思路：前序遍历的顺序是“根-左-右”，中序遍历的顺序是“左-中-右”。
那么，对于整棵树前序遍历的结果，第一个值r一定是树的根结点。如果在中序遍历的结果中找到r的位置index，那么index左边的子数组就都是根结点r的左子树的中序遍历结果，index右边的结点都是根结点右子树的中序遍历结果。
并且，根据在中序遍历中找到的左子树长度，可以同样在前序遍历的r结点之后找到相同长度的子数组，即为左子树的前序遍历结果。其余的部分即是左子树的前序遍历结果。
然后根据左、右子树的前序遍历和中序遍历结果再按照上述规则创建二叉树。

class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        return build(preorder, 0, preorder.length - 1, inorder, 0, inorder.length - 1);
    }

    private TreeNode build(int[] pre, int preL, int preR, int[] in, int inL, int inR) {
        if (preL > preR || inL > inR) {
            return null;
        }
        TreeNode root = new TreeNode(pre[preL]);
        int rootIndex = -1;
        for (int i = inL; i <= inR; i ++) {
            if (in[i] == pre[preL]) {
                rootIndex = i;
                break;
            }
        }
        int leftLen = rootIndex - inL;
        root.left = build(pre, preL+1, preL+leftLen, in, inL, rootIndex-1);
        root.right = build(pre, preL+leftLen+1, preR, in, rootIndex+1, inR);
        return root;
    }
}

12. 矩阵中的路径

题意：面试题12. 矩阵中的路径
思路：典型的dfs搜索+回溯题，每次朝一个方向进行搜索到底，不满足条件时进行回溯。

class Solution {
    int[][] dir = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};

    public boolean exist(char[][] board, String word) {
        char[] arr = word.toCharArray();
        boolean[][] visited = new boolean[board.length][board[0].length];
        for (int i = 0; i < board.length; i ++) {
            for (int j = 0; j < board[0].length; j ++) {
                if (searchWord(board, i, j, arr, 0, visited)) {
                    return true;
                }
            }
        }
        return false;
    }

    private boolean searchWord(char[][] board, int i, int j, char[] word, int w, boolean[][] visited) {
        if (w == word.length) {
            return true;
        }
        if (i >= 0 && i < board.length && j >= 0 && j < board[0].length
            && board[i][j] == word[w]
            && !visited[i][j]) {
            visited[i][j] = true;
            for (int[] d : dir) {
                if (searchWord(board, i + d[0], j + d[1], word, w + 1, visited)) {
                    return true;
                }
            }
            visited[i][j] = false;
            return false;
        }
        return false;
    }
}

13. 机器人的运动范围

题意：面试题13. 机器人的运动范围
思路：搜索，在边界条件中加入数位之和不大于k即可。其余条件与搜索一致。

class Solution {
    public int movingCount(int m, int n, int k) {
        int[][] visited = new int[m][n];
        return bfs(visited, m, n, 0, 0, k);
    }

    int[][] dirs = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};

    private int bfs(int[][] visited, int m, int n, int i, int j, int k) {
        Queue<int[]> queue = new LinkedList<>();
        queue.add(new int[]{i, j});
        visited[i][j] = 1;
        int count = 0;
        int[] tmp;
        while (!queue.isEmpty()) {
            tmp = queue.poll();
            count ++;
            for (int[] dir : dirs) {
                int x = tmp[0] + dir[0];
                int y = tmp[1] + dir[1];
                if (isValid(visited, m, n, x, y, k)) {
                    queue.add(new int[]{x, y});
                    visited[x][y] = 1;
                }
            }
        }
        return count;
    }

    private boolean isValid(int[][] visited, int m, int n, int x, int y, int k) {
        boolean isInBound = (x >= 0 && x < m && y >= 0 && y < n && visited[x][y] == 0);
        if (!isInBound) {
            return false;
        }
        int sum = 0;
        char[] arr = String.valueOf(x).toCharArray();
        for (char c : arr) {
            sum += (c - ‘0‘);
        }
        arr = String.valueOf(y).toCharArray();
        for (char c : arr) {
            sum += (c - ‘0‘);
        }
        return sum <= k;
    }
}

26. 树的子结构

题意：面试题26. 树的子结构
思路：将A中的每一个子结点a作为根结点，判断B是否与a的结构相同。isSub判断a与B的结构是否相同，isSubStructure取A中每一个结点与B进行比较。

class Solution {
    public boolean isSubStructure(TreeNode A, TreeNode B) {
        return A != null && B != null &&
        (isSub(A, B) || isSubStructure(A.left, B) || isSubStructure(A.right, B));
    }

    private boolean isSub(TreeNode A, TreeNode B) {
        if (B == null) {
            return true;
        } else if (A == null || A.val != B.val) {
            return false;
        }
        return isSub(A.left, B.left) && isSub(A.right, B.right);
    }
}

27. 二叉树的镜像

题意：面试题27. 二叉树的镜像
思路：以递归的方式创建。即把原树的左孩子结点作为新树的右孩子结点，原树的右孩子结点作为新树的左孩子结点。

class Solution {
    public TreeNode mirrorTree(TreeNode root) {
        return createMirror(root);
    }

    private TreeNode createMirror(TreeNode root) {
        if (root == null) {
            return null;
        }
        TreeNode newRoot = new TreeNode(root.val);
        newRoot.left = createMirror(root.right);
        newRoot.right = createMirror(root.left);
        return newRoot;
    }
}

28. 对称的二叉树

题意：面试题28. 对称的二叉树
思路：递归方式判断。对于每一个结点，必须满足 左孩子的左结点 == 右孩子的右结点 && 左孩子的右结点 == 右孩子的左结点，那么这棵二叉树就是对称的。

class Solution {
    public boolean isSymmetric(TreeNode root) {
        if (root == null) {
            return true;
        }
        return isSame(root.left, root.right);
    }

    private boolean isSame(TreeNode left, TreeNode right) {
        if (left == null && right == null) {
            return true;
        } else if (left == null || right == null) {
            return false;
        } else {
            boolean flag = (left.val == right.val);
            return flag && isSame(left.left, right.right) && isSame(left.right, right.left);
        }
    }
}

32-I. 从上到下打印二叉树

题意：面试题32 - I. 从上到下打印二叉树
思路：二叉树层次遍历，使用队列即可。

class Solution {
    public int[] levelOrder(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<>();
        if (root != null) {
            queue.add(root);
        }
        TreeNode tmp;
        while (!queue.isEmpty()) {
            tmp = queue.poll();
            list.add(tmp.val);
            if (tmp.left != null) {
                queue.add(tmp.left);
            }
            if (tmp.right != null) {
                queue.add(tmp.right);
            }
        }
        int[] out = new int[list.size()];
        for (int i = 0 ; i < out.length; i ++) {
            out[i] = list.get(i);
        }
        return out;
    }
}

32-II. 从上到下打印二叉树 II

题意：面试题32 - II. 从上到下打印二叉树 II
思路：二叉树层次遍历。有两种方式，详见{% post_link "二叉树的遍历" %}

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<>();
        if (root != null) {
            queue.add(root);
        }
        TreeNode last = root;
        TreeNode nLast = root;
        List<Integer> list = new ArrayList<>();
        TreeNode tmp;
        while (!queue.isEmpty()) {
            tmp = queue.poll();
            list.add(tmp.val);
            if (tmp.left != null) {
                queue.add(tmp.left);
                nLast = tmp.left;
            }
            if (tmp.right != null) {
                queue.add(tmp.right);
                nLast = tmp.right;
            }
            if (tmp == last) {
                res.add(list);
                list = new ArrayList<>();
                last = nLast;
            }
        }
        return res;
    }
}

33-III. 从上到下打印二叉树 III

题意：面试题32 - III. 从上到下打印二叉树 III
思路：与32题类似，增加一个标志位表示当前打印的是奇数行还是偶数行，奇数行从列表尾部插入元素，偶数行从列表头部插入元素。

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        TreeNode tmp;
        int size;
        boolean flag = true;
        List<Integer> list;
        while (!queue.isEmpty()) {
            size = queue.size();
            list = new ArrayList<>();
            for (int i = 0; i < size; i ++) {
                tmp = queue.poll();
                if (flag) {
                    list.add(tmp.val);
                } else {
                    list.add(0, tmp.val);
                }
                if (tmp.left != null) {
                    queue.add(tmp.left);
                }
                if (tmp.right != null) {
                    queue.add(tmp.right);
                }
            }
            res.add(list);
            flag = !flag;
        }
        return res;
    }
}

34. 二叉树中和为某一值的路径

题意：面试题34. 二叉树中和为某一值的路径
思路：最经典的dfs+回溯。dfs遍历过程中，使用列表记录从根结点到当前结点的路径，到达叶子结点时计算是否满足和为指定值，然后进行回溯。

class Solution {
    List<List<Integer>> res = new ArrayList<>();

    public List<List<Integer>> pathSum(TreeNode root, int sum) {
        if (root == null) {
            return res;
        }
        LinkedList<Integer> path = new LinkedList<>();
        dfs(root, sum, path);
        return res;
    }

    private void dfs(TreeNode root, int target, LinkedList<Integer> path) {
        path.add(root.val);
        if (root.left == null && root.right == null) {
            if (target == root.val) {
                res.add(new ArrayList<>(path));
            }
            path.removeLast();
            return;
        }
        if (root.left != null) {
            dfs(root.left, target - root.val, path);
        }
        if (root.right != null) {
            dfs(root.right, target - root.val, path);
        }
        path.removeLast();
    }
}

36. 二叉搜索树与双向链表

题意：面试题36. 二叉搜索树与双向链表
思路：二叉搜索树的前序遍历结果是一个递增的序列。可以利用这个特点，将遍历到的点依次连接起来。

class Solution {
    public Node treeToDoublyList(Node root) {
        inOrder(root);
        if (p != null) {
            p.right = head;
            head.left = p;
        }
        return head;
    }

    Node head;
    Node p;

    private void inOrder(Node root) {
        if (root == null) {
            return;
        }
        inOrder(root.left);
        if (head == null) {
            head = root;
            p = head;
        } else {
            p.right = root;
            root.left = p;
            p = root;
        }
        inOrder(root.right);
    }
}

37. 序列化二叉树

题意：面试题37. 序列化二叉树
思路：序列化过程：将各个结点以特殊符号“_”隔开，空结点以“#”代替，以层序遍历方式遍历整棵树。反序列化的过程中，以"_"分隔序列化字串，仍以层序方式将分隔出的字串恢复为树的结点，遇到“#”表示该结点为空。

public class Codec {
    // Encodes a tree to a single string.
    public String serialize(TreeNode root) {
        StringBuilder sb = new StringBuilder();
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        TreeNode tmp;
        while (!queue.isEmpty()) {
            tmp = queue.poll();
            if (tmp == null) {
                sb.append("#_");
            } else {
                sb.append(tmp.val).append("_");
                queue.add(tmp.left);
                queue.add(tmp.right);
            }
        }
        String res = sb.toString();
        return res.substring(0, res.length() - 1);
    }

    // Decodes your encoded data to tree.
    public TreeNode deserialize(String data) {
        String[] vals = data.split("_");
        if ("#".equals(vals[0])) {
            return null;
        }
        TreeNode root = new TreeNode(Integer.parseInt(vals[0]));
        int index = 1;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        TreeNode tmp;
        while (!queue.isEmpty()) {
            tmp = queue.poll();
            if (!"#".equals(tmp)) {
                if (!vals[index].equals("#")) {
                    tmp.left = new TreeNode(Integer.parseInt(vals[index]));
                    queue.add(tmp.left);
                }
                index ++;
                if (!vals[index].equals("#")) {
                    tmp.right = new TreeNode(Integer.parseInt(vals[index]));
                    queue.add(tmp.right);
                }
                index ++;
            }
        }
        return root;
    }
}

46. 把数字翻译成字符串

题意：面试题46. 把数字翻译成字符串

思路：每次考虑一个字符和两个字符（只有当前位置不是最后一个位置，且两个字符拼接成的整数小于25时才考虑这种情况），然后递归剩下的字符。当到达数字结尾时结束。

class Solution {
    private int count = 0;

    public int translateNum(int num) {
        translateNum(String.valueOf(num).toCharArray(), 0);
        return count;
    }

    private void translateNum(char[] arr, int start) {
        if (start >= arr.length) {
            count ++;
            return;
        }
        translateNum(arr, start + 1);
        if (start < arr.length - 1 && (arr[start] == ‘1‘
        || (arr[start] == ‘2‘ && arr[start + 1] <= ‘5‘))) {
            translateNum(arr, start + 2);
        }
    }
}

54. 二叉搜索树的第k大节点

题意：面试题54. 二叉搜索树的第k大节点
思路：二叉树的中序遍历（左中右）就是一个递增序列。只需要对遍历过程进行改造，将遍历过程修改为右中左就变为递减序列了，判断是否到达第k个点即可。

class Solution {
    int value = -1;
    int count = 0;

    public int kthLargest(TreeNode root, int k) {
        printTree(root, k);
        return value;
    }

    private void printTree(TreeNode root, int k) {
        if (root == null || count >= k) {
            return;
        }
        printTree(root.right, k);
        count ++;
        if (count == k) {
            value = root.val;
            return;
        }
        printTree(root.left, k);
    }
}

55-I. 二叉树的深度

题意：面试题55 - I. 二叉树的深度
思路：递归。深度为左子树和右子树最大高度加1得到。

class Solution {
    public int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
    }
}

55-II. 平衡二叉树

题意：面试题55 - II. 平衡二叉树
思路：递归。在判断左子树和右子树是否为平衡二叉树的同时，也要判断其高度差是否小于等于1（其中高度的计算可以由面试题55-I得到），所以递归函数的返回值有两个：高度和当前结点为根的子树是否为平衡二叉树。

class Solution {
    public boolean isBalanced(TreeNode root) {
        return isBalancedTree(root).isBalanced;
    }

    class Returntype {
        int height;
        boolean isBalanced;

        public Returntype(int height, boolean isBalanced) {
            this.height = height;
            this.isBalanced = isBalanced;
        }
    }

    private Returntype isBalancedTree(TreeNode root) {
        if (root == null) {
            return new Returntype(0, true);
        }
        Returntype left = isBalancedTree(root.left);
        if (!left.isBalanced) {
            return new Returntype(-1, false);
        }
        Returntype right = isBalancedTree(root.right);
        if (!right.isBalanced) {
            return new Returntype(-1, false);
        }
        if (Math.abs(left.height - right.height) <= 1) {
            return new Returntype(Math.max(left.height, right.height) + 1, true);
        }
        return new Returntype(-1, false);
    }
}

68-I. 二叉搜索树的最近公共祖先

题意：面试题68 - I. 二叉搜索树的最近公共祖先
思路：根据二叉搜索树的特点。根结点的值大于左子树的结点，且小于右子树上所有的结点。
1）如果根结点的值介于两个要找的值之间，那么根结点就是要求的最近公共祖先；
2）如果根结点的值小于两个要找的值，那么公共祖先应位于根结点的右子树上；
3）如果根结点的值大于两个要找的值，那么公共祖先应位于根结点的左子树上；

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        TreeNode less = p.val > q.val ? q : p;
        TreeNode large = less == p ? q : p;
        return commonNode(root, less, large);
    }

    private TreeNode commonNode(TreeNode root, TreeNode p, TreeNode q) {
        if (root == p || root == q) {
            return root;
        } else if (root.val > p.val && root.val < q.val) {
            return root;
        } else if (root.val < p.val && root.val < q.val) {
            return commonNode(root.right, p, q);
        } else {
            return commonNode(root.left, p, q);
        }
    }
}

68-II. 二叉树的最近公共祖先

题意：面试题68 - II. 二叉树的最近公共祖先
思路：递归。从根结点开始查找，要求的两个结点的公共祖先一定是：左子树上某个结点、右子树上某个结点或本结点。

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if (root == null || root == p || root == q) {
            return root;
        }
        TreeNode left = lowestCommonAncestor(root.left, p, q);
        TreeNode right = lowestCommonAncestor(root.right, p, q);
        if (left == null) {
            return right;
        } else if (right == null) {
            return left;
        }
        return root;
    }
}