树结构之二分搜索树

二叉树

里面有有一个节点，和链表不同的是有两个节点引用

 class Node{
        int e;
        Node left;
        Node right;
    }

二叉树和链表都具有天然的递归结构，但是由于链表具有线性，使用循环也能处理，但是二叉树是非线性，使用递归进行处理会更加方便

二分搜索树

• 二分搜索树首先是一个二叉树。
• 二分搜索树的节点值大于其左子树的值，小于其右子树的值
• 每一个子树也是二分搜索树
• 存储的元素必须具有可比较性

这样的话二分搜索树在查询的时候更加快速

二分搜索树的定义

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

    private Node root;
    private int size;

    public BinyTree() {
        root = null;
        size = 0;
    }

    class Node{
        E e;
        Node left;
        Node right;

        public Node(E e) {
            this.e = e;
            left = null;
            right = null;
        }
    }
}

添加新的元素

public void add(E e) {
        if (root == null) {
            root = new Node(e);
            size++;
        } else {

            insert(root, e);
        }
    }

    private void insert(Node node, E e) {
        //等于的时候默认不添加,前两个是递归的终止条件
        if (node.e.compareTo(e) < 0 && node.right == null) {
            node.left = new Node(e);
            size++;
        } else if (node.e.compareTo(e) > 0 && node.left == null) {
            node.left = new Node(e);
            size++;
        } else if (node.e.compareTo(e) < 0 && node.right != null) {
            insert(node.left, e);
        } else if (node.e.compareTo(e) < 0 && node.left != null) {
            insert(node.right, e);
        }
    }

简洁的改善版

 public void add(E e) {
        insert(root, e);
    }
    //返回插入新节点后二叉树的根
    private Node insert(Node node, E e) {
        //终止条件
        if (node ==null){
            size++;
           return new Node(e);
        }
        if (node.e.compareTo(e)>0){
            node.left = insert(node.left,e);
        }else if (node.e.compareTo(e)<0){
            node.right = insert(node.right,e);
        }
        return node;
    }

二叉树的查询

 public boolean contain(E e){
     return searchEle(root,e);
  }

  private boolean searchEle(Node node, E e) {

      if (node==null) return false;
      if (node.e.equals(e)) return true;
      if (node.e.compareTo(e)>0){
          return searchEle(node.left,e);
      }else {
          return searchEle(node.right,e);
      }
  }

二分搜索树的遍历

 //谦虚遍历
   public void preOrder(){
       transe(root);
   }

   private void transe(Node root) {
       if (root==null) return;
       System.out.println(root.e);
       transe(root.left);
       transe(root.right); 
   }

中序和后续只是输出的位置不一样，其他都是相同的
中序遍历就是二分搜索树排序后的结果！！！，二分搜索树也可以被称为排序树。

二分搜索树的非递归实现

相对于递归，非递归代码较为复杂
利用栈，具体可以百度查下，感觉太复杂了。
前中后序都是深度优先遍历。

二分搜索树的层次遍历

广度优先遍历，通常使用非递归，还要借助队列。

 //层次遍历
    public void levelOrder(){
        Queue<Node> queue = new ArrayDeque<>();
        queue.add(root);

        while (!queue.isEmpty()){
        //每次弹出一个节点，然后在加入弹出节点的左右节点
            Node node = queue.poll();
            if(node.left!=null){
                queue.add(node.left);
            }
            if (node.right!=null){
                queue.add(node.right);
            }
            System.out.println(node.e);
        }
    }

广度优先遍历的应用

• 更快找到问题的解。
• 常用于查找最短路径

二分搜索树的最小值和最大值的问题

最小值就是最左的节点，最大值就是最右的节点

 public E getMin(){
        return getMin(root);
    }

    private E getMin(Node node) {
        if (node.left==null) return node.e;
        return getMin(node.left);
    }

删除最小值和最大值

 //删除最小节点
    public E deleteMin() {
        E min = getMin();
        root = removeMin(root);
        return min;
    }

    //返回删除最小节点的根
    private Node removeMin(Node node) {
        if (node.left == null) {
            size--;
            return node.right;
        }

        node.left = removeMin(node.left);
        return node;
    }

删除任意值

// 删除掉以node为根的二分搜索树中值为e的节点, 递归算法
    // 返回删除节点后新的二分搜索树的根
    private Node remove(Node node, E e){

        if( node == null )
            return null;

        if( e.compareTo(node.e) < 0 ){
            node.left = remove(node.left , e);
            return node;
        }
        else if(e.compareTo(node.e) > 0 ){
            node.right = remove(node.right, e);
            return node;
        }
        else{   // e.compareTo(node.e) == 0

            // 待删除节点左子树为空的情况
            if(node.left == null){
                Node rightNode = node.right;
                node.right = null;
                size --;
                return rightNode;
            }

            // 待删除节点右子树为空的情况
            if(node.right == null){
                Node leftNode = node.left;
                node.left = null;
                size --;
                return leftNode;
            }

            // 待删除节点左右子树均不为空的情况

            // 找到比待删除节点大的最小节点, 即待删除节点右子树的最小节点
            // 用这个节点顶替待删除节点的位置,此时优点复杂
            //右节点的最小节点返回，此时就是根节点
            Node successor = minimum(node.right);
            //此时会返回删除最小值的右子树根节点
            successor.right = removeMin(node.rigt);
            
            successor.left = node.left;
			//让节点释放
            node.left = node.right = null;

            return successor;
        }
    }

二分搜索树的优缺点

查找的速度只与树的高度有关
优点

• 可以在查询的时候将复杂度降为logn
• 在增加，删除，修改的时候也是logn，极大的提高了查询的速度
  缺点
• 当数据有序的时候，此时建立的二叉树就会退化称为了一个链表，这时候就会变成了n的时间复杂度，
  用平衡二叉树可以解决这个问题