(C# Binary Tree) 基本概念和算法

A binary tree is defined as a tree where each node can have no more than two children.

Building a Binary Search Tree:

首先创建一个节点Class

    public class BtNode
    {
        public int Data { get; set; }

        public BtNode Left { get; set; }

        public BtNode Right { get; set; }

        public void DisplayNode()
        {
            Console.Write("Data: {0}, ", this.Data); 
        }
    }

然后创建BST Class 提供Insert 方法：

    public class BinarySearchTree
    {
        private BtNode root = null; 

        public BtNode Root
        {
            get
            {
                return this.root; 
            }
            set
            {
                this.root = value; 
            }
        }

        public void Insert(int data)
        {
            BtNode newNode = new BtNode();
            newNode.Data = data; 
            if (this.root == null)
            {
                this.root = newNode; 
            }
            else
            {
                // Add to children nodes.
                BtNode current = this.root; 
                BtNode parent = new BtNode(); 

                while(true)
                {
                    parent = current; 
                    if (data < current.Data)
                    {
                        current = current.Left; 
                        if (current == null )
                        {
                            parent.Left = newNode; 
                            break; 
                        }
                        
                    }
                    else
                    {
                        current = current.Right; 
                        if (current == null)
                        {
                            parent.Right = newNode;
                            break; 
                        }
                    }
                }
            }
        }
    }

Level traverse the binary tree.

思路就是用 Queue （FIFO），从左到右扫描节点，一个节点出队列，就将其节点的左右孩子入队。

        public static void PrintLevelTracversal(BtNode root)
        {
            if (root == null)
            {
                throw new Exception("Binary true is null!"); 
            }

            Queue<BtNode> queueBtNode = new Queue<BtNode>();
            queueBtNode.Enqueue(root);
            BtNode currentNode = root;  

            // Dequeue the node from left to right and put its left/right children into queue.
            while(currentNode != null)
            {
                currentNode = queueBtNode.Dequeue();
                currentNode.DisplayNode(); 

                if (currentNode.Left != null)
                {
                    queueBtNode.Enqueue(currentNode.Left); 
                }

                if (currentNode.Right != null)
                {
                    queueBtNode.Enqueue(currentNode.Right); 
                }
            }
        }

Level traverse and print nodes as Zigzag.

 思路： 用2个Stuck， 一个保存Current Level， 另一个保存Next Level.

当一层 扫完后，将下一层copy到当前层。

       // Non-Recursive method.  Use two stacks. 
        public static void PrintZigzagLevelTraversal(BtNode root)
        {
            if (root == null)
            {
                throw new Exception("Binary tree is null!"); 
            }

            Stack<BtNode> currentLevelStack = new Stack<BtNode>();
            Stack<BtNode> nextLevelStack = new Stack<BtNode>();
            BtNode currentBtNode = new BtNode(); 

            int level = 0;
            currentLevelStack.Push(root); 
           
            while(currentLevelStack.Count > 0)
            {
                // Display current node data.
                currentBtNode = currentLevelStack.Pop();
                currentBtNode.DisplayNode(); 

                if (level % 2 == 0)  // even level 
                {
                    if (currentBtNode.Left != null)
                    {
                        nextLevelStack.Push(currentBtNode.Left);
                    }
                    if (currentBtNode.Right != null)
                    {
                        nextLevelStack.Push(currentBtNode.Right);
                    }
                }
                else
                {
                    if (currentBtNode.Right != null)
                    {
                        nextLevelStack.Push(currentBtNode.Right);
                    }
                    if (currentBtNode.Left != null)
                    {
                        nextLevelStack.Push(currentBtNode.Left);
                    }
                }

                // Move data from next level to current level stack. 
                if (nextLevelStack.Count > 0 && currentLevelStack.Count == 0)
                {
                    BtNode[] nodes = new BtNode[nextLevelStack.Count];
                    nextLevelStack.CopyTo(nodes, 0);
                    for (int i = nodes.Length - 1; i >= 0; i--)
                    {
                        currentLevelStack.Push(nodes[i]); 
                    }
                    nextLevelStack.Clear(); 
                    level++; 
                }
            }
        }