二分搜索树

原创作品，转载请标明来源。

一、 什么是二叉树？

editByWpp.png

二叉树每个节点最多有两个孩子
二叉树每个节点最多有一个父亲

性质

• 二叉树具有天然的递归结构
• 每个节点的左子树也是二叉树
• 每个节点的柚子树也是二叉树
• 二叉树不一定是“满”的

二、什么是二分搜索树？

editByWpp.png

• 存储的元素必须有可比较性（比如节点存储的是学生，我们可以以年龄比较或学号比较等）

注意：本文的二分搜索树不包含重复元素
如果想包含重复元素的话，只需要定义：左子树小于等于节点；或者柚子树大于节点即可

二分搜索树的增删茶

• 新增节点

二分搜索树添加元素的非递归写法，和链表很像
本文在二分搜索树方面的实现，关注递归实现

public class BST<E extends Comparable<E>> {

private class Node{
   public   E e;
   public Noe left, right;
   public Node(E e) {
      this.e = e;
      left = null;
      right = null;
}
// 向二分搜索树中添加新的元素e -- 优化前
    public void add1(E e) {
        if (root == null) {
            root = new Node(e);
            size++;
        } else {
            add(root,e);
        }
    }

    // 向以node为根的二分搜索树中插入元素E,递归算法---优化前的插入元素部分
    private void add1(Node node, E e) {
        // 递归终止条件
       if (e.equals(node.e)) {
            return;
       } else if (e.compareTo(node.e) < 0 && node.left == null) {
           node.left = new Node(e);
           size++;
           return;
       } else if (e.compareTo(node.e) > 0 && node.right == null) {
           node.right = new Node(e);
           size++;
           return;
       }
       if (e.compareTo(node.e) < 0 && node.left != null) {
           add(node.left,e);
       } else{ // (e.compareTo(node.e) > 0 && node.right != null)
           add(node.right,e);
       }
    }
    // 向二分搜索树中添加新的元素e -- 优化后
    public void add(E e) {
       root = add(root,e);
    }
    // 向以node为根的二分搜索树中插入元素E,递归算法---优化后的插入元素部分
    // null 也是一个二叉树来考虑
    private Node add(Node node, E e) {
        // 递归终止条件
        if (node == null) {
            size++;
            return new Node(e);
        }
       if (e.compareTo(node.e) < 0) {
          node.left = add(node.left,e);
       } else if (e.compareTo(node.e) > 0) {
           node.right = add(node.right,e);
       }
       return node;
    }
}

• 二分搜索树的查询操作

// 递归算法
    private boolean contains(Node node, E e) {
        if (node == null)
            return false;
        if (e.compareTo(node.e) == 0)
            return true;
        else if (e.compareTo(node.e) < 0)
            return contains(node.left,e);
        else //e.compareTo(node.e) > 0
            return contains(node.right,e);
    }

• 遍历(前序、中序、后序-也叫深度优先遍历)

  
  editByWpp.png
  editByWpp.png

editByWpp.png

前序遍历
 public void preOrder() {
        System.out.println();
        preOrder(root);
    }
   private void preOrder(Node node) {
        if (node == null)
            return;
        System.out.println(node.e);
        preOrder(node.left);
        preOrder(node.right);
    }

    // 非递归的前序遍历
    public void preOrderNR (){

        Stack<Node> stack = new Stack();
        stack.push(root);
        while (!stack.isEmpty()) {
            Node cur = stack.pop();
            System.out.println(cur.e);
            if (cur.right != null) stack.push(cur.right);
            if (cur.left != null)  stack.push(cur.left);
        }
    }
中序遍历
    /**
     * 中序遍历
      */
    public void inOrder(){
        System.out.println();
        inOrder(root);
    }

    private void inOrder(Node node) {
        if (node == null)
            return;
        inOrder(node.left);
        System.out.print(node.e+ "  ");
        inOrder(node.right);
    }
    /**
     * 后序遍历
     */
    public void postOrder() {
        System.out.println();
        postOrder(root);
    }

    private void postOrder(Node node) {
        if (node == null) return;
        postOrder(node.left);
        postOrder(node.right);
        System.out.print(node.e+"  ");
    }

• 层序遍历(广度优先遍历)--更快的找到问题的解（常用于算法设计中-最短路径）

  
  editByWpp.png

   public void levelOrder (){
        LinkedListQueue <Node> queue = new LinkedListQueue();
        queue.enqueue(root);
        while (!queue.isEmpty()) {
            Node cur = queue.dequeue();
            System.out.println(cur.e);
            if (cur.left != null)   queue.enqueue(cur.left);
            if (cur.right != null)  queue.enqueue(cur.right);

        }
    }

• 删除操作
  删除二分搜索树的某一个节点可能不是很好实现，我们可以先实现删除最小节点和最大节点。可以发现最小节点就是二分搜索树最左边的节点，最大节点是二分搜索书最右边的节点；代码如下

// 得到最小节点值
    public E miniMum(){
        if (size == 0)
            throw new IllegalArgumentException("BST is empty");
       return miniMum(root).e;
    }
    private Node miniMum(Node node) {
        if (node.left == null)
            return node;
        return miniMum(node.left);
    }
// 得到醉倒节点值
    public E maxMum(){
        if (size == 0)
            throw new IllegalArgumentException("BST is empty");
        return maxMum(root).e;
    }
    private Node maxMum(Node node) {
        if (node.right == null)
            return node;
        return maxMum(node.right);
    }
 public E removeMin(){
        E  ret = miniMum();
        root = removeMin(root);
        return ret;
    }
    // 删除掉以node为根的二分搜索树中的最小节点
    // 返回删除节点后新的二分搜索树的根
    private Node removeMin(Node node) {
        if (node.left == null) {
            Node rightNode = node.right;
            node.right = null;
            size--;
            return rightNode;
        }
        node.left = removeMin(node.left);
        return node;
    }
   public E removeMax(){
        E  ret = maxMum();
        root = removeMax(root);
        return ret;
    }
    // 删除掉以node为根的二分搜索树中的最大节点
    // 返回删除节点后新的二分搜索树的根
    private Node removeMax(Node node) {
        if (node.right == null) {
            Node leftNode = node.left;
            node.left = null;
            size--;
            return leftNode;
        }
        node.right = removeMax(node.right);
        return node;
    }

当我们试图删除某一个节点时，如果这个节点只有左节点，没有右节点，我们可以以删除最大节点的方式去处理（即使该节点未必是最大节点），如果只有右节点没有左节点时，我们同样可以将它以删除最小节点的方式去处理，问题是如果这个要删除的节点既有左节点又有右节点时，怎么处理呢？
我引入一句话，给出了方案

1962年，Hibgard提出- Hibgard Deletion
其实也很简单，就是找到待删除节点的后置最小节点替代待删节点；

比如下图中，d节点是待删节点，根据二分搜索树的性质，d节点的右子叶都比左子叶要打，那么我们只要找到右子叶的最小值替代当前待删节点就可以了。

editByWpp.png

另一种方案：也可以找到待删节点的前驱最大节点替代待删节点。如上图其实也可以用53所在的节点替换d节点；

写在后面

好了，现在二分搜索树的分析暂时可以告一段落了，