概念

二分搜索树是二叉树 二分搜索树的每个节点的值-> 大于其左子树的每个节点的值,小于其右子树的每个节点的值。因此二分搜索树不包含重复节点。 存储的元素具有可比较性。

创建一个二分搜索树类

public class BST<E extends Comparable<E>>  {
    private class Node{
        public E e;
        public Node left;
        public Node right;
        public Node(E e){
            this.e=e;
            this.left=null;
            this.right=null;
        }
    }

    private Node root;
    private int size;

    public BST(){
        this.root=null;
    }

    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){
        node=new Node(e);
        size++;
        return node;
    }else 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;
}

查询

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 //if(e.compareTo(node.e)>0){
  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 preOrder(){
    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 levelOrder(){
    Queue<Node> queue=new LinkedList<>();
    queue.add(root);
    while(!queue.isEmpty()){
        Node cur= queue.remove();
        System.out.println(cur.e);
        if(cur.left!=null)
            queue.add(cur.left);
        if(cur.right!=null)
            queue.add(cur.right);
    }
}