6-5、6、7... 二分搜索树的查询操作、前序遍历

• 二分搜索树的contains方法实现逻辑如下：

// 看二分搜索树中是否包含元素e
    public boolean contains(E e){
        return contains(root, e);
    }

    // 看以node为根的二分搜索树中是否包含元素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 // e.compareTo(node.e) > 0
            return contains(node.right, e);
    }

• 6-6 二分搜索树的前序遍历

      二分搜索树的遍历操作，遍历操作就是把所有节点都访问一遍

     前序遍历：先访问节点，在访问左右子树。

 递归代码：先写递归终止条件，再写递归组成逻辑

// 二分搜索树的前序遍历
    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);
    }

6-7 二分搜索树的中序遍历和后序遍历

• 中序遍历的业务逻辑如下：

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

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

    if (node == null) {
        return;
    }

    inOrder(node.left);
    System.out.print(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.print(node.e);

}

 6-9 二分搜索树前序遍历的非递归实现

• 前序遍历是最自然的遍历方式，也是最常用的遍历方式；中序遍历的结果是按从小到大的顺序的排列的；后序遍历可以用于为二分搜索树释放内存。
• 利用"栈"实现二分搜索树的非递归前序遍历

//结合视频、PDF看这段代码

 // 二分搜索树的非递归前序遍历
    public void preOrderNR(){

        Stack<Node> stack = new Stack<>();//stack使用泛型型，里面装的是Node类对象
        stack.push(root);   //入栈，向根节点中添加root
        while(!stack.isEmpty()){
            Node cur = stack.pop();  //把栈顶元素来出来，放进cur中，cur节点就是我们当前要访问的节点
            System.out.println(cur.e);

            if(cur.right != null)  //前序遍历顺序：根→left节点→right节点，由于栈是后入先出的，所以right节点先入栈，left节点后入栈
                stack.push(cur.right);
            if(cur.left != null)
                stack.push(cur.left);
        }
    }

• 6-10 二分搜索树的层序遍历
• 二分搜索树的前序、中序、后序遍历本质上都是深度优先的遍历
• 二分搜索树的"层序遍历"属于"广度优先"算法。
• 利用"队列"实现二分搜索树的"层序遍历"

  // 二分搜索树的层序遍历
    public void levelOrder(){

        Queue<Node> q = new LinkedList<>();//对于层序遍历来说，需要使用一个队列，这里使用Java自带的Queue（导入包Queue），不过Java的Queue本质是一个接口，真正实现它是时候需要实现一个具体的底层数据结构，选择使用链表的方式来实现（导入包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");

        Node minNode = minimum(root);  //maximum(root)：以root为根的二分搜索树的最小值
        return minNode.e;//返回以root为根的二分搜索树的最小元素值
    }

    // 返回以node为根的二分搜索树的最小值所在的节点
    private Node minimum(Node node){
        if( node.left == null )//向左走走不动了
            return node;

        return minimum(node.left);//如果不满足if条件，执行这一步
    }

    // 寻找二分搜索树的最大元素
    public E maximum(){
        if(size == 0)
            throw new IllegalArgumentException("BST is empty");

        return maximum(root).e;
    }

    // 返回以node为根的二分搜索树的最大值所在的节点
    private Node maximum(Node node){
        if( node.right == null )
            return node;

        return maximum(node.right);
    }

•  删除二分搜索树的最大值、最小值

变成变成

  // 从二分搜索树中删除最小值所在节点, 返回最小值
    public E removeMin(){
        E ret = minimum();
        root = removeMin(root);//从root开始尝试删除最小值所在节点
        return ret;
    }

    // 删除掉以node为根的二分搜索树中的最小节点
    // 返回删除节点后新的二分搜索树的根
    private Node removeMin(Node node){

        if(node.left == null){  //不能向左走了，当前节点node就是最小值所在节点，要删到这个节点
            Node rightNode = node.right;//要删的这个当前节点可能是有右子树的，右子树不能丢。 创建rightNode，保存当前节点的右子树
            node.right = null;//对将要删除的节点让它的right等于空，也就是将要删除的node节点从二叉树中脱离。
            size --;//删除掉了一个元素，整体size要--
            return rightNode;//返回rightNode，起到删除最小值所在节点的作用。把node删除，当前二分搜索树的根就是node的右孩子：node.right（ rightNode ）
        }

        node.left = removeMin(node.left);//如果没有递归到底，不满足if条件，说明node还有左孩子，要做的是：去删除掉到node左子树对应的最小值
        return node;//删除掉到node左子树对应的最小值后，对于当前以node为根的二分搜索树，它的根节点依然是node，将它返回
    }

    // 从二分搜索树中删除最大值所在节点
    public E removeMax(){
        E ret = maximum();
        root = removeMax(root);
        return ret;
    }

    // 删除掉以node为根的二分搜索树中的最大节点
    // 返回删除节点后新的二分搜索树的根
    private Node removeMax(Node node){

        if(node.right == null){
            Node leftNode = node.left;
            node.left = null;
            size --;
            return leftNode;
        }

        node.right = removeMax(node.right);
        return node;
    }

看下面这个图便于理解

 6-12 删除二分搜索树的任意元素

 

即

 

具体实现代码：

• 删除二分搜索树中指定元素所对应的节点

  // 从二分搜索树中删除元素为e的节点
    public void remove(E e){
        root = remove(root, e);
    }

    // 删除掉以node为根的二分搜索树中值为e的节点, 递归算法
    // 返回删除节点后新的二分搜索树的根
    Node remove(Node node, E e){

        if( node == null )
            return null;

        if( e.compareTo(node.e) < 0 ){
            node.left = remove(node.left , e);  //到node的左子树中尝试删除e
            return node;
        }
        else if(e.compareTo(node.e) > 0 ){
            node.right = remove(node.right, e);
            return node;
        }
        else{   // e.compareTo(node.e) == 0代删除的e和当前节点的e相等

            // 待删除节点左子树为空的情况
            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);
            size ++;

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

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

            return successor;
        }