玩转数据结构之二分搜索树

说二分搜索树之前，必须先明确二叉树的概念，二叉树也是一种动态数据结构

树结构同样有天然的递归性，采用递归方法能比较简单的实现这种数据结构

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;
    }
    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;
    }
    //二分搜索树是否包含元素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;
        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);
    }

后序遍历：遍历顺序为 左子树——>右子树——>根节点

    //后序遍历
    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);
        }
    }