基础数据结构与算法实现（2）—二叉搜索树BST

import java.util.LinkedList;
import java.util.Queue;


public class BST <E extends Comparable<E>> {
        
        private class Node{
                public E e;
                public Node left,right;
                
                public Node(E e) {
                        this.e=e;
                        left = null;
                        right = null;
                }
        }
        
        private Node root;
        private int size;
        
        public BST() {
                root = null;
                size = 0;
        }
        
        public int size() {
                return size;
        }
        
        public boolean isEmpty() {
                return size==0;
        }
        
        //添加操作
        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);
                else if(e.compareTo(node.e)>0)
                        node.right  = add(node.right,e);
                
                return node;
                
        }
        
        
        //看BST中是否包含元素e
        public boolean contains(E e) {
                return contains(root,e);
        }
        
        
        //看以node为根的BST中是否包含元素e,递归算法
        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 {
                        return contains(node.right,e);
                }
                
        }
        
        
        //前序遍历 递归实现
        public void preOrder() {
                preOrder(root);
        }
        
        private void preOrder(Node node) {
                
                if(node == null)
                        return;
                
                System.out.println(node.e); //先访问节点
                preOrder(node.left);
                preOrder(node.right);
                
        }
        
        
        //中序遍历 按照从小到大的顺序(排序树)
        public void inOrder() {
                inOrder(root);
        }
        
        private void inOrder(Node node) {
                
                if(node == null) {
                        return;
                }
                
                inOrder(node.left);
                System.out.println(node.e); //先访问节点
                inOrder(node.right);
                
        }
        
        
        //后序遍历  
        //应用之一是为BST释放内存，先释放子节点
        public void postOrder() {
                postOrder(root);
        }
        
        private void postOrder(Node node) {
                
                if(node == null) {
                        return;
                }
                
                postOrder(node.left);
                postOrder(node.right);
                System.out.println(node.e); //最后访问节点
                
        }
        
        //层序遍历(广度优先遍历) 用队列来实现
        public void levelOrder() {
                Queue<Node>  q = new LinkedList<>();
                q.add(root);
                
                //让节点出队,同时让节点的子节点入队
                while(!q.isEmpty()) {
                        
                        Node cur = q.remove();
                        System.out.println(cur.e);
                        
                        if(cur.left != null)
                                q.add(cur.left);
                        if(cur.right != null)
                                q.add(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);
        }
        
        //删除BST中的最小元素
        public E removeMin() {
                E ret = minimum();
                root = removeMin(root);
                return ret;
        }
        
        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;
                
        }
        
        //从二分搜索树中删除元素e的节点
        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) {
                        node.left = remove(node.left,e);
                        return node;
                }else if(e.compareTo(node.e) > 0) {
                        node.right = remove(node.right, e);
                        return node;
                }else {
                        
                        //待删除节点左子树为空的情况
                        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.right);
                        successor.left = node.left;
                        
                        node.left = node.right = null;
                        
                        return successor;
                }
        }
        
        
        
        //以前序遍历实现打印BST
        @Override
        public String toString() {
                StringBuilder res = new StringBuilder();
                generateBSTString(root,0,res);
                return res.toString();
        }
        //生成以node为根节点,深度为depth的描述二叉树的字符串
        private void generateBSTString(Node node,int depth,StringBuilder res) {
                
                if(node == null) {
                        res.append(generateDepthString(depth)+"null\n");
                        return;
                }
                
                res.append(generateDepthString(depth)+node.e+"\n");
                generateBSTString(node.left, depth+1, res);
                generateBSTString(node.right, depth+1, res);
                
        }
        //代表深度的符号
        private String generateDepthString(int depth) {
                StringBuilder res = new StringBuilder();
                for(int i=0;i<depth;i++) {
                        res.append("-");
                }
                
                return res.toString();
        }
        
        
        
        
}