二叉搜索树(BST)

一、前言

关于二叉树还有个故事，Max Howell曾经面试因做不出翻转二叉树，面试被Google拒了。前几天也跟字节面试官交流了一下，太多的东西发现掌握的不够深刻，数据结构还是要坚持学下去，不多说开始coding。

二、完全二叉树

问题：关于完全二叉树有这样一个问题，如果一颗完全二叉树有786个节点，求叶子节点的个数？

推导过程：

假设叶子节点的个数为n1,我们知道叶子节点的度为0。假设度为1的节点个数为n2，度为2的节点个数为n3，该二叉树的边树为T。我们就能得到：

除了根节点外，每个节点都对应着一条边。所以：T = n1+n2+n3-1 =0*n1+ 1*n2+2*n3    推出：n1-1=n3

所以：768 = n1+n2+n3 = 2*n1 - 1 +n2  

注意：完全二叉树有一个重要的性质就是度为1的节点的个数要么是0，要么是1。所以很容易推出 n1 = 384

三、二叉搜索树(BinarySearchTree)

其实无论什么数据结构，其实它的核心方法都是增删改查。二叉搜索树的特点就是:对于一个节点来说它的左子树所有节点都小于它，它的右子树所有节点都大于它。

1.成员变量

一个二叉搜索树的成员变量应该有哪些呢？

    private int size; //树的大小
    private Node<E> root; //根节点
  
    private static class Node<E>{
        E element;
        Node<E> left;
        Node<E> right;
        Node<E> parent;

        public Node(E element,Node<E> parent){
            this.element = element;
            this.parent = parent;
        }
    }

2.添加方法add()

思路：我们要添加一个元素，首先我们的找到它要添加的位置在哪里？举个例子：假设我们要添加元素10

首先10比7大，所以10一定在7的右子树中。同理10又比9大，那么10也一定在9的右子树中，然后10和11比较，发现10比11小，那么10一定在11的左子树中，然后我们发现11的左子树是空的，所以10添加的位置是11的左子树。

如果root为空说明，这个二叉搜索树就是空的，所以添加的节点直接添加就行了。

如果root不为空，我们希望找到该节点的父节点，我们才能添加，那问题是怎么找呢？就是从根节点开始迭代，不断循环。由于我们定义的是泛型，所以我们传入的元素一定是可比较的。

所以我们定义了一个 compare(E e1,E e2)方法，如果e1大 返回1；相等返回0；否则返回-1。

    /**
     * 添加方法
     * @param element
     */
    public void add(E element){
        //1.空值检查
        elementNotNullCheck(element);
        if(root == null){
            root = new Node(element,null);
            size++;
            return;
        }
        //2.先找到父节点
        Node<E> node = root; //刚开始时node和parent都是root
        Node<E> parent = root;
        int com = 0; //这个com其实就是方向，我们可以根据这个值判断，加入的节点是在左边还是右边
        while (node!= null){
            com = compare(element,node.element);
            //这一行是最难理解的，还是用上面的例子假设此时的node = 11,那么下一次迭代的时候不就退出了循环，所以在退出循环之前把parent记录下来即可
            parent = node; 
            if(com>0){ //添加到右边
                node = node.right;
            }else if(com<0){
                node = node.left;
            }else{//如果相等直接覆盖
                node.element = element;
                return;
            }
        }
        //已经找到了parent,创建新节点
        Node<E> newNode = new Node<>(element,parent);
        if(com>0){
            parent.right = newNode;
        }else{
            parent.left = newNode;
        }
        size++;
    }

3.删除节点remove()

我们知道一颗二叉树的度只能为0、1、2，所以我们删除节点也需要分三种情况进行讨论：

一、删除度为2的节点

假设我们要删除节点7，我们的做法就是先找到7的前驱节点，就是节点5，然后用节点5的值覆盖7，最后删除节点5。

那么现在问题就变成了：一个节点的前驱节点怎么找呢？

 

如何来找一个节点的前驱节点(precursorNode)？

1.假设改节点的左子树不为空，precursorNode = node.left.right.right.... ,直到没有右子节点。例如：7的前驱节点就是5

2.假设左子树是空，并且没有父节点。这种情况很好理解，就是假设7的左子树是空的，那么毫无疑问7就没有前驱节点，返回null就行了

3.假设左子树为空，但父节点不为空。此时precursorNode = node.parent.parent ,直到找到节点是父节点的右子节。

private Node<E> precursor(Node<E> node){
    if(node == null) return;
    
    Node<E> p = node.left;
    if(p!=null){
       
        while(p.right!=null){//一直往右找
            p = p.right;
        }
        return p;
    }
    //假设节点的父节点不为空，且 节点是左子节点，那么就一直循环
    while(node.parent!=null || node=node.parent.left){
         node = node.parent;
    }
    //来到这里说明 node.parent == null 或者 node=node.parent.right
    return node.parent;
    
    
}

二、删除度为1的节点

假设我们要删除节点2，节点11，我们应该怎么做？

我们的做法是找到该节点的child，让child的值覆盖节点的值然后删除child。

这里有两种情况：删除的节点的父节点可能为空、可能不为空

 

三、删除度为0的节点

这种比较简单，直接删掉就可以了。

分析了上面的几种情况，下面就开始编码了。

public void remove(E element){
    if(element == null) return;
    remove(node(eleemnt));
}


private void remove(Node<E> node){
        if(node == null) return;
        //1.先删除度为2的节点
        if(node.hasTwoChild()){
            //先找到它的前驱节点
            Node<E> precursor = precursor(node);
            node.element = precursor.element;
            //删除前驱节点
            node = precursor;
        }
        //来到这里说明node的度只能是1或者是0
        if(node.hasNoChild()){ //度为0
            if(node.parent == null){
                root = null;
            }else{
                if(node == node.parent.left){
                    node.parent.left = null;
                }else{
                    node.parent.right = null;
                }
            }
        }
        if(node.hasOneChild()){
            if(node.parent == null){
                if(node == node.parent.left){ //左节点
                    root = node.left;
                }else{
                    root = node.right;
                }
            }else{
                Node<E> child = node.left!=null?node.left:node.right;
                child.parent = node.parent;
                if(node == node.parent.left){ //左子节点
                    node.parent.left = child;
                }else{
                    node.parent.right= child;
                }
            }
        }
    }



/**
 * 根据element找到节点，因为我内部的设计肯定是删除节点
 *  所以需要根据element先找到节点，找节点的方法也是从root开始迭代
 */
private Node<E> node(E element){
    Node<E> node = root;
    while(node!=null){
        int com = compare(element,node.element);
        if(com ==0) return node;
        if(com>0){
            //往右子树找
            node = node.right;            
        }else{
            node = node.left;
        }
    }
    return null;
}

其他方法：

/**
  *  是否包含
  */ 
public boolean contains(E element) {
    return node(element)!=null;
 }
 
 /**
  * 树的大小
  */
 public int size(){
     return size;
 }
 
 /**
  * 是否为空
  */
 public boolean isEmpty() {
     return size == 0;
 }
 
 /**
   * 清空树
   */
 public void clear() {
     root = null;
     size = 0;
 }

最后给出完整的代码：

里面还包含了四种遍历方式，前序、中序、后序、层级，每种遍历都有两种方法：迭代和递归。

这里比较亮眼的设计在比较器，我们可以想一下，用户它可以自定义规则，所以我们在构造函数那里可以传递一个比较器进来，具体的比较逻辑是用户来定的。当然用户也可以不传，那么你的对象就必须实现Comparable接口，重写里面的compareTo()方法。想想为什么我们一定要用户传进来的对象是可比较的呢？这不是废话吗，如果对象都不能比较，我怎么搜索，我怎么删除，我怎么添加。

 /**
     * 如果e1>e2 返回1,e1=e2 返回0 ,e1<e2 返回-1
     * @param e1
     * @param e2
     * @return
     */
    private int compare(E e1,E e2){
        if(compartor!=null){
            return compartor.compare(e1,e2);
        }
        return ((Comparable)e1).compareTo(e2);
    }

完整代码：

package 二叉搜索树;



import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Stack;

public class BinarySearchTree<E>{

    private int size; //树的大小
    private Node<E> root; //根节点
    private Comparator<E> compartor;
    private static class Node<E>{
        E element;
        Node<E> left;
        Node<E> right;
        Node<E> parent;

        public Node(E element,Node<E> parent){
            this.element = element;
            this.parent = parent;
        }

        public boolean hasTwoChild() {
            return left != null && right != null;
        }

        public boolean hasNoChild() {
            return left == null && right == null;
        }

        public boolean hasOneChild() {
            if((left!=null && right == null) || (right!=null && left == null)){
                return true;
            }else {
                return false;
            }
        }
    }

    /**
     * 添加方法
     * @param element
     */
    public void add(E element){
        //1.空值检查
        elementNotNullCheck(element);
        if(root == null){
            root = new Node(element,null);
            size++;
            return;
        }
        //2.先找到父节点
        Node<E> node = root;
        Node<E> parent = root;
        int com = 0;
        while (node!= null){
            com = compare(element,node.element);
            parent = node;
            if(com>0){ //添加到右边
                node = node.right;
            }else if(com<0){
                node = node.left;
            }else{
                node.element = element;
                return;
            }
        }
        //已经找到了parent,创建新节点
        Node<E> newNode = new Node<>(element,parent);
        if(com>0){
            parent.right = newNode;
        }else{
            parent.left = newNode;
        }
        size++;
    }

    /**
     * 删除方法
     * @param element
     */
    public void remove(E element) {
        if(element == null) return;
        remove(node(element));
    }

    //大神的写法
    private void remove(Node<E> node){
        if(node == null) return;
        //1.先删除度为2的节点
        if(node.hasTwoChild()){
            //先找到前驱节点，然后用前驱节点的值覆盖，删除前驱节点
            Node<E> precursor = precursor(node);
            node.element = precursor.element;
            node = precursor;
        }
        //删除node,此时node的度要么是1，要么是0
        //如果node是左子节点 child.parent = node.parent,node.parent.left = child
        Node<E> replaceNode = node.left!=null ? node.left : node.right;
        if(replaceNode!=null){//度为1的节点
            replaceNode.parent = node.parent;
            if(node.parent == null){ //node节点是根节点
                root = replaceNode;
            }
            if(node == node.parent.left){
                node.parent.left = node.left;
            }
            if(node == node.parent.right){
                node.parent.right = node.right;
            }
        }else if(node.parent == null){//度为0的节点
            root = null;
        }else{
            if(node == node.parent.left){
                node.parent.left = null;
            }else{
                node.parent.right = null;
            }
        }
        size--;
    }

    //我的写法
   /* private void remove(Node<E> node){
        if(node == null) return;
        //1.先删除度为2的节点
        if(node.hasTwoChild()){
            //先找到它的前驱节点
            Node<E> precursor = precursor(node);
            node.element = precursor.element;
            //删除前驱节点
            node = precursor;
        }
        //来到这里说明node的度只能是1或者是0
        if(node.hasNoChild()){ //度为0
            if(node.parent == null){
                root = null;
            }else{
                if(node == node.parent.left){
                    node.parent.left = null;
                }else{
                    node.parent.right = null;
                }
            }
        }
        if(node.hasOneChild()){
            if(node.parent == null){
                if(node == node.parent.left){ //左节点
                    root = node.left;
                }else{
                    root = node.right;
                }
            }else{
                Node<E> child = node.left!=null?node.left:node.right;
                child.parent = node.parent;
                if(node == node.parent.left){ //左子节点
                    node.parent.left = child;
                }else{
                    node.parent.right= child;
                }
            }
        }
    }*/

    private  Node<E> node(E element){
        if(root == null) return null;
        Node<E> node = root;
        while(node!=null){
            int compare = compare(element, node.element);
            if(compare == 0) return  node;
            if(compare>0){
                node = node.right;
            }else{
                node = node.left;
            }
        }
        return  null;
    }
    /**
     * 获取一个节点的前驱节点
     * @param node
     * @return
     */
    private Node<E> precursor(Node<E> node) {
        if(node == null) return null;
        Node<E> p = node.left;
        if(p!=null){//前驱节点
            while(p.right!=null){
                p = p.right;
            }
            return p;
        }
        while(node.parent!=null && node == node.parent.left){
            node = node.parent;
        }
        //node.parent = null
        //node = node.parent.right
        return node.parent;
    }



    public BinarySearchTree(){
        this(null);
    }

    public BinarySearchTree(Comparator<E> compartor){
        this.compartor = compartor;
    }

    public int size(){
        return size;
    }
    public boolean isEmpty() {
        return size == 0;
    }
    public void clear() {
        root = null;
        size = 0;
    }


    /**
     * 如果e1>e2 返回1,e1=e2 返回0 ,e1<e2 返回-1
     * @param e1
     * @param e2
     * @return
     */
    private int compare(E e1,E e2){
        if(compartor!=null){
            return compartor.compare(e1,e2);
        }
        return ((Comparable)e1).compareTo(e2);
    }

    private void elementNotNullCheck(E element) {
        if (element == null) {
            throw new IllegalArgumentException("element must not be null");
        }
    }


    public boolean contains(E element) {
        return node(element)!=null;
    }

    //前序遍历 - 递归
    /*public  void beforeOrder(Visitor<E> visitor){
        if(visitor == null) return;
        beforeOrder(root,visitor);
    }

    private void beforeOrder(Node<E> root,Visitor<E> visitor){
        if(root == null || visitor.stop) return;
        visitor.stop = visitor.visit(root.element);
        beforeOrder(root.left,visitor);
        beforeOrder(root.right,visitor);
    }*/

    //前序遍历 - 非递归
    //使用栈：1.root入栈
    //循环操作：root出栈 root.left入栈  root.right入栈
    public  void beforeOrder(Visitor<E> visitor){
        if(visitor == null || root == null) return;
        Stack<Node<E>> stack = new Stack<>();
        stack.push(root);
        while(!stack.isEmpty()){
            Node<E> node = stack.pop();
            if(visitor.stop) return;
            visitor.stop = visitor.visit(node.element);
            if(node.right!=null){
                stack.push(node.right);
            }
            if(node.left!=null){
                stack.push(node.left);
            }
        }


    }

    //中序遍历 - 递归
   /* public  void innerOrder(Visitor<E> visitor){
        if(visitor == null) return;
        innerOrder(root,visitor);
    }

    private void innerOrder(Node<E> root,Visitor<E> visitor){
        if(root == null || visitor.stop) return;
        innerOrder(root.left,visitor);
        if(visitor.stop) return;
        visitor.stop = visitor.visit(root.element);
        innerOrder(root.right,visitor);
    }*/

    //中序遍历 非递归方式  左子树 - 根节点 - 右子树
    public  void innerOrder(Visitor<E> visitor){
        if(visitor == null || root==null) return;
        Stack<Node<E>> stack = new Stack<>();
        //先将左子树入栈
        pushLeft(root,stack);
        while(!stack.isEmpty()){
            Node<E> node = stack.pop();
            if(visitor.stop) return;
            visitor.stop = visitor.visit(node.element);
            if(node.right!=null){
                pushLeft(node.right,stack);
            }
        }

    }

    private void pushLeft(Node<E> root, Stack<Node<E>> stack) {
        while(root!=null){
            stack.push(root);
            root = root.left;
        }
    }

    //后序遍历
   /* public  void afterOrder(Visitor<E> visitor){
        if(visitor == null) return;
        afterOrder(root,visitor);
    }
    private void afterOrder(Node<E> root,Visitor<E> visitor){
        if(root == null || visitor.stop) return;
        afterOrder(root.left,visitor);
        afterOrder(root.right,visitor);
        if(visitor.stop) return;
        visitor.stop = visitor.visit(root.element);
    }*/
    //左 - 右 - 根
    public  void afterOrder(Visitor<E> visitor){
        if(visitor == null || root ==null){
            return;
        }
        List<Node<E>> list = new LinkedList<>();
        Stack<Node<E>> stack = new Stack<>();
        stack.push(root);
        while(!stack.isEmpty()){
            Node<E> pop = stack.pop();
            list.add(0,pop);
            if(pop.left!=null){
                stack.push(pop.left);
            }
            if(pop.right!=null){
                stack.push(pop.right);
            }
        }
        if(list!=null && list.size()>0){
            for (Node<E> node : list) {
                if(visitor.stop){
                    return;
                }
                visitor.stop = visitor.visit(node.element);
            }
        }
    }

    //层序遍历
    public void layerOrder(Visitor<E> visitor){
        //创建一个队列
        Queue<Node<E>> queue = new LinkedList<>();
        queue.offer(root);

        while(!queue.isEmpty()){
            Node<E> node = queue.poll();
            boolean visit = visitor.visit(node.element);
            if(visit) return;
            if(node.left!=null){
                queue.add(node.left);
            }
            if(node.right!=null){
                queue.add(node.right);
            }
        }
    }


}

package 二叉搜索树;

public abstract class Visitor<E> {

    //stop为true的时候表示终止
    boolean stop;

    public abstract boolean visit(E element);

}