重拾演算法(1)——優雅地非遞迴遍歷二叉樹及其它

重拾演算法(1)——優雅地非遞迴遍歷二叉樹及其它

本文中非遞迴遍歷二叉樹的思想和程式碼都來自這裡（http://jianshu.io/p/49c8cfd07410#）。我認為其思想和程式碼都足夠優雅動人了，於是稍作整理，得到如下的程式。

前中後序遍歷二叉樹

    public class BinaryTreeNode<T>
    {
        public T Value { get;set; }
        public BinaryTreeNode<T> Parent { get;set; }
        public BinaryTreeNode<T> Left { get;set; }
        public BinaryTreeNode<T> Right { get;set; }
        
        public virtual void Traverse(TraverseOrder order, NodeWorker<T> worker)
        {
            if (worker == null) { return; }

            var left = this.Left;
            var right = this.Right;
            switch (order)
            {
            case TraverseOrder.Preorder:
                /* recursive preorder traverse
                worker.DoActionOnNode(this);
                if (left != null) { Left.Traverse(order, worker); }
                if (right != null) { Right.Traverse(order, worker); }
                */
                PreorderTraverse(worker);
                break;
            case TraverseOrder.Inorder:
                /* recursive inorder traverse
                if (left != null) { Left.Traverse(order, worker); }
                worker.DoActionOnNode(this);
                if (right != null) { Right.Traverse(order, worker); }
                */
                InorderTraverse(worker);
                break;
            case TraverseOrder.Postorder:
                /* recursive postorder traverse
                if (left != null) { Left.Traverse(order, worker); }
                if (right != null) { Right.Traverse(order, worker); }
                worker.DoActionOnNode(this);
                */
                PostorderTraverse(worker);
                break;
            default:
                break;
            }
        }
        
        void PreorderTraverse(NodeWorker<T> worker)
        {
            var stack = new Stack<BinaryTreeNode<T>>();
            stack.Push(this); 
            
            while (stack.Count > 0)
            {
                var node = stack.Pop(); 
                //if (node == null) { continue; }
                //else
                {
                    var right = node.Right;
                    var left = node.Left;
                    worker.DoActionOnNode(node);
                    if (right != null) { stack.Push(right); }
                    if (left != null) { stack.Push(left); }
                }
            }
        }        
        /* This works fine and is better for tuition. The code above is an optimized version.
        void PreorderTraverse(NodeWorker<T> worker)
        {
            var stack = new Stack<BinaryTreeNode<T>>(); var stackReady4Visit = new Stack<bool>();
            
            stack.Push(this); stackReady4Visit.Push(false);
            
            while (stack.Count > 0)
            {
                var node = stack.Pop(); var ready4Visit = stackReady4Visit.Pop();
                //if (node == null) { continue; }
                if (ready4Visit)
                {
                    worker.DoActionOnNode(node);
                }
                else
                {
                    var right = node.Right;
                    var left = node.Left;
                    if (right != null) { stack.Push(right); stackReady4Visit.Push(false); }
                    if (left != null) { stack.Push(left); stackReady4Visit.Push(false); }
                    stack.Push(node); stackReady4Visit.Push(true);
                }
            }
        }
        */
        
        void InorderTraverse(NodeWorker<T> worker)
        {
            var stack = new Stack<BinaryTreeNode<T>>(); var stackReady4Visit = new Stack<bool>();
            
            stack.Push(this); stackReady4Visit.Push(false);
            
            while (stack.Count > 0)
            {
                var node = stack.Pop(); var ready4Visit = stackReady4Visit.Pop();
                //if (node == null) { continue; }
                if (ready4Visit)
                {
                    worker.DoActionOnNode(node);
                }
                else
                {
                    var right = node.Right;
                    var left = node.Left;
                    if (right != null) { stack.Push(right); stackReady4Visit.Push(false); }
                    stack.Push(node); stackReady4Visit.Push(true);
                    if (left != null) { stack.Push(left); stackReady4Visit.Push(false); }
                }
            }
        }
        
        void PostorderTraverse(NodeWorker<T> worker)
        {
            var stack = new Stack<BinaryTreeNode<T>>(); var stackReady4Visit = new Stack<bool>();
            
            stack.Push(this); stackReady4Visit.Push(false);
            
            while (stack.Count > 0)
            {
                var node = stack.Pop(); var ready4Visit = stackReady4Visit.Pop();
                //if (node == null) { continue; }
                if (ready4Visit)
                {
                    worker.DoActionOnNode(node);
                }
                else
                {
                    var right = node.Right;
                    var left = node.Left;
                    stack.Push(node); stackReady4Visit.Push(true);
                    if (right != null) { stack.Push(right); stackReady4Visit.Push(false); }
                    if (left != null) { stack.Push(left); stackReady4Visit.Push(false); }
                }
            }
        }
    }
    public abstract class NodeWorker<T>
    {
        public abstract void DoActionOnNode(BinaryTreeNode<T> node);
    }

以上三種遍歷實現程式碼行數一模一樣，如同遞迴遍歷一樣，只有三行核心程式碼的先後順序有區別。用原作者的話解釋就是："得以統一三種更簡單的非遞迴遍歷方法的基本思想：有重合元素的區域性有序一定能導致整體有序。基於這種思想，我就構思三種非遞迴遍歷的統一思想：不管是前序，中序，後序，只要我能保證對每個結點而言，該結點，其左子結點，其右子結點都滿足以前序/中序/後序的訪問順序,整個二叉樹的這種三結點區域性有序一定能保證整體以前序/中序/後序訪問，因為相鄰的區域性必有重合的結點，即一個區域性的"根"結點是另外一個區域性的"子"結點。"。

 

層次遍歷

層次遍歷類似圖的廣度優先搜尋。

    public class BinaryTree<T>
    {
        BinaryTreeNode<T> Node { get;set; }
        public BinaryTree(BinaryTreeNode<T> node)
        {
            this.Node = node;
        }
        
        public void Traverse(TraverseOrder order, NodeWorker<T> worker)
        {
            if (worker == null) { return; }
            var node = this.Node;
            if (node == null) { return; }
            
            switch (order)
            {
            case TraverseOrder.Preorder:
                node.Traverse(order, worker);
                break;
            case TraverseOrder.Inorder:
                node.Traverse(order, worker);
                break;
            case TraverseOrder.Postorder:
                node.Traverse(order, worker);
                break;
            case TraverseOrder.Layer:
                TraverseLayer(worker);
                break;
            default:
                break;
            }
        }
        
        private void TraverseLayer(NodeWorker<T> worker)
        {
            var queue = new Queue<BinaryTreeNode<T>>();
            queue.Enqueue(this.Node);
            while (queue.Count > 0)
            {
                var element = queue.Dequeue();
                if (element != null)
                {
                    worker.DoActionOnNode(element);
                    var left = element.Left;
                    var right = element.Right;
                    if (left != null) { queue.Enqueue(left); }
                    if (right != null) { queue.Enqueue(right); }
                }
            }
        }
    }

 

借用Traverse方法實現其他功能

    public class BinaryTree<T>
    {
        /* 略 */
        
        public int GetNodeCount()
        {
            var counter = new NodeCounter<T>();
            this.Traverse(TraverseOrder.Preorder, counter);
            return counter.Count;
        }
        
        public int GetLeaveCount()
        {
            var counter = new LeaveCounter<T>();
            this.Traverse(TraverseOrder.Preorder, counter);
            return counter.Count;
        }
        
        public int GetNonLeaveCount()
        {
            var counter = new NonLeaveCounter<T>();
            this.Traverse(TraverseOrder.Preorder, counter);
            return counter.Count;
        }
    }
    
    class NonLeaveCounter<T> : NodeWorker<T>
    {
        public int Count { get;set; }
        public override void DoActionOnNode(BinaryTreeNode<T> node)
        {
            if (node != null)
            {
                if (node.Left != null || node.Right != null)
                {
                    this.Count++;
                }
            }
        }
    }
    
    class LeaveCounter<T> : NodeWorker<T>
    {
        public int Count { get;set; }
        public override void DoActionOnNode(BinaryTreeNode<T> node)
        {
            if (node != null)
            {
                if (node.Left == null && node.Right == null)
                {
                    this.Count++;
                }
            }
        }
    }
    
    class NodeCounter<T> : NodeWorker<T>
    {
        public int Count { get;set; }
        public override void DoActionOnNode(BinaryTreeNode<T> node)
        {
            if (node != null)
            {
                this.Count++;
            }
        }
    }