leetcode 315 Count of Smaller Numbers After Self 以及 BST總結。

跳過總結請點這裏：
https://segmentfault.com/a/11...

BST最明顯的特色就是root.left.val < root.val < root.right.val.
還有另外一個特色就是，bst inorder traversal result is an ascending array.

下面簡單表示一個BST:

60
         /        \
        40         80
      /    \      /  \
     20     50   70   90
    / \                \
  10   30              100

BST inorder traversal result is: 10 20 30 40 50 60 70 80 90 100.

BST 和普通的樹的區別就在於它是一個有序的，爲了保證順序，咱們須要經過inorder traversal獲得，因此幾乎全部leetcode關於bst的題目，都是在考咱們如何利用inorder traverse.

簡單題目只過代碼思路，代碼會附在題號底下，爲了減小博客篇幅，題目描述細節請參看leetcode。

LC 173 Binary Search Tree Iterator.
Calling next() will return the next smallest number in the BST.

題目意思就是要一個個的返回bst當前的最小值。強提示：有序。
因此解法天然就是bst inorder traverse。起點就是BST裏最小的值，也就是leftmost.

public class BSTIterator {
    ArrayDeque<TreeNode> stk;
    
    public BSTIterator(TreeNode root) {
        stk = new ArrayDeque<TreeNode>();
        pushAll(root);
    }

    /** @return whether we have a next smallest number */
    public boolean hasNext() {
        return !stk.isEmpty();
    }

    /** @return the next smallest number */
    public int next() {
        TreeNode node = stk.pop();
        if(node.right !=null) {
            pushAll(node.right);
        }
        return node.val;
    }
    
    public void pushAll(TreeNode node){
        while(node != null){
            stk.push(node);
            node = node.left;
        }
    }
}

新增了預處理的方法。這個方法的好處就是每次next()都是嚴格的O(1), 而上面那個方法只是AVE O(1).

public class BSTIterator {
    ArrayList<Integer> ascending;
    int pos = 0;
    
    public BSTIterator(TreeNode root) {
        ascending = new ArrayList<Integer>();
        inorder(root, ascending);
    }

    /** @return whether we have a next smallest number */
    public boolean hasNext() {
        return pos < ascending.size();
    }

    /** @return the next smallest number */
    public int next() {
        return ascending.get(pos++);
    }
    
    public void inorder(TreeNode root, ArrayList<Integer> ascending){
        if(root == null) return;
        inorder(root.left, ascending);
        ascending.add(root.val);
        inorder(root.right, ascending);
    }
}

LC 230 Kth Smallest Element in a BST

返回BST裏第k小的元素。 強提示：有序。
從leftmost開始，找到第k個點返回。時間複雜度近似到O(K).
爲了寫代碼的清晰度，咱們使用recursion的方法作inorder traversal。

public class Solution {
    public int kthSmallest(TreeNode root, int k) {
        if(root == null) return 0;
        int[] res = {Integer.MIN_VALUE};
        kthSmallest(root, k, res);
        return res[0];
    }
    
    public int kthSmallest(TreeNode root, int k, int[] res){
        if(res[0] != Integer.MIN_VALUE || root == null){    //if finded kth, all recursion will immediately return to root.
            return 0;
        }
        int left = kthSmallest(root.left, k,res);
        if(left == k-1){
            res[0] = root.val;
        }
        int right = kthSmallest(root.right, k - left -1, res);
        return left + right + 1;

LC99 Recover Binary Search Tree
Two elements of a binary search tree (BST) are swapped by mistake.

若是BST中有兩個節點位置互相交換了，怎麼辦？ 代表BST的順序被打亂。咱們須要找出被打亂的點並返回正確結果。

利用上面給的BST的圖，咱們swap(20, 90)，獲得以下BST：

60
         /        \
        40         80
      /    \      /  \
     90     50   70   20
    / \                \
  10   30              100

inorder traversal result is:
10 90 30 40 50 60 70 80 20 100
this is not an ascending array.
90 >30, 80 >20 這兩處順序不合理，靠前的值大於靠後的值。
因此這裏咱們在inorder traversal的同時，咱們還須要比較pre.val和cur.val。
而後將兩個不正確的點記錄下來，最後swap回原來正確的值。

public class Solution {
    private TreeNode firstNode = null;
    private TreeNode secondNode = null;
    private TreeNode preNode = new TreeNode(Integer.MIN_VALUE);
    
    public void recoverTree(TreeNode root) {
        if(root == null) return;
        inorderTraversal(root);
        
        int temp = firstNode.val;
        firstNode.val = secondNode.val;
        secondNode.val = temp;
    }
    
    public void inorderTraversal(TreeNode root){
        if(root == null) return;
        
        inorderTraversal(root.left);
        
        if(firstNode == null && preNode.val > root.val) {
            firstNode = preNode;
        }
        
        if(firstNode != null && preNode.val > root.val) {
            secondNode = root;
        }
        
        preNode = root;
        
        inorderTraversal(root.right);
        
    }
}

LC450 Delete Node in a BST

找到一個點容易，利用root.left.val < root.val < root.right.val，時間複雜度O（logN)找到。
刪除一個點。若是是葉子節點，或者只有一個子樹。都容易操做。
若是是中間節點怎麼辦？咱們找到它在bst裏的前一個點（或者後一個點），改變要刪除節點的值，而後刪除它的前一個點。
思想來自於heap的代碼實現。咱們每次Pop的時候取的是根節點的值，而後把heap裏最尾端的點換到根節點，而後shift down。

public class Solution {
    public TreeNode deleteNode(TreeNode root, int key) {
        if(root == null) return null;
        
        if(key < root.val) {
            root.left = deleteNode(root.left, key);
        } else if(key > root.val) {
            root.right = deleteNode(root.right, key);
        } else {
            if(root.left == null) {
                return root.right;
            } else if(root.right == null) {
                return root.left;
            }
            
            TreeNode node = findNextMin(root.right);
            root.val = node.val;
            root.right = deleteNode(root.right, node.val);
        }
        return root;
    }
    
    public TreeNode findNextMin(TreeNode node) {
        while(node.left != null) {
            node = node.left;
        }
        return node;
    }
}

寫不下了，換一篇，點這裏：
https://segmentfault.com/a/11...