## 二、二叉搜索树 BST

Java 实现代码如下：

`public class BinarySearchTree {    /**     * 根节点     */    public static TreeNode root;    public BinarySearchTree() {        this.root = null;    }    /**     * 查找     */    public TreeNode search (int key) {        TreeNode current = root;        while (current != null                && key != current.value) {            if (key < current.value )                current = current.left;            else                current = current.right;        }        return current;    }    /**     * 插入     */    public TreeNode insert (int key) {        // 新增节点        TreeNode newNode = new TreeNode(key);        // 当前节点        TreeNode current = root;        // 上个节点        TreeNode parent  = null;        // 如果根节点为空        if (current == null) {            root = newNode;            return newNode;        }        while (true) {            parent = current;            if (key < current.value) {                current = current.left;                if (current == null) {                    parent.left = newNode;                    return newNode;                }            } else {                current = current.right;                if (current == null) {                    parent.right = newNode;                    return newNode;                }            }        }    }    /**     * 删除节点     */    public TreeNode delete (int key) {        TreeNode parent  = root;        TreeNode current = root;        boolean isLeftChild = false;        // 找到删除节点 及 是否在左子树        while (current.value != key) {            parent = current;            if (current.value > key) {                isLeftChild = true;                current = current.left;            } else {                isLeftChild = false;                current = current.right;            }            if (current == null) {                return current;            }        }        // 如果删除节点左节点为空 , 右节点也为空        if (current.left == null && current.right == null) {            if (current == root) {                root = null;            }            // 在左子树            if (isLeftChild == true) {                parent.left = null;            } else {                parent.right = null;            }        }        // 如果删除节点只有一个子节点 右节点 或者 左节点        else if (current.right == null) {            if (current == root) {                root = current.left;            } else if (isLeftChild) {                parent.left = current.left;            } else {                parent.right = current.left;            }        }        else if (current.left == null) {            if (current == root) {                root = current.right;            } else if (isLeftChild) {                parent.left = current.right;            } else {                parent.right = current.right;            }        }        // 如果删除节点左右子节点都不为空        else if (current.left != null && current.right != null) {            // 找到删除节点的后继者            TreeNode successor = getDeleteSuccessor(current);            if (current == root) {                root = successor;            } else if (isLeftChild) {                parent.left = successor;            } else {                parent.right = successor;            }            successor.left = current.left;        }        return current;    }    /**     * 获取删除节点的后继者     *      删除节点的后继者是在其右节点树种最小的节点     */    public TreeNode getDeleteSuccessor(TreeNode deleteNode) {        // 后继者        TreeNode successor = null;        TreeNode successorParent = null;        TreeNode current = deleteNode.right;        while (current != null) {            successorParent = successor;            successor = current;            current = current.left;        }        // 检查后继者(不可能有左节点树)是否有右节点树        // 如果它有右节点树,则替换后继者位置,加到后继者父亲节点的左节点.        if (successor != deleteNode.right) {            successorParent.left = successor.right;            successor.right = deleteNode.right;        }        return successor;    }    public void toString(TreeNode root) {        if (root != null) {            toString(root.left);            System.out.print("value = " + root.value + " -> ");            toString(root.right);        }    }}/** * 节点 */class TreeNode {    /**     * 节点值     */    int value;    /**     * 左节点     */    TreeNode left;    /**     * 右节点     */    TreeNode right;    public TreeNode(int value) {        this.value = value;        left  = null;        right = null;    }}`

### 面试点二：如何确定二叉树的最大深度或者最小深度

`int maxDeath(TreeNode node){    if(node==null){        return 0;    }    int left = maxDeath(node.left);    int right = maxDeath(node.right);    return Math.max(left,right) + 1;}    int getMinDepth(TreeNode root){        if(root == null){            return 0;        }        return getMin(root);    }    int getMin(TreeNode root){        if(root == null){            return Integer.MAX_VALUE;        }        if(root.left == null&&root.right == null){            return 1;        }        return Math.min(getMin(root.left),getMin(root.right)) + 1;    }`

### 面试点三：如何确定二叉树是否是平衡二叉树

`boolean isBalanced(TreeNode node){        return maxDeath2(node)!=-1;    }    int maxDeath2(TreeNode node){        if(node == null){            return 0;        }        int left = maxDeath2(node.left);        int right = maxDeath2(node.right);        if(left==-1||right==-1||Math.abs(left-right)>1){            return -1;        }        return Math.max(left, right) + 1;    }`

`public class BinarySearchTreeTest {    public static void main(String[] args) {        BinarySearchTree b = new BinarySearchTree();        b.insert(3);b.insert(8);b.insert(1);b.insert(4);b.insert(6);        b.insert(2);b.insert(10);b.insert(9);b.insert(20);b.insert(25);        // 打印二叉树        b.toString(b.root);        System.out.println();        // 是否存在节点值10        TreeNode node01 = b.search(10);        System.out.println("是否存在节点值为10 => " + node01.value);        // 是否存在节点值11        TreeNode node02 = b.search(11);        System.out.println("是否存在节点值为11 => " + node02);        // 删除节点8        TreeNode node03 = b.delete(8);        System.out.println("删除节点8 => " + node03.value);        b.toString(b.root);    }}`

`value = 1 -> value = 2 -> value = 3 -> value = 4 -> value = 6 -> value = 8 -> value = 9 -> value = 10 -> value = 20 -> value = 25 -> 是否存在节点值为10 => 10是否存在节点值为11 => null删除节点8 => 8value = 1 -> value = 2 -> value = 3 -> value = 4 -> value = 6 -> value = 9 -> value = 10 -> value = 20 -> value = 25 ->`

### 面试点四：搜索二叉树如何实现插入

1. 值为 2 的节点开始判断
2. 如果为空，则插入该节点
3. 循环下面节点:
1. 节点当前值大于，继续循环左节点
2. 节点当前值小于，继续循环右节点

### 面试点五：搜索二叉树如何实现查找

1. 值为 2 的节点开始判断
1. 节点当前值大于，继续循环左节点
2. 节点当前值小于，继续循环右节点
1. 如果值相等，搜索到对应的值，并返回
2. 如果循环完毕没有，则返回未找到

• 树，二叉树的概念
• BST 算法