二叉搜索樹的操作

二叉搜索樹（Binary Search Tree）是一種特殊形式的二叉樹，節點值大於左子樹小於右子樹。因爲這種性質，導致它的中序遍歷爲升序。

• 判斷一顆二叉樹是否爲二叉搜索樹
• 二叉搜索樹迭代器
• 二叉搜索樹查找
• 二叉搜索樹插入
• 二叉搜索樹刪除
• 二叉搜索樹查找第K大的節點
• 二叉搜索樹在指定範圍內查找符合條件的兩個節點
• 二叉搜索樹是否平衡
• 有序數組構造二叉搜索樹

---

判斷一顆二叉樹是否爲二叉搜索樹

可以根據二叉搜索樹的特性進行判斷，節點值大於左子樹小於右子樹。

    private boolean isValidBST(TreeNode root) {
        if (root != null) {
            //一直到最左的左葉子節點
            if (!isValidBST(root.left)) return false;

            //第一次執行到這裏時pre爲空
            if (pre != null && root.val <= pre.val) return false;

            //第一次爲pre賦值的爲最小的葉子節點
            pre = root;

            return isValidBST(root.right);
        }
        return true;
    }

類似中序遍歷

二叉搜索樹迭代器

迭代器需要判斷是否存在下一項，且按序迭代。
可以採用棧來完成，迭代器初始化時將根結點的所有左子樹壓棧，每次出棧時將出棧節點的所有右子樹壓棧。當棧爲空時二叉搜索樹迭代完成。

https://blog.csdn.net/smile_watermelon/article/details/47280679

    class BSTIterator {
        LinkedList<TreeNode> stack = new LinkedList<TreeNode>();

        public BSTIterator(TreeNode root) {
            TreeNode node = root;
            //壓入根結點及所有的左孩子節點
            while (node != null) {
                stack.push(node);
                node = node.left;
            }
        }

        public boolean hasNext() {
            return !stack.isEmpty();
        }

        public TreeNode next() {
            TreeNode node = stack.pop();//1、根結點出棧（根結點小於右節點）

            TreeNode temp = node.right;
            while (temp != null) {
                stack.push(temp);//右節點入棧
                temp = temp.left;//右節點的左節點入棧
            }
            //所以棧頂值最小
            return node;
        }
    }

二叉搜索樹查找

根據性質，小於根結點的去左子樹去找，大於根結點的去右子樹去找。

    private TreeNode search(TreeNode root, int key) {
        if (root == null) {
            return null;
        }
        if (key < root.val) {
            return search(root.left, key);
        } else if (key > root.val) {
            return search(root.right, key);
        } else {
            return root;
        }
    }

二叉搜索樹插入

插入的節點必須符合二叉搜索樹的性質

    private TreeNode insert(TreeNode root, int key) {

        if (root == null) {
            return new TreeNode(key);
        }

        if (key < root.val) {
            if (root.left == null) {
                root.left = new TreeNode(key);
            } else {
                insert(root.left, key);
            }
        }
        if (key > root.val) {
            if (root.right == null) {
                root.right = new TreeNode(key);
            } else {
                insert(root.right, key);
            }
        }

        return root;
    }

二叉搜索樹刪除

刪除的節點如果是葉子節點，則直接刪除。如果不是葉子節點，刪除節點可能會導致樹斷掉，因此需要將刪掉節點的子樹連接到刪掉節點的父節點上，且要保證連接後的二叉樹爲二叉搜索樹。

    private TreeNode delete(TreeNode root, int key) {

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

        if (key < root.val) {
            root.left = delete(root.left, key);
        } else if (key > root.val) {
            root.right = delete(root.right, key);
        } else {
            if (root.left == null) {
                return root.right;
            } else if (root.right == null) {
                return root.left;
            } else {
                root.val = min(root.right);
                root.right = delete(root.right, root.val);
            }
        }
        return root;
    }

    private int min(TreeNode root) {
        TreeNode node = root;
        while (node != null && node.left != null) {
            node = node.left;
        }
        return node.val;
    }

二叉搜索樹查找第K大的節點

由二叉搜索樹的性質右子樹大於節點，優先遍歷右子樹，遍歷次數爲K時返回節點。

https://www.geeksforgeeks.org/kth-largest-element-in-bst-when-modification-to-bst-is-not-allowed/

    private void kThLargest(TreeNode node, int k) {

        if (node == null || c > k) {
            return;
        }

        kThLargest(node.right, k);

        c++;
        if (c == k) {
            kThNode = node;
            return;
        }

        kThLargest(node.left, k);

    }

二叉搜索樹在指定範圍內查找符合條件的兩個節點

使用到了TreeSet
set.floor(num)用於返回set中小於num的最大的項
set.ceiling(num)用於返回set中大於num的最小的項

    private boolean containsNearbyAlmostDuplicate(int[] nums, int k, int t) {

        if (nums == null || nums.length == 0) {
            return false;
        }

        if (k <= 0 || t < 0) {
            return false;
        }

        TreeSet<Integer> set = new TreeSet<Integer>();

        for (int i = 0; i < nums.length; i++) {
            int num = nums[i];

            if ((set.floor(num) != null && num - set.floor(num) <= t)
                    || set.ceiling(num) != null && set.ceiling(num) - num <= t) {
                return true;
            } else {
                set.add(num);
            }

            if (i >= k) {//控制窗口大小
                set.remove(nums[i - k]);
            }
        }
        return false;
    }

二叉搜索樹是否平衡

平衡的條件是左右子樹的高度差不大於1。

    private boolean isBalance(TreeNode root) {
        if (root == null) {
            return true;
        }
        if (Math.abs(height(root.left) - height(root.right)) > 1) {
            return false;
        }

        return isBalance(root.left) && isBalance(root.right);
    }

    private int height(TreeNode node) {

        if (node == null) {
            return 0;
        }

        int left = height(node.left);
        int right = height(node.right);

        return (left > right ? left : right) + 1;

    }

有序數組構造二叉搜索樹

有序數組中間節點爲根結點，以此將一個數組分成兩個數組。
將問題縮小，分而治之，明顯的遞歸操作。

    private TreeNode sortedArrayToBST(int[] nums) {
        if (nums.length == 0) {
            return null;
        }

        if (nums.length == 1) {
            return new TreeNode(nums[0]);
        }

        int center = nums.length / 2;

        TreeNode root = new TreeNode(nums[center]);

        int[] left = new int[center];
        int[] right = new int[nums.length - center - 1];

        System.arraycopy(nums, 0, left, 0, center);
        System.arraycopy(nums, center + 1, right, 0, nums.length - center - 1);

        root.left = sortedArrayToBST(left);
        root.right = sortedArrayToBST(right);

        return root;
    }

GitHub