Java的二叉搜索樹

Java的二叉搜索樹

概念

二叉搜索樹又稱二叉排序樹，它或者是一棵空樹，或者是具有以下性質的二叉樹:
若它的左子樹不爲空，則左子樹上所有節點的值都小於根節點的值
若它的右子樹不爲空，則右子樹上所有節點的值都大於根節點的值
它的左右子樹也分別爲二叉搜索樹

查找

插入

1. 如果樹爲空樹，即根 == null，直接插入
   
2. 如果樹不是空樹，按照查找邏輯確定插入位置，插入新結點

刪除

設待刪除結點爲 cur, 待刪除結點的雙親結點爲 parent

1. cur.left == null
   1. cur 是 root，則 root = cur.right
   2. cur 不是 root，cur 是 parent.left，則 parent.left = cur.right
   3. cur 不是 root，cur 是 parent.right，則 parent.right = cur.right
2. cur.right == null
   1. cur 是 root，則 root = cur.left
   2. cur 不是 root，cur 是 parent.left，則 parent.left = cur.left
   3. cur 不是 root，cur 是 parent.right，則 parent.right = cur.left
3. cur.left != null && cur.right != null
   需要使用替換法進行刪除，即在它的右子樹中尋找中序下的第一個結點(關鍵碼最小)，用它的值填補到被刪除節點中，再來處理該結點的刪除問題(左子樹最大的或者右子樹最小的值)

代碼實現二叉搜索樹

public class BinarySearchTree {
    public static class Node {
        int key;
        Node left;
        Node right;

        public Node(int key) {
            this.key = key;
        }
    }

    private Node root = null;

    /**
     * 在搜索樹中查找 key，如果找到，返回 key 所在的結點，否則返回 null
     *
     * @param key
     * @return
     */
    public Node search(int key) {
        Node cur = root;
        while (cur != null) {
            if (key == cur.key) {
                return cur;
            } else if (key < cur.key) {
                cur = cur.left;
            } else {
                cur = cur.right;
            }
        }
        return null;
    }

    /**
     * 插入
     *
     * @param key
     * @return true 表示插入成功, false 表示插入失敗
     */
    public boolean insert(int key) {
        if (root == null) {
            root = new Node(key);
            return true;
        }
        Node cur = root;
        Node parent = null;
        while (cur != null) {
            if (key == cur.key) {
                return false;
            } else if (key < cur.key) {
                parent = cur;
                cur = cur.left;
            } else {
                parent = cur;
                cur = cur.right;
            }
        }
        Node node = new Node(key);
        if (key < parent.key) {
            parent.left = node;
        } else {
            parent.right = node;
        }
        return true;
    }

    /**
     * 刪除成功返回 true，失敗返回 false
     *
     * @param key
     * @return
     */
    public boolean remove(int key) {
        Node cur = root;
        Node parent = null;
        while (cur != null) {
            if (key == cur.key) {
// 找到，準備刪除
                removeNode(parent, cur);
                return true;
            } else if (key < cur.key) {
                parent = cur;
                cur = cur.left;
            } else {
                parent = cur;
                cur = cur.right;
            }
        }
        return false;
    }

    private void removeNode(Node parent, Node cur) {
        if (cur.left == null) {
            if (cur == root) {
                root = cur.right;
            } else if (cur == parent.left) {
                parent.left = cur.right;
            } else {
                parent.right = cur.right;
            }
        } else if (cur.right == null) {
            if (cur == root) {
                root = cur.left;
            } else if (cur == parent.left) {
                parent.left = cur.left;
            } else {
                parent.right = cur.left;
            }
        } else {
            Node goatParent = cur;
            Node goat = cur.right;
            while (goat.left != null) {
                goatParent = goat;
                goat = goat.left;
            }
            cur.key = goat.key;
//cur.value = goat.value;
            if (goat == goatParent.left) {
                goatParent.left = goat.right;
            } else {
                goatParent.right = goat.right;
            }
        }
    }

    public static void main(String[] args) {
// 1. 創建搜索樹
// 2. 隨機插入一些數據
// 3. 打印前序 + 中序遍歷
// 4. 查找
        BinarySearchTree tree = new BinarySearchTree();
        int[] keys = {3, 9, 7, 4, 1, 6, 2, 8, 5};
        for (int key : keys) {
            System.out.println(tree.insert(key));
        }
        System.out.println("插入重複數據");
        System.out.println(tree.insert(7));
        System.out.println("前序遍歷");
        preOrder(tree.root);
        System.out.println("中序遍歷");
        inOrder(tree.root);
        System.out.println(tree.search(7).key);
        System.out.println(tree.search(8).key);
        System.out.println(tree.search(5).key);
    }

    private static void inOrder(Node node) {
        if (node != null) {
            inOrder(node.left);
            System.out.println(node.key);
            inOrder(node.right);
        }
    }

    private static void preOrder(Node node) {
        if (node != null) {
            System.out.println(node.key);
            preOrder(node.left);
            preOrder(node.right);
        }
    }
}