用栈实现递归算法（第一版）

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

namespace TEST
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.Write(GetFoo(10));

            Console.Read();
        }
        //
        static long GetFoo(int n)
        {
            if (IsLeaf(n))
            {
                return GetLeafvalue(n);
            }
            //结果保存栈
            Stack<long[]> resultStack = new Stack<long[]>();

            //临时结果数组
            long[] tempResultArry = InitTempResultArry();

            //压入临时结果数组
            resultStack.Push(tempResultArry);

            //临时节点栈
            Stack<int> tempNodeStack = new Stack<int>();

            //压入根节点
            tempNodeStack.Push(n);

            //遍历临时节点
            while (tempNodeStack.Count > 0)
            {
                tempResultArry = resultStack.Last();
                int branchIndex = GetNodeBranchIndex(tempResultArry);

                //当前节点遍历完成
                if (branchIndex == -1)
                {
                    if (resultStack.Count == 1)
                    {
                        break;
                    }
                    else
                    {
                        tempNodeStack.Pop();
                        resultStack.Pop();
                        //branchIndex = GetNodeBranchIndex(tempResultArry);

                        //把结果赋值给上层
                        //tempResultArry = resultStack.Last();

                        long tempResult = CalculateResult(tempResultArry);
                        tempResultArry[1] = tempResultArry[0];
                        tempResultArry[0] = tempResult;
                    }
                }
                else
                {
                    //没完成，得到要遍历的下一个节点
                    int currentNode = tempNodeStack.First();
                    int nextNode = GetSubNode(currentNode, branchIndex);

                    if (IsLeaf(nextNode))
                    {
                        tempResultArry[branchIndex] = GetLeafvalue(nextNode);
                    }
                    else
                    {
                        tempNodeStack.Push(nextNode);
                        resultStack.Push(InitTempResultArry());
                    }

                }


            }
            return CalculateResult(resultStack.First());
        }

        //
        static bool IsLeaf(int n)
        {
            return n < 3;
        }
        //
        static int GetNodeBranchIndex(long[] tempNodeResultArry)
        {
            for (int i = 0; i < tempNodeResultArry.Length; i++)
            {
                if (tempNodeResultArry[i] == -1)
                {
                    return i;
                }
            }
            return -1;//表示没有遍历完成
        }

        //
        static int GetSubNode(int node, int branchIndex)
        {
            return node - branchIndex - 1;
        }
        //
        static long GetLeafvalue(int n)
        {
            return 1;
        }
        //
        static long[] InitTempResultArry()
        {
            long[] tempResultArry = new long[2];
            for (int i = 0; i < 2; i++)
            {
                tempResultArry[i] = -1;
            }
            return tempResultArry;
        }

        static long CalculateResult(long[] tmpResults)
        {
            long retValue = 0;
            for (int i = 0; i < 2; i++)
            {
                retValue += tmpResults[i];
            }
            return retValue;
        }

    }
}