根据先序、中序、后序中的两者还原二叉树——递归函数和Csharp泛型

给出一颗二叉树的先序遍历、中序遍历、后序遍历中的两者，还原这棵二叉树并输出其另一种遍历的结果。

一个节点类TreeNode< T>

一个二叉树类BinaryTree< T>

一个工具类Tools< T>

一个测试类Person

[code]    public class TreeNode<T>
    {
        private T data;
        private TreeNode<T> left;
        private TreeNode<T> right;

        public T Data
        {
            get { return data; }
            set { data = value; }
        }

        public TreeNode<T> Left
        {
            get { return left; }
            set { left = value; }
        }

        public TreeNode<T> Right
        {
            get { return right; }
            set { right = value; }
        }

        public TreeNode()
        {
            data = default(T);
            left = null;
            right = null;
        }

        public TreeNode(T Data)
        {
            data = Data;
            left = null;
            right = null;
        }

        public TreeNode(TreeNode<T> Left, TreeNode<T> Right)
        {
            data = default(T);
            left = Left;
            right = Right;
        }

        public TreeNode(T Data, TreeNode<T> Left, TreeNode<T> Right)
        {
            data = Data;
            left = Left;
            right = Right;
        }

        public bool isEquals(TreeNode<T> Node)
        {
            if (Data.Equals(Node.Data)) return true;
            else return false;
        }

        public bool isChecked(List<TreeNode<T>> OrderOne, List<TreeNode<T>> OrderTwo)
        {
            bool result = false;
            if (OrderOne.Count == OrderTwo.Count)
            {
                foreach (TreeNode<T> one in OrderOne)
                {
                    result = false;
                    foreach (TreeNode<T> two in OrderTwo)
                    {
                        if (one.isEquals(two))
                        {
                            result = true;
                            break;
                        }
                    }
                }
            }
            return result;
        }

        public TreeNode<T> preinTreeNode(List<TreeNode<T>> preOrder, List<TreeNode<T>> inOrder)
        {
            TreeNode<T> result = new TreeNode<T>();
            if (isChecked(preOrder, inOrder))
            {
                if (preOrder.Count == 0) return null;
                else
                {
                    result.Data = preOrder[0].Data;
                    List<TreeNode<T>> pre1 = new List<TreeNode<T>>();
                    List<TreeNode<T>> pre2 = new List<TreeNode<T>>();
                    List<TreeNode<T>> ino1 = new List<TreeNode<T>>();
                    List<TreeNode<T>> ino2 = new List<TreeNode<T>>();
                    int index = 0;
                    for (int i = 0; i < preOrder.Count; i++)
                    {
                        //if (preOrder[0].isEquals(inOrder[i]))
                        if (preOrder[0] == inOrder[i])
                        {
                            index = i; break;
                        }
                    }
                    for (int i = 1; i < index + 1; i++)
                    {
                        pre1.Add(preOrder[i]);
                    }
                    for (int i = index + 1; i < preOrder.Count; i++)
                    {
                        pre2.Add(preOrder[i]);
                    }
                    for (int i = 0; i < index; i++)
                    {
                        ino1.Add(inOrder[i]);
                    }
                    for (int i = index + 1; i < preOrder.Count; i++)
                    {
                        ino2.Add(inOrder[i]);
                    }
                    if (pre1.Count != 0)
                        result.Left = preinTreeNode(pre1, ino1);
                    if (pre2.Count != 0)
                        result.Right = preinTreeNode(pre2, ino2);
                }
            }
            return result;
        }

        public TreeNode<T> inpostTreeNode(List<TreeNode<T>> inOrder, List<TreeNode<T>> postOrder)
        {
            TreeNode<T> result = new TreeNode<T>();
            if (isChecked(inOrder, postOrder))
            {
                if (inOrder.Count == 0) return null;
                else
                {
                    result.Data = postOrder[postOrder.Count - 1].Data;
                    List<TreeNode<T>> ino1 = new List<TreeNode<T>>();
                    List<TreeNode<T>> ino2 = new List<TreeNode<T>>();
                    List<TreeNode<T>> pos1 = new List<TreeNode<T>>();
                    List<TreeNode<T>> pos2 = new List<TreeNode<T>>();
                    int index = 0;
                    for (int i = 0; i < inOrder.Count; i++)
                    {
                        //if (postOrder[postOrder.Count - 1].isEquals(inOrder[i]))
                        if (postOrder[postOrder.Count - 1] == inOrder[i])
                        {
                            index = i; break;
                        }
                    }
                    for (int i = 0; i < index; i++)
                    {
                        ino1.Add(inOrder[i]);
                    }
                    for (int i = index + 1; i < inOrder.Count; i++)
                    {
                        ino2.Add(inOrder[i]);
                    }
                    for (int i = 0; i < index; i++)
                    {
                        pos1.Add(postOrder[i]);
                    }
                    for (int i = index; i < postOrder.Count - 1; i++)
                    {
                        pos2.Add(postOrder[i]);
                    }
                    if (ino1.Count != 0)
                        result.Left = inpostTreeNode(ino1, pos1);
                    if (ino2.Count != 0)
                        result.Right = inpostTreeNode(ino2, pos2);
                }
            }
            return result;
        }

        public TreeNode<T> prepostTreeNode(List<TreeNode<T>> preOrder, List<TreeNode<T>> postOrder)
        {
            TreeNode<T> result = new TreeNode<T>();
            if (isChecked(preOrder, postOrder))
            {
                if (preOrder.Count == 1) return preOrder[0];
                else
                {
                    result.Data = preOrder[0].Data;
                    List<TreeNode<T>> pre1 = new List<TreeNode<T>>();
                    List<TreeNode<T>> pre2 = new List<TreeNode<T>>();
                    List<TreeNode<T>> pos1 = new List<TreeNode<T>>();
                    List<TreeNode<T>> pos2 = new List<TreeNode<T>>();
                    int index = 0;
                    for (int i = 0; i < postOrder.Count - 1; i++)
                    {
                        //if (preOrder[1].isEquals(postOrder[i]))
                        if (preOrder[1] == postOrder[i])
                        {
                            index = i; break;
                        }
                    }
                    for (int i = 1; i < index + 2; i++)
                    {
                        pre1.Add(preOrder[i]);
                    }
                    for (int i = index + 2; i < preOrder.Count; i++)
                    {
                        pre2.Add(preOrder[i]);
                    }
                    for (int i = 0; i < index + 1; i++)
                    {
                        pos1.Add(postOrder[i]);
                    }
                    for (int i = index + 1; i < preOrder.Count - 1; i++)
                    {
                        pos2.Add(postOrder[i]);
                    }
                    if (pre1.Count != 0)
                        result.Left = prepostTreeNode(pre1, pos1);
                    if (pre2.Count != 0)
                        result.Right = prepostTreeNode(pre2, pos2);
                }
            }
            return result;
        }

        public TreeNode(List<TreeNode<T>> preOrder, List<TreeNode<T>> inOrder)
        {
            if (isChecked(preOrder, inOrder))
            {
                if (preOrder.Count == 0) { }
                else
                {
                    Data = preOrder[0].Data;
                    List<TreeNode<T>> pre1 = new List<TreeNode<T>>();
                    List<TreeNode<T>> pre2 = new List<TreeNode<T>>();
                    List<TreeNode<T>> ino1 = new List<TreeNode<T>>();
                    List<TreeNode<T>> ino2 = new List<TreeNode<T>>();
                    int index = 0;
                    for (int i = 0; i < preOrder.Count; i++)
                    {
                        //if (preOrder[0].isEquals(inOrder[i]))
                        if (preOrder[0]==inOrder[i])
                        {
                            index = i; break;
                        }
                    }
                    for (int i = 1; i < index + 1; i++)
                    {
                        pre1.Add(preOrder[i]);
                    }
                    for (int i = index + 1; i < preOrder.Count; i++)
                    {
                        pre2.Add(preOrder[i]);
                    }
                    for (int i = 0; i < index; i++)
                    {
                        ino1.Add(inOrder[i]);
                    }
                    for (int i = index + 1; i < preOrder.Count; i++)
                    {
                        ino2.Add(inOrder[i]);
                    }
                    if (pre1.Count != 0)
                        Left = new TreeNode<T>(pre1, ino1);
                    if (pre2.Count != 0)
                        right = new TreeNode<T>(pre2, ino2);
                }
            }
        }
    }

    public class BinaryTree<T>
    {
        private TreeNode<T> head;

        public TreeNode<T> Head
        {
            get { return head; }
            set { head = value; }
        }

        public BinaryTree()
        {
            Head = default(TreeNode<T>);
        }

        public BinaryTree(T Data)
        {
            TreeNode<T> h = new TreeNode<T>(Data);
            head = h;
        }

        public BinaryTree(TreeNode<T> Node)
        {
            head = Node;
        }

        public BinaryTree(List<TreeNode<T>> preOrder, List<TreeNode<T>> inOrder)
        {
            TreeNode<T> Node = new TreeNode<T>(preOrder, inOrder);
            head = Node;
        }

        public BinaryTree<T> preinBinaryTree(List<TreeNode<T>> preOrder, List<TreeNode<T>> inOrder)
        {
            TreeNode<T> n = new TreeNode<T>();
            TreeNode<T> Node = n.preinTreeNode(preOrder, inOrder);
            BinaryTree<T> result = new BinaryTree<T>(Node);
            return result;
        }

        public BinaryTree<T> inpostBinaryTree(List<TreeNode<T>> inOrder, List<TreeNode<T>> postOrder)
        {
            TreeNode<T> n = new TreeNode<T>();
            TreeNode<T> Node = n.inpostTreeNode(inOrder, postOrder);
            BinaryTree<T> result = new BinaryTree<T>(Node);
            return result;
        }

        public BinaryTree<T> prepostBinaryTree(List<TreeNode<T>> preOrder, List<TreeNode<T>> postOrder)
        {
            TreeNode<T> n = new TreeNode<T>();
            TreeNode<T> Node = n.prepostTreeNode(preOrder, postOrder);
            BinaryTree<T> result = new BinaryTree<T>(Node);
            return result;
        }

        public bool isEmpty()
        {
            if (head == null) return true;
            else return false;
        }

        public List<TreeNode<T>> preorder(TreeNode<T> Node)
        {
            List<TreeNode<T>> result = new List<TreeNode<T>>();
            if (Node != null)
            {
                result.Add(Node);
            }
            if (Node.Left != null)
            {
                result.AddRange(preorder(Node.Left));
            }
            if (Node.Right != null)
            {
                result.AddRange(preorder(Node.Right));
            }
            return result;
        }

        public List<TreeNode<T>> preorder()
        {
            return preorder(Head);
        }

        public List<TreeNode<T>> inorder(TreeNode<T> Node)
        {
            List<TreeNode<T>> result = new List<TreeNode<T>>();
            if (Node.Left != null)
            {
                result.AddRange(inorder(Node.Left));
            }
            if (Node != null)
            {
                result.Add(Node);
            }
            if (Node.Right != null)
            {
                result.AddRange(inorder(Node.Right));
            }
            return result;
        }

        public List<TreeNode<T>> inorder()
        {
            return inorder(Head);
        }

        public List<TreeNode<T>> postorder(TreeNode<T> Node)
        {
            List<TreeNode<T>> result = new List<TreeNode<T>>();
            if (Node.Left != null)
            {
                result.AddRange(postorder(Node.Left));
            }
            if (Node.Right != null)
            {
                result.AddRange(postorder(Node.Right));
            }
            if (Node != null)
            {
                result.Add(Node);
            }
            return result;
        }

        public List<TreeNode<T>> postorder()
        {
            return postorder(Head);
        }
    }

    public class Tools<T>
    {
        public void print(List<TreeNode<T>> list)
        {
            foreach (TreeNode<T> l in list)
            {
                Console.Write(l.Data.ToString() + " ");
            }
        }

        public void println(List<TreeNode<T>> list)
        {
            foreach (TreeNode<T> l in list)
            {
                Console.Write(l.Data.ToString() + " ");
            }
            Console.WriteLine();
        }
    }

    public class Person
    {
        private string name;

        public string Name
        {
            get { return name; }
            set { name = value; }
        }

        public Person(string Name)
        {
            name = Name;
        }
    }

写几个方法体测试一下

[code]        static void Main(string[] args)
        {
            dowork1();
            dowork2();
            //dowork3();
            dowork4();
            Console.ReadKey();
        }

        public static void dowork1()
        {
            TreeNode<char> tmp1 = new TreeNode<char>('A');
            TreeNode<char> tmp2 = new TreeNode<char>('B');
            TreeNode<char> tmp3 = new TreeNode<char>('D');
            TreeNode<char> tmp4 = new TreeNode<char>('H');
            TreeNode<char> tmp5 = new TreeNode<char>('I');
            TreeNode<char> tmp6 = new TreeNode<char>('E');
            TreeNode<char> tmp7 = new TreeNode<char>('C');
            TreeNode<char> tmp8 = new TreeNode<char>('F');
            TreeNode<char> tmp9 = new TreeNode<char>('G');
            TreeNode<char> tmp10 = new TreeNode<char>('J');
            TreeNode<char> tmp11 = new TreeNode<char>('K');
            TreeNode<char>[] arr1 = { tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp8, tmp9, tmp10, tmp11 };
            TreeNode<char>[] arr2 = { tmp4, tmp3, tmp5, tmp2, tmp6, tmp1, tmp8, tmp7, tmp10, tmp9, tmp11 };
            TreeNode<char>[] arr3 = { tmp4, tmp5, tmp3, tmp6, tmp2, tmp8, tmp10, tmp11, tmp9, tmp7, tmp1 };
            List<TreeNode<char>> list1 = new List<TreeNode<char>>();
            List<TreeNode<char>> list2 = new List<TreeNode<char>>();
            List<TreeNode<char>> list3 = new List<TreeNode<char>>();
            list1.AddRange(arr1);
            list2.AddRange(arr2);
            list3.AddRange(arr3);
            BinaryTree<char> tree0 = new BinaryTree<char>(list1, list2);
            BinaryTree<char> tree1 = new BinaryTree<char>();
            BinaryTree<char> tree2 = new BinaryTree<char>();
            BinaryTree<char> tree3 = new BinaryTree<char>();
            BinaryTree<char> tree = new BinaryTree<char>();
            tree1 = tree.preinBinaryTree(list1, list2);
            tree2 = tree.inpostBinaryTree(list2, list3);
            tree3 = tree.prepostBinaryTree(list1, list3);
            Tools<char> tool = new Tools<char>();
            Console.WriteLine("原先序、中序、后序");
            tool.println(list1);
            tool.println(list2);
            tool.println(list3);
            Console.WriteLine("根据构造函数生成的二叉树先序、中序、后序");
            tool.println(tree0.preorder());
            tool.println(tree0.inorder());
            tool.println(tree0.postorder());
            Console.WriteLine("根据先序、中序生成的二叉树先序、中序、后序");
            tool.println(tree1.preorder());
            tool.println(tree1.inorder());
            tool.println(tree1.postorder());
            Console.WriteLine("根据中序、后序生成的二叉树先序、中序、后序");
            tool.println(tree2.preorder());
            tool.println(tree2.inorder());
            tool.println(tree2.postorder());
            Console.WriteLine("根据先序、后序生成的二叉树先序、中序、后序");
            tool.println(tree3.preorder());
            tool.println(tree3.inorder());
            tool.println(tree3.postorder());
        }

        public static void dowork2()
        {
            TreeNode<string> tmp1 = new TreeNode<string>("aaa");
            TreeNode<string> tmp2 = new TreeNode<string>("bbb");
            TreeNode<string> tmp3 = new TreeNode<string>("ccc");
            TreeNode<string> tmp4 = new TreeNode<string>("ddd");
            TreeNode<string> tmp5 = new TreeNode<string>("eee");
            TreeNode<string> tmp6 = new TreeNode<string>("fff");
            TreeNode<string> tmp7 = new TreeNode<string>("ggg");
            TreeNode<string> tmp8 = new TreeNode<string>("hhh");
            TreeNode<string> tmp9 = new TreeNode<string>("iii");
            TreeNode<string> tmp10 = new TreeNode<string>("jjj");
            TreeNode<string> tmp11 = new TreeNode<string>("kkk");
            TreeNode<string>[] arr1 = { tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp8, tmp9, tmp10, tmp11 };
            TreeNode<string>[] arr2 = { tmp4, tmp3, tmp5, tmp2, tmp6, tmp1, tmp8, tmp7, tmp10, tmp9, tmp11 };
            TreeNode<string>[] arr3 = { tmp4, tmp5, tmp3, tmp6, tmp2, tmp8, tmp10, tmp11, tmp9, tmp7, tmp1 };
            List<TreeNode<string>> list1 = new List<TreeNode<string>>();
            List<TreeNode<string>> list2 = new List<TreeNode<string>>();
            List<TreeNode<string>> list3 = new List<TreeNode<string>>();
            list1.AddRange(arr1);
            list2.AddRange(arr2);
            list3.AddRange(arr3);
            BinaryTree<string> tree0 = new BinaryTree<string>(list1, list2);
            BinaryTree<string> tree1 = new BinaryTree<string>();
            BinaryTree<string> tree2 = new BinaryTree<string>();
            BinaryTree<string> tree3 = new BinaryTree<string>();
            BinaryTree<string> tree = new BinaryTree<string>();
            tree1 = tree.preinBinaryTree(list1, list2);
            tree2 = tree.inpostBinaryTree(list2, list3);
            tree3 = tree.prepostBinaryTree(list1, list3);
            Tools<string> tool = new Tools<string>();
            Console.WriteLine("原先序、中序、后序");
            tool.println(list1);
            tool.println(list2);
            tool.println(list3);
            Console.WriteLine("根据构造函数生成的二叉树先序、中序、后序");
            tool.println(tree0.preorder());
            tool.println(tree0.inorder());
            tool.println(tree0.postorder());
            Console.WriteLine("根据先序、中序生成的二叉树先序、中序、后序");
            tool.println(tree1.preorder());
            tool.println(tree1.inorder());
            tool.println(tree1.postorder());
            Console.WriteLine("根据中序、后序生成的二叉树先序、中序、后序");
            tool.println(tree2.preorder());
            tool.println(tree2.inorder());
            tool.println(tree2.postorder());
            Console.WriteLine("根据先序、后序生成的二叉树先序、中序、后序");
            tool.println(tree3.preorder());
            tool.println(tree3.inorder());
            tool.println(tree3.postorder());
        }

        public static void dowork3()
        {
            TreeNode<string> tmp1 = new TreeNode<string>("aaa");
            TreeNode<string> tmp2 = new TreeNode<string>("aaa");
            TreeNode<string> tmp3 = new TreeNode<string>("ccc");
            TreeNode<string> tmp4 = new TreeNode<string>("ddd");
            TreeNode<string> tmp5 = new TreeNode<string>("eee");
            TreeNode<string> tmp6 = new TreeNode<string>("fff");
            TreeNode<string> tmp7 = new TreeNode<string>("ggg");
            TreeNode<string> tmp8 = new TreeNode<string>("hhh");
            TreeNode<string> tmp9 = new TreeNode<string>("iii");
            TreeNode<string> tmp10 = new TreeNode<string>("jjj");
            TreeNode<string> tmp11 = new TreeNode<string>("kkk");
            TreeNode<string>[] arr1 = { tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp8, tmp9, tmp10, tmp11 };
            TreeNode<string>[] arr2 = { tmp4, tmp3, tmp5, tmp2, tmp6, tmp1, tmp8, tmp7, tmp10, tmp9, tmp11 };
            TreeNode<string>[] arr3 = { tmp4, tmp5, tmp3, tmp6, tmp2, tmp8, tmp10, tmp11, tmp9, tmp7, tmp1 };
            List<TreeNode<string>> list1 = new List<TreeNode<string>>();
            List<TreeNode<string>> list2 = new List<TreeNode<string>>();
            List<TreeNode<string>> list3 = new List<TreeNode<string>>();
            list1.AddRange(arr1);
            list2.AddRange(arr2);
            list3.AddRange(arr3);
            BinaryTree<string> tree0 = new BinaryTree<string>(list1, list2);
            BinaryTree<string> tree1 = new BinaryTree<string>();
            BinaryTree<string> tree2 = new BinaryTree<string>();
            BinaryTree<string> tree3 = new BinaryTree<string>();
            BinaryTree<string> tree = new BinaryTree<string>();
            tree1 = tree.preinBinaryTree(list1, list2);
            tree2 = tree.inpostBinaryTree(list2, list3);
            tree3 = tree.prepostBinaryTree(list1, list3);
            Tools<string> tool = new Tools<string>();
            Console.WriteLine("原先序、中序、后序");
            tool.println(list1);
            tool.println(list2);
            tool.println(list3);
            Console.WriteLine("根据构造函数生成的二叉树先序、中序、后序");
            tool.println(tree0.preorder());
            tool.println(tree0.inorder());
            tool.println(tree0.postorder());
            Console.WriteLine("根据先序、中序生成的二叉树先序、中序、后序");
            tool.println(tree1.preorder());
            tool.println(tree1.inorder());
            tool.println(tree1.postorder());
            Console.WriteLine("根据中序、后序生成的二叉树先序、中序、后序");
            tool.println(tree2.preorder());
            tool.println(tree2.inorder());
            tool.println(tree2.postorder());
            Console.WriteLine("根据先序、后序生成的二叉树先序、中序、后序");
            tool.println(tree3.preorder());
            tool.println(tree3.inorder());
            tool.println(tree3.postorder());
        }

        public static void dowork4()
        {
            Person p1 = new Person("aaa");
            Person p2 = new Person("aaa");
            Person p3 = new Person("ccc");
            Person p4 = new Person("aaa");
            Person p5 = new Person("eee");
            Person p6 = new Person("fff");
            Person p7 = new Person("ggg");
            Person p8 = new Person("hhh");
            Person p9 = new Person("iii");
            Person p10 = new Person("jjj");
            Person p11 = new Person("kkk");
            TreeNode<Person> tmp1 = new TreeNode<Person>(p1);
            TreeNode<Person> tmp2 = new TreeNode<Person>(p2);
            TreeNode<Person> tmp3 = new TreeNode<Person>(p3);
            TreeNode<Person> tmp4 = new TreeNode<Person>(p4);
            TreeNode<Person> tmp5 = new TreeNode<Person>(p5);
            TreeNode<Person> tmp6 = new TreeNode<Person>(p6);
            TreeNode<Person> tmp7 = new TreeNode<Person>(p7);
            TreeNode<Person> tmp8 = new TreeNode<Person>(p8);
            TreeNode<Person> tmp9 = new TreeNode<Person>(p9);
            TreeNode<Person> tmp10 = new TreeNode<Person>(p10);
            TreeNode<Person> tmp11 = new TreeNode<Person>(p11);
            TreeNode<Person>[] arr1 = { tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp8, tmp9, tmp10, tmp11 };
            TreeNode<Person>[] arr2 = { tmp4, tmp3, tmp5, tmp2, tmp6, tmp1, tmp8, tmp7, tmp10, tmp9, tmp11 };
            TreeNode<Person>[] arr3 = { tmp4, tmp5, tmp3, tmp6, tmp2, tmp8, tmp10, tmp11, tmp9, tmp7, tmp1 };
            List<TreeNode<Person>> list1 = new List<TreeNode<Person>>();
            List<TreeNode<Person>> list2 = new List<TreeNode<Person>>();
            List<TreeNode<Person>> list3 = new List<TreeNode<Person>>();
            list1.AddRange(arr1);
            list2.AddRange(arr2);
            list3.AddRange(arr3);
            BinaryTree<Person> tree0 = new BinaryTree<Person>(list1, list2);
            BinaryTree<Person> tree1 = new BinaryTree<Person>();
            BinaryTree<Person> tree2 = new BinaryTree<Person>();
            BinaryTree<Person> tree3 = new BinaryTree<Person>();
            BinaryTree<Person> tree = new BinaryTree<Person>();
            tree1 = tree.preinBinaryTree(list1, list2);
            tree2 = tree.inpostBinaryTree(list2, list3);
            tree3 = tree.prepostBinaryTree(list1, list3);
            Tools<Person> tool = new Tools<Person>();
            Console.WriteLine("原先序、中序、后序");
            personprintln(list1);
            personprintln(list2);
            personprintln(list3);
            Console.WriteLine("根据构造函数生成的二叉树先序、中序、后序");
            personprintln(tree0.preorder());
            personprintln(tree0.inorder());
            personprintln(tree0.postorder());
            Console.WriteLine("根据先序、中序生成的二叉树先序、中序、后序");
            personprintln(tree1.preorder());
            personprintln(tree1.inorder());
            personprintln(tree1.postorder());
            Console.WriteLine("根据中序、后序生成的二叉树先序、中序、后序");
            personprintln(tree2.preorder());
            personprintln(tree2.inorder());
            personprintln(tree2.postorder());
            Console.WriteLine("根据先序、后序生成的二叉树先序、中序、后序");
            personprintln(tree3.preorder());
            personprintln(tree3.inorder());
            personprintln(tree3.postorder());
        }

        public static void personprintln(List<TreeNode<Person>> list)
        {
            foreach(TreeNode<Person> l in list)
            {
                Console.Write(l.Data.Name.ToString() + " ");
            }
            Console.WriteLine();
        }

通过比较节点TreeNode< T>中实体对象的值来还原二叉树。

1. 当T为基本数据（值）类型时，二叉树中节点的值都是唯一的。

2. 当T为复合数据（引用）类型时，二叉树中节点的值可以相同，但是对象是唯一的。

通过测试可以检验一下。