无限树

给你一个二叉树，你能克隆出无限的二叉树，很显然是不能用递归来做的，调用函数它是占用我们的栈的，要是树的高度很高，没克隆几个就Stack Overflow了，所以要用广度优先来做，就得引入队列

Program.cs

    class Test
    {
    static void Main(string[] arg)
    {
         int[]a =new int[]{1,2,3,4,5,6,7};
         var root=Utilities.BuildTree(a,0,a.Length-1);
         //Utilities.DFS(root);
         Utilities.DFS(Clone(root));
    }

    static Node Clone(Node root)
    {
        Queue<Node> q=new Queue<Node>();
        Node newroot=new Node(root.Val);
        q.Enqueue(root);
        q.Enqueue(newroot);
        while(q.Count>0)
        {
            Node original=q.Dequeue();
            Node clone=q.Dequeue();
            if(original.Left!=null)
            {
                clone.Left=new Node(original.Left.Val);
                q.Enqueue(original.Left);
                q.Enqueue(clone.Left);
            }
            if(original.Right!=null)
            {
                clone.Right=new Node(original.Right.Val);
                q.Enqueue(original.Right);
                q.Enqueue(clone.Right);
            }
        }
        return newroot;
    } 

Node.cs

    public class Node
    {
       public int Val;
       public Node Left;
       public Node Right;
       public Node(int val)
       {
           this.Val=val;
       } 
    }

    public class Utilities
    {
        public static Node BuildTree(int[] a,int li,int hi)
        {
            if(hi<li) return null;
            int mi=li+(hi-li)/2;
            Node node=new Node(a[mi]);
            node.Left=BuildTree(a,li,mi-1);
            node.Right=BuildTree(a,mi+1,hi);
            return node;
        }

        public static void DFS(Node node)
        {
            if(node==null)
            {
                return;
            }
            DFS(node.Left);
            System.Console.WriteLine(node.Val);
            DFS(node.Right);
        }

    }