C＃實現中的二叉搜索樹

Question

class Node
{
    public int data;
    public Node left, right;

    public Node(int data)
    {
        this.data = data;
        left = null;
        right = null;

    }
}

class BinaryTreeImp
{
    Node root;
    static int count = 0;

    public BinaryTreeImp()
    {
        root = null;

    }
    public Node addNode(int data)
    { 
        Node newNode = new Node(data);

        if (root == null)
        {
            root = newNode;

        }
        count++;
        return newNode;


    }

    public void insertNode(Node root,Node newNode )
    {
        Node temp;
        temp = root;

        if (newNode.data < temp.data)
            {
                if (temp.left == null)
                {
                    temp.left = newNode;

                }

                else
                {
                    temp = temp.left;
                    insertNode(temp,newNode);

                }
            }
            else if (newNode.data > temp.data)
            {
                if (temp.right == null)
                {
                    temp.right = newNode;

                }

                else 
                {
                    temp = temp.right;
                    insertNode(temp,newNode);
                }
            }
        }


    public void displayTree(Node root)
    {
        Node temp;
        temp = root;

        if (temp == null)
            return;
            displayTree(temp.left);
            System.Console.Write(temp.data + " ");
            displayTree(temp.right);


    }

    static void Main(string[] args)
    {
       BinaryTreeImp btObj = new BinaryTreeImp();
       Node iniRoot= btObj.addNode(5);


       btObj.insertNode(btObj.root,iniRoot);
       btObj.insertNode(btObj.root,btObj.addNode(6));
       btObj.insertNode(btObj.root,btObj.addNode(10));
       btObj.insertNode(btObj.root,btObj.addNode(2));
       btObj.insertNode(btObj.root,btObj.addNode(3));
       btObj.displayTree(btObj.root);

       System.Console.WriteLine("The sum of nodes are " + count);
       Console.ReadLine();

    }
}

這是實現的代碼。代碼工作正常，但如果在displayTree函數中，我替換它

public void displayTree(Node root)
{
    Node temp;
    temp = root;

    while(temp!=null)
    {
        displayTree(temp.left);
        System.Console.Write(temp.data + " ");
        displayTree(temp.right);
    }

}

導致無限循環。 我不明白是什么導致了這一點。我想知道是否有更好的方法在C＃中實現BST。

Answer 1

我不確定你為什么需要這個循環，但回答你的問題：

while(temp!=null)
{
    displayTree(temp.left);
    System.Console.Write(temp.data + " ");
    displayTree(temp.right);
}

此代碼檢查temp是否為null ，但它永遠不會變為null，因為在循環內部 ，您只對temp的葉子起作用。 這就是為什么你有一個無限循環。

Answer 2

你不需要while循環或temp變量，讓遞歸為你做的工作：

public void displayTree(Node root)
{
    if(root == null) return;

    displayTree(root.left);
    System.Console.Write(root.data + " ");
    displayTree(root.right);
}

Answer 3

temp在開頭設置為root，之后它的值永遠不會改變

怎么樣重寫你的功能

public void displayTree(Node root)
{
     if (root == null)
       return;
     displayTree(root.left);
     Console.Write(...);
     displayTree(root.right);
}

Answer 4

嘗試這個

     public void displayTree(Node root) 
    {
        Node temp;
        temp = root;

        if (temp != null)
        {
            displayTree(temp.left);
            Console.WriteLine(temp.data + " ");
            displayTree(temp.right);

        }
    }

Answer 5

我只是想你也可以使用遞歸來添加函數。 它可能看起來像這樣

      private void Add(BinaryTree node, ref BinaryTree rootNode)
    {
        if (rootNode == null)
        {
            rootNode = node;
        }
        if (node.value > rootNode.value)
        {
            Add(node, ref rootNode.right);
        }
        if (node.value < rootNode.value)
        {

         Add(node, ref rootNode.left);
        }  
    }

Answer 6

請參閱https://msdn.microsoft.com/en-us/library/ms379572%28v=vs.80%29.aspx 。 請參閱“遍歷BST的節點”部分中的示例代碼

另外......別忘了查看SortedDictionary等。他們可能已經准備好了你需要的BST！ https://msdn.microsoft.com/en-us/library/f7fta44c.aspx

Answer 7

完整的二進制搜索樹...使用Code來檢查Tree是否平衡

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;

namespace BinarySearchTree
{

    public class Node
    {
        public Node(int iData)
        {
            data = iData;
            leftNode = null;
            rightNode= null;
        }
        public int data{get; set;}
        public Node leftNode{get; set;}
        public Node rightNode{get; set;}
    };
    public class Program
    {
        public static Node root = null;
        public static void Main(string[] args)
        {
            //Your code goes here
            Console.WriteLine("Hello, world!");
            root = new Node(20);
            InsertNode(root, new Node(10));
            InsertNode(root, new Node(15));
            InsertNode(root, new Node(13));
            InsertNode(root, new Node(11));
            InsertNode(root, new Node(12));
            InsertNode(root, new Node(25));
            InsertNode(root, new Node(22));
            InsertNode(root, new Node(23));
            InsertNode(root, new Node(27));
            InsertNode(root, new Node(26));


           if(CheckIfTreeIsBalanced(root))
           {
                Console.WriteLine("Tree is Balanced!");
           }
           else
           {
               Console.WriteLine("Tree is Not Balanced!");
           }
            PrintTree(root);
        }


        public static void PrintTree(Node root)
        {
           if(root == null) return;        
           Node temp = root;

           PrintTree(temp.leftNode);
           System.Console.Write(temp.data + " "); 
           PrintTree(temp.rightNode);

        }

        public static bool CheckIfTreeIsBalanced(Node root)
        {
            if(root != null)
            {
                if(root.leftNode != null && root.rightNode!= null)
                {
                    if(root.leftNode.data < root.data && root.rightNode.data > root.data)
                    {
                        return CheckIfTreeIsBalanced(root.leftNode)&&CheckIfTreeIsBalanced(root.rightNode);
                    }
                    else
                    {
                        return false;
                    }
                } 
                else if(root.leftNode != null)
                {
                    if(root.leftNode.data < root.data)
                    {
                        return CheckIfTreeIsBalanced(root.leftNode);
                    }
                    else
                    {
                        return false;
                    }
                }
                else if(root.rightNode != null)
                {
                    if(root.rightNode.data > root.data)
                    {
                        return CheckIfTreeIsBalanced(root.rightNode);
                    }
                    else
                    {
                        return false;
                    }
                }
            }
             return true;
        }

        public static void InsertNode(Node root, Node newNode )
        {
        Node temp;
        temp = root;

        if (newNode.data < temp.data)
            {
                if (temp.leftNode == null)
                {
                    temp.leftNode = newNode;

                }

                else
                {
                    temp = temp.leftNode;
                    InsertNode(temp,newNode);

                }
            }
            else if (newNode.data > temp.data)
            {
                if (temp.rightNode == null)
                {
                    temp.rightNode = newNode;

                }

                else 
                {
                    temp = temp.rightNode;
                    InsertNode(temp,newNode);
                }
            }
        }

    }
}

輸出：

Hello, world!
Tree is Balanced!
10 11 12 13 15 20 22 23 25 26 27