Li Kou's notes have been opened to the public:
Portal
[Author: ArtBoy literature and art

Self-Improvement

There's no better way to overpower a trickle of doubt than with a flood of naked truth.
A flood of facts is the best way to break a trace of doubt.

Title Source:
https://leetcode-cn.com/leetbook/detail/illustration-of-algorithm/

Supporting learning documents:
https://www.kancloud.cn/alex_wsc/dataalg/1853982

Book recommendation:

Comic algorithm

Video recommendation:
https://www.bilibili.com/video/BV1E4411H73v

catalogue

1, Sword finger Offer 12. Path in matrix

Question:

Given an m x n two-dimensional character grid board and a string word word. If word exists in the grid, return true; Otherwise, false is returned.

Words must be formed alphabetically by letters in adjacent cells, where "adjacent" cells are those horizontally or vertically adjacent. Letters in the same cell cannot be reused.

For example, in 3 below × The matrix of 4 contains the word "ABCCED" (the letters in the word are marked).

Example 1:

Input: board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCCED"
Output: true

Example 2:

Input: board = [["a","b"],["c","d"]], word = "abcd"
Output: false

Tips:

1 <= board.length <= 200
1 <= board[i].length <= 200
board and word It consists of upper and lower case letters only

Solution:

Problem solving idea: DFS + pruning

AC Code:

class Solution {
    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++){
                if(dfs(board, words, i, j, 0)) return true;
            }
        }
        return false;
    }
    boolean dfs(char[][] board, char[] words, int i, int j, int k){
        if(i >= board.length || i < 0 || j >= board[0].length || j < 0 || board[i][j] != words[k]) return false; // Subscript out of bounds
        if(k == words.length - 1) return true; // Match all
        board[i][j] = '\0'; // Invalid marker (the next step is to explore the way up, down, left and right. You can't walk through the past, '\ 0' to prevent repetition with the characters in words)
        boolean res = dfs(board, words, i+1, j, k+1) || dfs(board, words, i-1, j, k+1) 
        || dfs(board, words, i, j+1, k+1) || dfs(board, words, i, j-1, k+1); // Up, down, right, left, parallel
        board[i][j] = words[k];
        return res;
    }
}

M. N is the size of matrix rows and columns, and K is the length of string word.

• Time complexity O(3K MN): in the worst case, it is necessary to traverse all schemes with a length of K string in the matrix, and the time complexity is O(3K); There are Mn starting points in the matrix, and the time complexity is O(MN).
• Calculation of the number of schemes: set the length of the string as K, and each character in the search can be selected in the up, down, left and right directions. Discard the back (last character) direction, and there are three options left. Therefore, the complexity of the number of schemes is O(3K).
• Space complexity O(K): the recursion depth in the search process does not exceed K, so the stack space accumulated by the system due to function calls occupies O(K) (because the stack space of system calls will be released after the function returns). In the worst case, K = MN and the recursion depth is Mn. At this time, the system stack uses the additional space of O(MN).

2, 13. Motion range of the robot

Question:

There is a grid of m rows and N columns on the ground, from coordinates [0,0] to coordinates [m-1,n-1]. A robot starts to move from the grid of coordinates [0,0]. It can move left, right, up and down one grid at a time (it cannot move outside the grid), nor can it enter the grid where the sum of digits of row coordinates and column coordinates is greater than k. For example, when k is 18, the robot can enter the grid [35, 37], because 3 + 5 + 3 + 7 = 18. But it cannot enter the grid [35, 38], because 3 + 5 + 3 + 8 = 19. How many grids can the robot reach?

Example 1:

Input: m = 2, n = 3, k = 1
 Output: 3

Example 2:

Input: m = 3, n = 1, k = 0
 Output: 1

Tips:

1 <= n,m <= 100
0 <= k <= 20

Solution:

Problem solving idea: DFS + pruning

Digital sum calculation template:

int sums(int x)
    int s = 0;
    while(x != 0) {
        s += x % 10;  // Get the one digit number of x
        x = x / 10; // Move the decimal number of x one digit to the right, that is, delete one digit.
    }
    return s;

In this problem, the robot can only move one grid at a time, and only the digits and increments from X to x+1 are required for each calculation

(x + 1) % 10 != 0 ? s_x + 1 : s_x - 8;

explain:

• x = 11, x + 1 = 12, digit sum: 2, 3 (2 + 1)
• x = 19, x + 1 = 20, digit sum: 10, 2 (10-8)

According to the structure and connectivity of reachable solutions, it is easy to deduce that the robot can access all reachable solutions only by moving to the right and down.

AC Code:

class Solution {
    int m, n, k;
    boolean[][] visited;
    public int movingCount(int m, int n, int k) {
        this.m = m; this.n = n; this.k = k;
        this.visited = new boolean[m][n];
        return dfs(0, 0, 0, 0);
    }
    public int dfs(int i, int j, int si, int sj){ // Coordinates, digits and
        if(i >= m || j >= n || si + sj > k || visited[i][j]) return 0; // prune
        visited[i][j] = true; // sign
        int down = dfs(i+1, j, cal(i, si), sj); // Next look
        int right = dfs(i, j+1, si, cal(j, sj)); // Right search
        return 1 + down + right;
    }
    public int cal(int x, int sum){ // Digit and increment
        return (x + 1) % 10 != 0 ? sum + 1 : sum - 8;
    }
}

Problem solving idea: BFS

AC Code:

class Solution {
    public int movingCount(int m, int n, int k) {
        boolean[][] visited = new boolean[m][n];
        int res = 0;
        LinkedList<int[]> queue = new LinkedList<>();
        queue.add(new int[]{0, 0, 0, 0}); // i,j,si,sj
        while(!queue.isEmpty()){
            int[] x = queue.removeFirst();
            int i = x[0], j = x[1], si = x[2], sj = x[3];
            if(i >= m || j >= n || si + sj > k || visited[i][j]) continue;
            visited[i][j] = true;
            res++;
            queue.add(new int[]{i+1, j , cal(i,si), sj});
            queue.add(new int[]{i, j+1, si, cal(j,sj)});
        }
        return res;
    }
    public int cal(int x, int sum){
        return (x + 1)%10 != 0 ? sum + 1 : sum - 8;
    }
}

3, Sword finger Offer 26. Substructure of tree

Question:

Input two binary trees a and B to judge whether B is the substructure of A. (the contract empty tree is not a substructure of any tree)

B is the substructure of A, that is, the same structure and node values as B appear in A.

For example:
Given tree A:

     3
    / \
   4   5
  / \
 1   2

Given tree B:

   4 
  /
 1

Returns true because A subtree of B and A has the same structure and node values.

Example 1:

Input: A = [1,2,3], B = [3,1]
Output: false

Example 2:

Input: A = [3,4,5,1,2], B = [4,1]
Output: true

Limitations:

0 <= Number of nodes <= 10000

Solution:

Problem solving idea: first traverse A + judge whether A contains B (double-layer dfs)

AC Code:

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isSubStructure(TreeNode A, TreeNode B) {
        // An empty tree is not a substructure of any tree
        if(A == null || B == null) return false;
        // Current node judgment
        if(recur(A,B)) return true;
        // Left and right node judgment
        return isSubStructure(A.left, B) || isSubStructure(A.right, B);
    }
    // Compare current node
    boolean recur(TreeNode A, TreeNode B){
        // B match end
        if(B == null) return true;
        // First judge whether it is null, and then judge whether its val is equal, otherwise a null pointer exception will be reported
        if(A == null || A.val != B.val) return false;
        return recur(A.left, B.left) && recur(A.right, B.right);
    }
}

• Time complexity O(MN): where m and N are the number of nodes of tree A and tree B respectively; First traverse the tree a to occupy O(M), and each time call recur(A, B) to judge the occupation of O(N).
• Spatial complexity O(M): when both tree A and tree B degenerate into linked lists, the recursive call depth is the largest. When M ≤ n, the total recursive depth of traversing tree A and recursive judgment is M; When M > N, the worst case is to traverse to the leaf node of tree a, and the total recursion depth is M.

4, Sword finger Offer 27. Image of binary tree

Question:

Please complete a function, input a binary tree, and the function outputs its image.

For example, enter:

     4
   /   \
  2     7
 / \   / \
1   3 6   9

Mirror output:

     4
   /   \
  7     2
 / \   / \
9   6 3   1

Example 1:

Input: root = [4,2,7,1,3,6,9]
Output:[4,7,2,9,6,3,1]

Limitations:

0 <= Number of nodes <= 1000

Solution:

Problem solving idea: recursion
AC Code:

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode mirrorTree(TreeNode root) {
        // It must be judged as null before taking value to prevent null exception
        if(root == null) return null;
        TreeNode temp = root.left;
        // Right flip left
        root.left = mirrorTree(root.right);
        // temp flip right
        root.right = mirrorTree(temp);
        return root;
    }
}

• Time complexity O(N): where N is the number of nodes of the binary tree. To establish a binary tree image, you need to traverse all nodes of the tree, taking O(N) time.
• Space complexity O(N): in the worst case (when the binary tree degenerates into a linked list), the system needs to use stack space of O(N) size for recursion.

Solution idea: auxiliary stack traversal exchange

AC Code:

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode mirrorTree(TreeNode root) {
        if(root == null) return null;
        // Traverse the whole tree through the stack (store the nodes to be accessed and pop up the accessed nodes)
        LinkedList<TreeNode> stack = new LinkedList<>(){{add(root);}};
        while(!stack.isEmpty()){
            // Pop up the node being accessed
            TreeNode node = stack.removeLast();
            // Record the left and right nodes for the next visit
            if(node.left != null) stack.add(node.left);
            if(node.right != null) stack.add(node.right);
            // exchange
            TreeNode temp = node.left;
            node.left = node.right;
            node.right = temp;
        }
        return root;
    }
}

• Time complexity O(N): where N is the number of nodes of the binary tree. To establish a binary tree image, you need to traverse all nodes of the tree, taking O(N) time.
• Space complexity O(N): as shown in the figure below, in the worst case, stack stack can be stored at most at the same time N + 1 2 \frac{N+1}{2} 2N+1} nodes, occupying O(N) additional space.
  

5, Sword finger Offer 28. Symmetric binary tree

Question:

Please implement a function to judge whether a binary tree is symmetrical. If a binary tree is the same as its mirror, it is symmetrical.

For example, a binary tree [1,2,2,3,4,4,3] is symmetric.

    1
   / \
  2   2
 / \ / \
3  4 4  3

However, the following [1,2,2,null,3,null,3] is not mirror symmetric:

    1
   / \
  2   2
   \   \
   3    3

Example 1:

Input: root = [1,2,2,3,4,4,3]
Output: true

Example 2:

Input: root = [1,2,2,null,3,null,3]
Output: false

Limitations:

0 <= Number of nodes <= 1000

Solution:

Solution idea: recursive traversal and comparison one by one
AC Code:

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isSymmetric(TreeNode root) {
        if(root == null) return true;
        return recur(root.left, root.right);
    }
    boolean recur(TreeNode L, TreeNode R){
        // 50. R ends recursively at the same time
        if(L == null && R == null) return true;
        // L or R has an early end, with different values
        if(L == null || R == null || L.val != R.val) return false;
        return recur(L.left, R.right) && recur(L.right, R.left);
    }
}

• Time complexity O(N): where N is the number of nodes in the binary tree. Each execution of recur() can judge whether a pair of nodes are symmetrical. Therefore, the recur() method can be called N/2 times at most.
• Spatial complexity O(N): as shown in the figure below, in the worst case (binary tree degenerates into linked list), the system uses a space of O(N).

6, Sword finger Offer 32 - I. print binary tree from top to bottom

Question:

Each node of the binary tree is printed from top to bottom, and the nodes of the same layer are printed from left to right.

For example:
Given binary tree: [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

return:

[3,9,20,15,7]

Tips:

Total number of nodes <= 1000

Solution:

Problem solving idea: BFS
AC Code:

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public int[] levelOrder(TreeNode root) {
        if(root == null) return new int[0];
        List<Integer> res = new ArrayList<>();
        // BFS template
        LinkedList<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while(!queue.isEmpty()){
            TreeNode node = queue.removeFirst();
            res.add(node.val);
            if(node.left != null) queue.add(node.left);
            if(node.right != null) queue.add(node.right);
        }
        // List to array
        int[] ans = new int[res.size()];
        for(int i = 0; i < res.size(); i++){
            ans[i] = res.get(i);
        }
        return ans;
    }
}

• Time complexity O(N): N is the number of nodes in the binary tree, that is, BFS needs to cycle N times.
• Spatial complexity O(N): in the worst case, that is, when the tree is a balanced binary tree, there are at most N/2 tree nodes in the queue at the same time, and the additional space of O(N) size is used.

7, Sword finger Offer 32 - II. Print binary tree II from top to bottom

Question:

The binary tree is printed by layers from top to bottom, the nodes of the same layer are printed from left to right, and each layer is printed to one line.

For example:
Given binary tree: [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

Return its hierarchy traversal result:

[
  [3],
  [9,20],
  [15,7]
]

Tips:

Total number of nodes <= 1000

Solution:

Problem solving idea: BFS
AC Code:

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if(root == null) return res;
        LinkedList<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while(!queue.isEmpty()){
            List<Integer> temp = new ArrayList<>();
            // Sequence traversal and output
            int num = queue.size(); // Get the number of nodes in this layer
            while((num --) > 0){
                TreeNode node = queue.removeFirst();
                temp.add(node.val);
                if(node.left != null) queue.add(node.left);
                if(node.right != null) queue.add(node.right);
            }
            res.add(temp);
        }
        return res;
    }
}

8, Sword finger Offer 32 - III. print binary tree III from top to bottom

Question:

Please implement a function to print the binary tree in zigzag order, that is, the first line is printed from left to right, the second layer is printed from right to left, the third line is printed from left to right, and so on.

For example:
Given binary tree: [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

Return its hierarchy traversal result:

[
  [3],
  [20,9],
  [15,7]
]

Tips:

Total number of nodes <= 1000

Solution:

Solution: sequence traversal + double ended queue
AC Code:

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if(root == null) return res;
        LinkedList<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while(!queue.isEmpty()){
            LinkedList<Integer> temp = new LinkedList<>();
            int num = queue.size(); // level traversal 
            while((num --) > 0){
                TreeNode node = queue.removeFirst();
                if(res.size() % 2 == 0){ // The initial length is 0
                    temp.add(node.val);
                }else{
                    temp.addFirst(node.val);
                }
                if(node.left != null) queue.add(node.left);
                if(node.right != null) queue.add(node.right);          
            }
            res.add(temp);
        }
        return res;       
    }
}

Problem solving ideas:
AC Code:

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if(root == null) return res;
        LinkedList<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while(!queue.isEmpty()){
            List<Integer> temp = new ArrayList<>();
            int num = queue.size(); // level traversal 
            while((num --) > 0){
                TreeNode node = queue.removeFirst();
                temp.add(node.val);
                if(node.left != null) queue.add(node.left);
                if(node.right != null) queue.add(node.right);          
            }
            if(res.size()%2 != 0) Collections.reverse(temp);
            res.add(temp);
        }
        return res;       
    }
}

9, Sword finger Offer 34. A path with a certain value in a binary tree

Question:

Enter a binary tree and an integer, and print out all paths where the sum of node values in the binary tree is the input integer. A path is formed from the root node of the tree down to the leaf node.

A leaf node is a node that has no children.

Example:
Given the following binary tree, and target and target = 22,

          5
         / \
        4   8
       /   / \
      11  13  4
     /  \    / \
    7    2  5   1

return:

[
   [5,4,11,2],
   [5,8,4,5]
]

Tips:

Total number of nodes <= 10000

Solution:

Solution idea: first order traversal + path record
AC Code:

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    LinkedList<List<Integer>> res = new LinkedList<>();
    LinkedList<Integer> path = new LinkedList<>();
    public List<List<Integer>> pathSum(TreeNode root, int target) {
        dfs(root, target);
        return res;
    }
    void dfs(TreeNode root, int tar){
        if(root == null) return;
        path.add(root.val);
        tar -= root.val;
        if(tar == 0 && root.left == null && root.right == null){
            res.add(new LinkedList(path));
        }
        dfs(root.left, tar);
        dfs(root.right, tar);
        path.removeLast();
    }
}

10, Sword finger Offer 36. Binary search tree and bidirectional linked list

Question:

Enter a binary search tree and convert the binary search tree into a sorted circular two-way linked list. It is required that no new node can be created, and only the node pointer in the tree can be adjusted.
To better understand the problem, take the following binary search tree as an example:

We hope to transform this binary search tree into a two-way circular linked list. Each node in the linked list has a precursor and successor pointer. For a two-way circular linked list, the precursor of the first node is the last node, and the successor of the last node is the first node.

The following figure shows the linked list transformed from the above binary search tree. "head" refers to the node with the smallest element in the linked list.

In particular, we want the conversion to be done in place. After the conversion is completed, the left pointer of the node in the tree needs to point to the precursor and the right pointer of the node in the tree needs to point to the successor. You also need to return the pointer of the first node in the linked list.

Solution:

Solution idea: middle order traversal + two-way linked list + circular linked list

It is worth noting that the middle order traversal of the binary search tree in this problem can realize the increasing sequence

AC Code:

/*
// Definition for a Node.
class Node {
    public int val;
    public Node left;
    public Node right;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val,Node _left,Node _right) {
        val = _val;
        left = _left;
        right = _right;
    }
};
*/
class Solution {
    Node pre,head;
    public Node treeToDoublyList(Node root) {
        if(root == null) return null;
        dfs(root);
        // Head to tail docking
        head.left = pre;
        pre.right = head;
        return head;
    }
     void dfs(Node cur){
        if(cur == null) return;
        // Medium order traversal
        dfs(cur.left); // Left
        // root
        // Double linked list template
        if(pre != null) pre.right = cur;
        else head = cur;
        cur.left = pre;
        // Pointer pre shift right
        pre = cur;
        dfs(cur.right); // right
    }
}

• Time complexity O(N): N is the number of nodes of the binary tree, and all nodes need to be accessed for medium order traversal.
• Space complexity O(N): in the worst case, that is, when the tree degenerates into a linked list, the recursion depth reaches N, and the system uses O(N) stack space.

11, Sword finger Offer 37. Serialized binary tree

Question:

Please implement two functions to serialize and deserialize the binary tree respectively.

You need to design an algorithm to realize the serialization and deserialization of binary tree. There is no restriction on the execution logic of your sequence / deserialization algorithm. You only need to ensure that a binary tree can be serialized into a string and deserialize the string into the original tree structure.

Note: the input / output format is the same as that currently used by LeetCode. For details, please refer to the format of LeetCode serialized binary tree. You don't have to take this approach, you can also take other methods to solve the problem.

Example:

Input: root = [1,2,3,null,null,4,5]
Output:[1,2,3,null,null,4,5]

Solution:

Solution: sequence traversal
AC Code:

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Codec {

    // Encodes a tree to a single string.
    public String serialize(TreeNode root) {
        if(root == null) return "[]";
        StringBuilder res = new StringBuilder("[");
        // BFS
        LinkedList<TreeNode> queue = new LinkedList<>(){{add(root);}};
        while(!queue.isEmpty()){
            TreeNode node = queue.removeFirst();
            if(node != null){
                res.append(node.val + ",");
                queue.add(node.left);
                queue.add(node.right);
            }else res.append("null,");
        }
        res.deleteCharAt(res.length() - 1); // Remove the last comma
        res.append("]");
        return res.toString();
    }

    // Decodes your encoded data to tree.
    public TreeNode deserialize(String data) {
        if(data.equals("[]")) return null;
        // string manipulation
        String[] vals = data.substring(1, data.length() - 1).split(",");
        // BFS
        int index = 0; // Traversal array pointer
        TreeNode root = new TreeNode(Integer.parseInt(vals[index++]));
        LinkedList<TreeNode> queue = new LinkedList<>(){{add(root);}};
        while(!queue.isEmpty()){
            TreeNode node = queue.removeFirst();
            if(!vals[index].equals("null")){
                node.left = new TreeNode(Integer.parseInt(vals[index]));
                queue.add(node.left);
            }
            index ++;
            if(!vals[index].equals("null")){
                node.right = new TreeNode(Integer.parseInt(vals[index]));
                queue.add(node.right);
            }
            index ++;
        }
        return root;
    }
}

// Your Codec object will be instantiated and called as such:
// Codec codec = new Codec();
// codec.deserialize(codec.serialize(root));

• Time complexity O(N): N is the number of nodes of the binary tree. Sequence traversal needs to access all nodes. In the worst case, it needs to access N + 1 null s. The overall complexity is
  O( N + 1 2 \frac{N+1}{2} 2N+1​) = O(N).
• Spatial complexity O(N): in the worst case, the queue stores 2N+1 nodes (or N+1 null s) at the same time, using O(N); The list res uses O(N).

12, Sword finger Offer 38. Arrangement of strings

Question:

Enter a string and print out all the arrangements of characters in the string.

You can return this string array in any order, but there can be no duplicate elements.

Example:

Input: s = "abc"
Output:["abc","acb","bac","bca","cab","cba"]

Limitations:

1 <= s Length of <= 8

Solution:

Problem solving ideas: dfs + backtracking
Illustration:

List all full permutations of 1, 2 and 3, and add dfs traversal to res one by one

For a string of length n (assuming that the characters do not repeat each other), the number of arrangement schemes is: n × (n−1) × (n−2)… × two × one

swap() function:

AC Code:

class Solution {
    List<String> res = new LinkedList<>();
    char[] c;
    public String[] permutation(String s) {
        c = s.toCharArray();
        dfs(0);
        return res.toArray(new String[res.size()]);
    }
    void dfs(int x) {
        if(x == c.length - 1) {
            res.add(String.valueOf(c));      // Add arrangement scheme
            return;
        }
        HashSet<Character> set = new HashSet<>();
        for(int i = x; i < c.length; i++) {
            if(set.contains(c[i])) continue; // Repeat, so prune
            set.add(c[i]);
            swap(i, x);                      // Swap, fix c[i] in bit x
            dfs(x + 1);                      // Turn on fixed x + 1 st character
            swap(i, x);                      // Recovery exchange
        }
    }
    void swap(int a, int b) {
        char tmp = c[a];
        c[a] = c[b];
        c[b] = tmp;
    }
}

• Time complexity O(N!N): n is the length of string s; The time complexity is linear with the number of schemes of string arrangement, and the number of schemes is n × (N−1) × (N−2)… × two × 1, that is, the complexity is O(N!); The string splicing operation join() uses O(N); Therefore, the overall time complexity is O(N!N).
• Space complexity O(N2): the recursion depth of full permutation is n, and the cumulative stack space used by the system is O(N); The maximum cumulative number of characters stored by the auxiliary Set in recursion is N + (N-1) +... + 2 + 1 = (N+1)N/2, that is, it occupies additional space of O(N2).

13, Sword finger Offer 54. The k-th node of the binary search tree

Question:

Given a binary search tree, please find the k-largest node.

Example 1:

input: root = [3,1,4,null,2], k = 1
   3
  / \
 1   4
  \
   2
 output: 4

Example 2:

input: root = [5,3,6,2,4,null,null,1], k = 3
       5
      / \
     3   6
    / \
   2   4
  /
 1
 output: 4

Limitations:

1 ≤ k ≤ Number of binary search tree elements

Solution:

Solution idea: middle order traversal reverse order
AC Code:

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    int res, k; // Returned result, k
    public int kthLargest(TreeNode root, int k) {
		this.k = k;
        dfs(root); // Inverse middle order traversal
        return res;
    }
    void dfs(TreeNode root){
		if(root == null) return;
        dfs(root.right); // right
        k--;
        if(k == 0){
			res = root.val;
            return;
        }
        dfs(root.left); // Left
    }
}

• Time complexity O(N): when the tree degenerates into a linked list (all right child nodes), the recursion depth is N regardless of the value of k, occupying O(N) time.
• Space complexity O(N): when the tree degenerates into a linked list (all right child nodes), the system uses a stack space of O(N).

14, Sword finger Offer 55 - I. depth of binary tree

Question:

Enter the root node of a binary tree to find the depth of the tree. The nodes (including root and leaf nodes) passing from root node to leaf node form a path of the tree, and the length of the longest path is the depth of the tree.

For example:

Given binary tree [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

Returns its maximum depth 3.

Tips:

Total number of nodes <= 10000

Solution:

Problem solving idea: DFS (post order traversal)
AC Code:

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public int maxDepth(TreeNode root) {
        if(root == null) return 0; // Export
        return Math.max(maxDepth(root.left),maxDepth(root.right)) + 1;
    }
}

• Time complexity O(N): N is the number of nodes in the tree. To calculate the depth of the tree, you need to traverse all nodes.
• Spatial complexity O(N): in the worst case (when the tree degenerates into a linked list), the recursion depth can reach N.

Problem solving idea: BFS
AC Code:

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public int maxDepth(TreeNode root) {
        if(root == null) return 0;
        LinkedList<TreeNode> queue = new LinkedList<>(){{add(root);}};
        int res = 0;
        while(!queue.isEmpty()){
            LinkedList<TreeNode> temp = new LinkedList<>();
            // level traversal 
            for(TreeNode node : queue){
                if(node.left != null) temp.add(node.left);
                if(node.right != null) temp.add(node.right);
            }
            queue = temp;
            res ++;
        }
        return res;
    }
}

• Time complexity O(N): N is the number of nodes in the tree. To calculate the depth of the tree, you need to traverse all nodes.
• Spatial complexity O(N): in the worst case (when the tree is balanced), the queue stores N/2 nodes at the same time.

15, Sword finger Offer 55 - II. Balanced binary tree

Question:

Enter the root node of a binary tree to judge whether the tree is a balanced binary tree. If the depth difference between the left and right subtrees of any node in a binary tree is no more than 1, it is a balanced binary tree.

Example 1:

Given binary tree [3,9,20,null,null,15,7]

    3
   / \
  9  20
    /  \
   15   7

Returns true.

Example 2:

Given binary tree [1,2,2,3,3,null,null,4,4]

       1
      / \
     2   2
    / \
   3   3
  / \
 4   4

Returns false.

Limitations:

0 <= Number of nodes in the tree <= 10000

Solution:

Problem solving idea: first order traversal + judgment depth (from top to bottom)
AC Code:

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isBalanced(TreeNode root) {
        if(root == null) return true;
        return Math.abs(dfs(root.left) - dfs(root.right)) <= 1 && isBalanced(root.left) && isBalanced(root.right);
    }
    // Returns the depth of the node
    int dfs(TreeNode root){
        if(root == null) return 0;
        return Math.max(dfs(root.left), dfs(root.right)) + 1;
    }
}

16, Sword finger Offer 64. Find 1 + 2 +... + n

Question:

For 1 + 2 +... + n, it is required that keywords such as multiplication and division, for, while, if, else, switch, case and conditional judgment statements (A?B:C) cannot be used.

Example 1:

input: n = 3
 output: 6

Example 2:

input: n = 9
 output: 45

Limitations:

1 <= n <= 10000

Solution:

Solution idea: bit operation
AC Code:

class Solution {
    int res = 0;
    public int sumNums(int n) {
        boolean x = n > 1 && sumNums(n-1) > 0;
        res += n;
        return res;
    }
}

17, Sword finger Offer 68 - I. nearest common ancestor of binary search tree

Question:

Given a binary search tree, find the nearest common ancestor of two specified nodes in the tree.

Baidu Encyclopedia defines the nearest public ancestor as: "for two nodes p and q with root tree T, the nearest public ancestor is expressed as a node x, which satisfies that x is the ancestor of p and q, and the depth of X is as large as possible (a node can also be its own ancestor)."

For example, give the following binary search tree: root = [6,2,8,0,4,7,9,null,null,3,5]

Example 1:

input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
 output: 6 
explain: The nearest common ancestor of node 2 and node 8 is 6.

Example 2:

input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
 output: 2
 explain: The nearest common ancestor of node 2 and node 4 is 2, Because according to the definition, the nearest common ancestor node can be the node itself.

explain:

The values of all nodes are unique.
p,q Are different nodes and all exist in a given binary search tree.

Solution:

Problem solving idea: recursion

Binary lookup tree: unique value, left less than right

Definition of ancestor: if node p is in the left (right) subtree of node root, or p = root, root is said to be the ancestor of p.

Nearest common ancestor: set node root as a common ancestor of nodes P and Q. if its left child node root.left and right child node root.right are not the common ancestors of P and Q, root is called "nearest common ancestor".

AC Code:

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        // On the right side of the root node
        if(root.val < p.val && root.val < q.val) return lowestCommonAncestor(root.right,p,q);
        // To the left of the root node
        if(root.val > p.val && root.val > q.val) return lowestCommonAncestor(root.left,p,q);
        // Different side
        return root;
    }
}

• Time complexity O(N): where N is the number of binary tree nodes; One layer is excluded in each cycle. The minimum number of layers of binary search tree is logN (full binary tree) and the maximum is N (degenerated into linked list).
• Spatial complexity O(N): in the worst case, that is, when the tree degenerates into a linked list, the recursion depth reaches the number of layers N of the tree.

18, Sword finger Offer 68 - II. Nearest common ancestor of binary tree

Question:

Given a binary tree, find the nearest common ancestor of two specified nodes in the tree.

Baidu Encyclopedia defines the nearest public ancestor as: "for two nodes p and q with root tree T, the nearest public ancestor is expressed as a node x, which satisfies that x is the ancestor of p and q, and the depth of X is as large as possible (a node can also be its own ancestor)."

For example, give the following binary tree: root = [3,5,1,6,2,0,8,null,null,7,4]

Example 1:

input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
 output: 3
 explain: The nearest common ancestor of node 5 and node 1 is node 3.

Example 2:

input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
 output: 5
 explain: The nearest common ancestor of node 5 and node 4 is node 5. Because according to the definition, the nearest common ancestor node can be the node itself.

explain:

The values of all nodes are unique.
p,q Are different nodes and all exist in a given binary tree.

Solution:

Problem solving ideas:
AC Code:

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if(root == null || root == p || root == q) return root; // Export
        TreeNode left = lowestCommonAncestor(root.left, p, q);
        TreeNode right = lowestCommonAncestor(root.right, p, q);
        if(left != null && right != null) return root; // There are both left and right subtrees
        else return left != null ? left : right;
    }
}