二叉排序树

树

记得在软件工程的课程中，老师讲过：程序=数据结构+算法。随着学习的深入，越来越能理解这句话的含义了，吧一段程序或者一个应用抽象来看，一层一层剥去，最后剩下来的无非是用来存储内存数据的数据结构和怎么怎么存储以及实现业务逻辑的算法。在计算机的世界里，存储的数据的数据结构有很多，它们被用到不同的场景来解决不同的问题，只有了解了各种数据结构的实现和用途，我们才能将其用到正确的场景，解决合适的问题，所以，了解数据结构和算法是必不可少的。

树是基于两种基本的数据结构而衍生出的更加高级的数据结构，它被用来解决搜索，存储等方面的应用。

二叉树

有一个根节点，每个节点有左子树和右子树，一颗二叉树可以只有一个节点，也可以没有节点(根节点为null)，如果一个节点没有左子树和右子树，则这个节点为叶子节点

二叉排序树

二叉排序树在二叉树的基础上做了一些要求，要求插入的元素必须是可比较的，并且左子树的值必须小于右子树。

代码实现

import java.util.*;

/**
 * @author tangxuejun
 * @version 2018/10/3 4:01 PM
 */
public class BST<E extends Comparable<E>> {
    public class Node {
        public E value;
        public Node left, right;

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

    private Node root;
    private int size;

    public BST() {
    }

    public int size() {
        return size;
    }

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


    /**
     * 非递归实现二叉搜索树的构建
     *
     * @param e
     */
    public void addWithNoRecursive2(E e) {
        if (root == null) {
            root = new Node(e);
        } else {
            Node node = root;
            while (true) {
                if (e.compareTo(node.value) > 0) {
                    if (node.right == null) {
                        node.right = new Node(e);
                        return;
                    } else {
                        node = node.right;
                    }
                } else {
                    if (node.left == null) {
                        node.left = new Node(e);
                        return;
                    } else {
                        node = node.left;
                    }
                }
            }
        }
        size++;
    }

    /**
     * 递归实现二叉搜索树的构建
     *
     * @param e
     */
    public void add(E e) {
        root = add(root, e);
    }

    private Node add(Node node, E e) {
        //递归终止条件
//        if (e.equals(node.value)) {
//            return;
//        } else if (e.compareTo(node.value) > 0 && node.right == null) {
//            node.right = new Node(e);
//            size++;
//            return;
//        } else if ((e.compareTo(node.value) < 0 && node.left == null)) {
//            node.left = new Node(e);
//            size++;
//            return;
//        }
        if (node == null) {
            size++;
            return new Node(e);
        }
        //递归调用
        if (e.compareTo(node.value) > 0) {
            node.right = add(node.right, e);
        } else if (e.compareTo(node.value) < 0) {
            node.left = add(node.left, e);
        }
        return node;
    }

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

    private boolean contains(Node root, E e) {
        //终止条件
        if (root == null) {
            return false;
        }

        if (e.compareTo(root.value) == 0) {
            return true;
        } else if (e.compareTo(root.value) > 0) {
            return contains(root.right, e);
        } else {
            return contains(root.left, e);
        }
    }

    /**
     * 前序遍历
     */
    public void preOrder() {
        preOrder(root);
    }

    private void preOrder(Node root) {
        //递归终止条件
        if (root == null) {
            return;
        }
        System.out.println(root.value);
        preOrder(root.left);
        preOrder(root.right);
    }

    /**
     * 中序遍历
     */
    public void inOrder() {
        inOrder(root);
    }

    private void inOrder(Node root) {
        //递归终止条件
        if (root == null) {
            return;
        }
        inOrder(root.left);
        System.out.println(root.value);
        inOrder(root.right);
    }

    /**
     * 后序遍历
     */
    public void postOrder() {
        postOrder(root);
    }

    private void postOrder(Node root) {
        //递归终止条件
        if (root == null) {
            return;
        }
        postOrder(root.left);
        postOrder(root.right);
        System.out.println(root.value);
    }

    /**
     * 先序遍历非递归(深度遍历)
     */
    public void preRecursive() {
        //1.新建一个栈
        Stack<Node> stack = new Stack<>();

        while (root != null) {
            //2.访问节点
            System.out.println(root.value);

            //3.压入栈
            if (root.right != null) {
                stack.push(root.right);
            }
            if (root.left != null) {
                stack.push(root.left);
            }
            if (stack.empty()) {
                return;
            }
            root = stack.pop();
        }
    }

    /**
     * 广度遍历
     */
    public void widthTraversing() {
        //新建队列
        Queue<Node> list = new LinkedList<>();

        list.add(root);

        while (!list.isEmpty()) {
            Node remove = list.remove();
            System.out.println(remove.value);
            if (remove.left != null) {
                list.add(remove.left);
            }
            if (remove.right != null) {
                list.add(remove.right);
            }
        }
    }

    public E getMin() {
        Node node = root;
        while (node.left != null) {
            node = node.left;
        }
        return node.value;
    }

    public E minnum() {
        return minnum(root).value;
    }

    private Node minnum(Node node) {
        if (node.left == null) {
            return node;
        }
        return minnum(node.left);
    }

    public E getMax() {
        while (root.right != null) {
            root = root.right;
        }
        return root.value;
    }

    /**
     * 删除二叉搜索树中最小的元素
     */
    public Node delMini(Node node) {
        Node parent = node;
        while (parent.left.left != null) {
            parent = parent.left;
        }
        if (parent.left.right == null) {
            parent.left = null;
        } else {
            parent.left = parent.left.right;
        }
        return node;
    }

    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.value) < 0) {
           return  node.left = remove(node.left,e);
        } else if (e.compareTo(node.value) > 0) {
           return node.right = remove(node.right, e);
        }else{
            //删除元素
            //左子树为空
            if (node.left == null) {
                Node right = node.right;
                node.right = null;
                return right;
            }
            //右子树为空
            if (node.right == null) {
                Node left = node.left;
                node.left = null;
                return left;
            }

            //左右子树都不为空
            Node successor = minnum(node.right);
            successor.right = delMini(node.right);
            node.left = node.right = null;
            return successor;
        }
    }
}