二叉查找樹的遞歸實現及遞歸分析

整體思路：二叉查找樹是一棵樹，對於樹，需要把節點表示出來。由於節點僅僅在樹的內部使用，故采用內部類的形式實現。

樹作為一種ADT，需要屬性及在其上進行的操作。由於大部分樹的操作都是從根節點開始的，因此需要一個根節點屬性，並可根據自己的需求來確定需要實現哪些操作。

對於二叉查找樹，它不是一般的二叉樹，它具有特點：任一節點的左子樹上的節點都比它小，右子樹上的節點都比它大。因此，二叉查找樹的方法實現需要滿足這個特點。

 

一，樹由結點組成

結點的定義如下：

    private static class BinaryNode<T>{
        T element;
        BinaryNode left;
        BinaryNode right;
        
        public BinaryNode(T element) {
            this(element, null, null);
        }
        
        public BinaryNode(T element, BinaryNode<T>left, BinaryNode<T>right) {
            this.element = element;
            this.left = left;
            this.right = right;
        }
    }

 

二，二叉查找樹 類

對於樹，需要有根結點。BinaryNode<T>以靜態內部類方式聲明在BinarySearchTree<T>中。靜態內部類的功能就是：靜態內部類的對象的創建不需要依賴其外部類的對象。

BinarySearchTree采用默認構造方法創建對象，然后調用 insert 方法向樹中添加節點。

public class BinarySearchTree<T extends Comparable<? super T>> {
    
    ......//BinaryNode<T>的聲明
    
    private BinaryNode<T> root;

    ....... // 二叉查找樹中的方法
｝

 

三，二叉查找樹的一些方法的遞歸實現及分析

1) insert(T ele)，向二叉查找樹中插入一個元素。插入元素之后，返回樹根節點。

正確版本：

private BinaryNode<T> insert(T ele, BinaryNode<T> root){
        if(root == null)
            return new BinaryNode<T>(ele);
        int compareResult = ele.compareTo(root.element);
        if(compareResult > 0)
            root.right = insert(ele, root.right);
        else if(compareResult < 0)
            root.left = insert(ele, root.left);
        else
            ;
        return root;
    }

 

錯誤版本一：

    private BinaryNode<T> insert1(T ele, BinaryNode<T> root){
        if(root == null)
            return new BinaryNode<T>(ele);
        
        int compareResult = ele.compareTo(root.element);
        if(compareResult > 0)
            return insert(ele, root.right);
        else if(compareResult < 0)
            return insert(ele, root.left);
        else
            return root;
        
    }

這種版本的遞歸，返回的是：最后一層遞歸調用時，root所指向的節點。最后一層遞歸調用發生在葉子節點上，故返回的root是最后一個插入的元素。

判斷遞歸調用每一層的返回值時，可按照“壓棧”的順序進行分析。

如，上面程序當運行到第7行時，執行遞歸調用，那么會將當前的環境壓入棧中，保存起來。然后執行下一層的方法調用。

當下面的遞歸調用結束后，程序返回到第7行。繼續向后執行，可以看出第8行的 else if 和 第10行的 else的條件都不成立（因為程序已經在第7行條件成立了）

錯誤版本二：

    private BinaryNode<T> insert2(T ele, BinaryNode<T> root){
        if(root == null)
            return new BinaryNode<T>(ele);
        int compareResult = ele.compareTo(root.element);
        if(compareResult > 0)
            root = insert2(ele, root.right);
        else if(compareResult < 0)
            root = insert2(ele, root.left);
        else
            ;
        return root;
    }

版本二的錯誤和版本一一樣，都沒有建立起父節點與左右孩子節點的連接。因此，最終得到的樹根節點指向的是最后一個插入的元素。

 

2）查找二叉樹中元素最大的節點

正確版本：

 /*
     * 關於尾遞歸的返回值,該方法只會返回二個值: null 和 'root'
     * root 是最后一層遞歸調用時findMax的 root 參數
     */
    private BinaryNode<T> findMax(BinaryNode<T> root){
        if(root == null)
            return null;
        if(root.right == null)
            return root;
        else
            return findMax(root.right);
    }

只有當樹為空時，才返回null。第一個if判斷才會執行，否則第一個if永遠不會執行。每一次遞歸都會使問題的規模縮小---從以root為根的樹，縮小成以root的右孩子為根的樹。

錯誤版本：

    private BinaryNode<T> findMax1(BinaryNode<T> root){
        if(root == null)
            return null;
        else
            return findMax(root.right);
    }
    

該findMax遞歸版本，不管root是否為空，不管樹中有多少個節點，返回的值都為null。從中可以看出，這種形式的遞歸返回值，由其基准條件來決定。

 

3)先序遍歷的遞歸算法分析

    public void preOrder(BinaryNode<T> root){
        if(root == null)
            return;
        System.out.print(root.element + " ");
        preOrder(root.left);
        preOrder(root.right);
    }

該方法能夠清晰地分析遞歸的步驟。假設先序遍歷為e d c f g
               e
            d      f

        c             g

1）對於節點e，執行到第4行，輸出e。在第5行，遞歸調用preOrder(d)，並把preOrder(e)的相關信息壓入棧中保存。

2）對於節點d，執行到第4行，輸出d。在第5行，遞歸調用preOrder(c)，並把preOrder(d)的相關信息壓入棧中保存。

3）對於節點c，執行到第4行，輸出c。在第5行，遞歸調用preOrder(c.left ‘null’)，執行到第三行return null.

此時，返回到 2）由於preOrder(d)在棧頂，彈出preOrder(d)的信息。

由於preOrder(d)在它的下一層遞歸前執行到了第5行，故它從第6行繼續向前執行：preOrder(d.right)=preOrder(null)。並又把preOrder(d)的相關信息壓入棧中。

4)執行preOrder(d.right==null)從第3行 return null

此時，又彈出preOrder(d)，此時從第6行向下繼續執行，遇到了右大括號，執行結束，返回到上層遞歸處.

5）此時preOrder(e)在棧頂，彈出。從第5行斷點處繼續向下執行:preOrder(e.right)=preOrder(f)

6) 對於節點f，執行到第4行，輸出f。在第5行，遞歸調用preOrder(f.left)=preOrder(null)，並把preOrder(f)的相關信息壓入棧保存。

7）執行preOrder(f.left)在第三行返回，彈出preOrder(f)

8) 從preOrder(f)的斷點第5行處向下執行到第6行：preOrder(f.right)=preOrder(g)

9）對於節點g，執行到第4行，輸出g。在第5行遞歸調用preOrder(g.left)，並將preOrder(g)的相關信息入棧....

.....

.....

 

二叉查找樹完整實現代碼如下：

 

package c4;

import java.util.Random;

import c2.C2_2_8;

public class BinarySearchTree<T extends Comparable<? super T>> {

    private static class BinaryNode<T> {
        T element;
        BinaryNode<T> left;
        BinaryNode<T> right;

        public BinaryNode(T element) {
            this(element, null, null);
        }

        public BinaryNode(T element, BinaryNode<T> left, BinaryNode<T> right) {
            this.element = element;
            this.left = left;
            this.right = right;
        }

        public String toString() {
            return element.toString();
        }
    }

    private BinaryNode<T> root;

    public BinarySearchTree() {
        root = null;
    }

    public void makeEmpty() {
        root = null;
    }

    public boolean isEmpty() {
        return root == null;
    }

    public boolean contains(T ele) {
        return contains(ele, root);
    }

    private boolean contains(T ele, BinaryNode<T> root) {
        if (root == null)
            return false;
        int compareResult = ele.compareTo(root.element);
        if (compareResult > 0)
            return contains(ele, root.right);
        else if (compareResult < 0)
            return contains(ele, root.left);
        else
            return true;
    }

    public BinaryNode<T> findMax() {
        return findMax(root);
    }

    /*
     * 關於尾遞歸的返回值,該方法只會返回二個值: null 和 'root' root 是最后一層遞歸調用時findMax的 root 參數
     */
    private BinaryNode<T> findMax(BinaryNode<T> root) {
        if (root == null)
            return null;
        if (root.right == null)
            return root;
        else
            return findMax(root.right);
    }

    public BinaryNode<T> findMin() {
        return findMin(root);
    }

    private BinaryNode<T> findMin(BinaryNode<T> root) {
        if (root == null)
            return null;
        if (root.left == null)
            return root;
        else
            return findMin(root.left);
    }

    public void insert(T ele) {
        root = insert(ele, root);// 每次插入操作都會'更新'根節點.
    }

    private BinaryNode<T> insert(T ele, BinaryNode<T> root) {
        if (root == null)
            return new BinaryNode<T>(ele);
        int compareResult = ele.compareTo(root.element);
        if (compareResult > 0)
            root.right = insert(ele, root.right);
        else if (compareResult < 0)
            root.left = insert(ele, root.left);
        else
            ;
        return root;
    }

    public void preOrder(BinaryNode<T> root) {
        if (root == null)
            return;
        System.out.print(root.element + " ");
        preOrder(root.left);
        preOrder(root.right);
    }

    public void inOrder(BinaryNode<T> root) {
        if (root == null)
            return;
        inOrder(root.left);
        System.out.print(root.element + " ");
        inOrder(root.right);
    }

    public int height() {
        return height(root);
    }

    private int height(BinaryNode<T> root) {
        if (root == null)
            return -1;// 葉子節點的高度為0,空樹的高度為1

        return 1 + (int) Math.max(height(root.left), height(root.right));
    }

    public static void main(String[] args) {
        BinarySearchTree<String> tree = new BinarySearchTree<>();
        tree.insert("e");
        tree.insert("d");
        tree.insert("c");
        tree.insert("f");
        tree.insert("g");

        System.out.println("contains g? " + tree.contains("g"));
        System.out.println("contains h? " + tree.contains("h"));
        System.out.println("max node: " + tree.findMax().toString());
        tree.preOrder(tree.root);
        System.out.println();
        tree.inOrder(tree.root);
        System.out.println("\nheight: " + tree.height());
    ｝
｝