二叉搜索樹 (BST) 的創建以及遍歷

二叉搜索樹(Binary Search Tree) ： 屬於二叉樹，其中每個節點都含有一個可以比較的鍵（如需要可以在鍵上關聯值）， 且每個節點的鍵都大於其左子樹中的任意節點而小於右子樹的任意節點的鍵。

1、BST 的總體結構：

主要的幾種變量以及方法如上圖所示，主要有插入、排序、刪除以及查找等方法。鍵采用泛型，繼承 IComparable， 便於比較。

其中節點的類如下圖：

BST 類代碼如下：

    public class BST<Tkey, Tval> where Tkey : IComparable
    {
        private Node root;

        public class Node
        {
            private Tkey key;
            private Tval val;
            private int n;

            public Node(Tkey key, Tval val, int n)
            {
                this.key = key;
                this.val = val;
            }
            public Tkey Key { get => key; }
            public Tval Val { get => val; set => val = value; }
            public Node left { set; get; }
            public Node right { set; get; }
            public int N { set => n = value; get => n; }
        }
                
       public int Size() 
       public void Insert(Tkey, Tval)
       public void Delete(Node x)
       public void InorderTraversal()
    }

 

 

2、插入新節點

根據鍵大於左節點， 小於右節點的定義，可用如下代碼實現新節點的插入：

public void Insert(Tkey key, Tval val)
{
    // 創建私有方法，便於傳入參數 root
    root = Insert(root, key, val);
}

private Node Insert(Node x, Tkey key, Tval val)
{
    // 若節點為空（無根節點），則創建新的節點
    if (x == null)
    {
        return new Node(key, val, 1);
    }

    // 比較鍵的大小，小於返回 -1 ， 大於返回 1， 等於返回 0
    int t = key.CompareTo(x.Key);

    if (t > 0) { x.right = Insert(x.right, key, val); }
    else if (t < 0) { x.left = Insert(x.left, key, val); }
    else { x.Val = val; }

    x.N = Size(x.left) + Size(x.right) + 1;

    return x;
}

  

3、計算以該節點為根的節點總節點數

采用遞歸的方法，從根節點到循環到葉子節點

    public int Size(Node x)
    {
        if (x == null) { return 0; }
        return Size(x.left) + Size(x.right) + 1;
    }

 

 

4、遍歷

遍歷分為廣度遍歷與深度遍歷，如下圖所示：

深度優先遍歷的幾種方式原理相似， 只是輸出的節點鍵的位置不同而已。

中序遍歷遞歸：

    public void InorderTraversal_recursive(Node x)
    {
        if (x == null) { return; }

        InorderTraversal(x.left);
        Console.Write(x.Key + "   ");
        InorderTraversal(x.right);
    }

中序遍歷非遞歸：

    public void  InorderTraversal_stack()   // 利用堆棧先進后出的特性， 先將全部左節點壓入，然后輸出左節點，每輸出一個左節點后切換到右節點， 繼續輸出
    {
        Stack<Node> nodeStack = new Stack<Node>();
        Node currentNode = root;

        while (nodeStack != null || currentNode != null)  // 此處判斷 curretNode 非空，是因為首次循環 nodeStack 為空， 避免了在循環外添加根節點。
        {
            while (currentNode != null)  //  將全部左節點壓入堆棧
            {
                nodeStack.Push(currentNode);
                currentNode = currentNode.left;
            }
            if (nodeStack.count != 0)
               {
                currentNode = nodeStack.Pop();
                Console.Write(currentNode.key + "   ");
                currentNode = currentNode.right; // 切換到右節點
              }
        }
    }

 

層序遍歷：

    // 利用隊列先進先出的特性， 層層輸出
    public void LevelTraversal()
    {
        Queue<Node> nodeQueue = new Queue<Node>();
        if (root != null) { nodeQueue.Enqueue(root); }

        while (nodeQueue.Count() != 0)
        {
            Node currentNode = nodeQueue.Dequeue();
            Console.Write(currentNode.Key + "   ");
            // 將去除節點的子節點添加到隊列的尾部
            if (currentNode.left != null) { nodeQueue.Enqueue(currentNode.left); }
            if (currentNode.right != null) { nodeQueue.Enqueue(currentNode.right); }
        }
    }            

 

5. 證明二叉樹為搜索樹

根據定義，搜索樹是二叉樹的基礎上添加的一個條件： 節點左子樹全部節點小於節點， 節點右子樹大於節點。中序遍歷，全部節點按序遍歷，由此我們只需要證明后一個節點大於前一個節點。

    public bool isBST()
    {
        Stack<Node> nodeStack = new Stack<Node>();
        Node currentNode = root;
        Node preNode = null;


        if (nodeStack.Count() != 0 || currentNode != null)
        {
            while (currentNode != null)
            {
                nodeStack.Push(currentNode);
                currentNode = currentNode.left;
            }

            if (nodeStack.Count() != 0)
            {
                currentNode = nodeStack.Pop();
                // 此處需要判斷 preNode 等於空的情況（當進行首個節點判斷時，preNOde 為空， 跳過判斷） 
                if (preNode != null && currentNode.Key.CompareTo(preNode.Key) <= 0) { return false; }

                preNode = currentNode;
                currentNode = currentNode.right;
            }
        }
        return true;
    }