数据结构--二分搜索树（BST）

1.二分搜索树的简单介绍

一般来讲，二叉树的存储数据的基本结构是封装一个Node节点，保存左右两个孩子的node变量，以及一个泛型数据，二分搜索树需要泛型类型实现Comparable接口（必须保证左子树的数据比右子树大）

/**
 * Created by upupgogogo on 2018/5/30.上午11:38
 */

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

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

    private int size;   //二叉树的节点个数
    private Node root; //当前二叉树的根节点

    public int getSize(){
        return this.size;
    }

    public boolean isEmpty(){
        return this.size == 0;
    }}

2.分析添加节点的方法

 //添加一个节点
    public void add(E e){
        root = add(root,e);
    }

    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);

        if (e.compareTo(node.e) > 0)
            node.right = add(node.right,e);

        return node;
    }

这里通过递归算法封装了一个add方法，两个参数分别表示需要添加节点的二叉树的根节点，以及需要保存的数据，返回添加之后的二叉树的根节点

首先判断该节点是否为空，如果为空则返回一个new Node(e)，如果不为空，判断数据的大小，比根节点保存数据小的话，把该数据添加到左子树里(宏观的角度是整个左子树)，如果大于根节点保存的数据，把该数据添加到右子树里(宏观的角度是整个右子树)，数据相等不考虑添加，最后返回node

3.看二分搜索树是否包含元素e

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

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

这里通过递归算法封装了一个contains方法，两个参数分别表示当前是否包含元素e的二叉树的根节点，和元素e,返回boolean类型数据

首先判断当前二叉树的根节点是否为空，如果为空表示当前二叉树为空，则返回false,然后判断该根节点所保存的元素和参数e是否相等，相等则直接返回true,接着比较根节点所保存元素和和元素e大小关系，比元素e大，则返回左二叉树是否包含元素e，反之，则返回右二叉树是否包含元素e

4.二叉树的前中后序遍历

  // 二分搜索树的前序遍历
    public void preOrder(){
        preOrder(root);
    }

    // 前序遍历以node为根的二分搜索树, 递归算法
    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(){
        inOrder(root);
    }

    // 中序遍历以node为根的二分搜索树, 递归算法
    private void inOrder(Node node){

        if(node == null)
            return;

        inOrder(node.left);
        System.out.println(node.e);
        inOrder(node.right);
    }

    // 二分搜索树的后序遍历
    public void postOrder(){
        postOrder(root);
    }

    // 后序遍历以node为根的二分搜索树, 递归算法
    private void postOrder(Node node){

        if(node == null)
            return;

        postOrder(node.left);
        postOrder(node.right);
        System.out.println(node.e);
    }

5.删除一个节点

public void remove(E e){
        root = remove(root, e);
    }

    private Node remove(Node node, E e) {
        if (node == null)
            return null;
        if (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 = new Node(minimum(node.right).e);
            size ++;

            successor.right = removeMin(node.right);
            successor.left = node.left;

            node.left = node.right = null;
            size --;

            return successor;

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

这里通过递归算法封装了一个remove方法，两个参数分别表示当前需要删除节点的二叉树的根节点，和元素e,返回删除后二叉树的根节点

首先判断根节点是否为空，如果为空则直接返回null，然后比较元素e和根节点所保存元素的大小关系，如果想等，先考虑左子树为空的情况，则返回右二叉树的根节点，并且让根节点所指向右孩子的变量为空，脱离整个二叉树，右子树为空也是一样

当两个子树都不为空时，new 一个Node对象，保存右子树最小的元素e，并删除右子树该节点，让这个新建的node节点右孩子指向被删除根节点的右孩子，左孩子也是，并让根节点的左右两个孩子变量都指向null，脱离整个二叉树

然后比较该元素和根节点所保存元素的大小，如果大于该元素，则删除左子树所保存该元素的节点，并返回删除后的根节点

反之亦然