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

给出一颗二叉树的先序遍历、中序遍历、后序遍历中的两者，还原这棵二叉树并输出其另一种遍历的结果。
一个节点类TreeNode< T>
一个二叉树类BinaryTree< T>
一个工具类Tools< T>
一个测试类Person

    public class TreeNode
    {
        private T data;
        private TreeNode left;
        private TreeNode right;

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

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

        public TreeNode 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 Left, TreeNode Right)
        {
            data = default(T);
            left = Left;
            right = Right;
        }

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

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

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

        public TreeNode preinTreeNode(List> preOrder, List> inOrder)
        {
            TreeNode result = new TreeNode();
            if (isChecked(preOrder, inOrder))
            {
                if (preOrder.Count == 0) return null;
                else
                {
                    result.Data = preOrder[0].Data;
                    List> pre1 = new List>();
                    List> pre2 = new List>();
                    List> ino1 = new List>();
                    List> ino2 = new List>();
                    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 inpostTreeNode(List> inOrder, List> postOrder)
        {
            TreeNode result = new TreeNode();
            if (isChecked(inOrder, postOrder))
            {
                if (inOrder.Count == 0) return null;
                else
                {
                    result.Data = postOrder[postOrder.Count - 1].Data;
                    List> ino1 = new List>();
                    List> ino2 = new List>();
                    List> pos1 = new List>();
                    List> pos2 = new List>();
                    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 prepostTreeNode(List> preOrder, List> postOrder)
        {
            TreeNode result = new TreeNode();
            if (isChecked(preOrder, postOrder))
            {
                if (preOrder.Count == 1) return preOrder[0];
                else
                {
                    result.Data = preOrder[0].Data;
                    List> pre1 = new List>();
                    List> pre2 = new List>();
                    List> pos1 = new List>();
                    List> pos2 = new List>();
                    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> preOrder, List> inOrder)
        {
            if (isChecked(preOrder, inOrder))
            {
                if (preOrder.Count == 0) { }
                else
                {
                    Data = preOrder[0].Data;
                    List> pre1 = new List>();
                    List> pre2 = new List>();
                    List> ino1 = new List>();
                    List> ino2 = new List>();
                    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(pre1, ino1);
                    if (pre2.Count != 0)
                        right = new TreeNode(pre2, ino2);
                }
            }
        }
    }

    public class BinaryTree
    {
        private TreeNode head;

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

        public BinaryTree()
        {
            Head = default(TreeNode);
        }

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

        public BinaryTree(TreeNode Node)
        {
            head = Node;
        }

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

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

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

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

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

        public List> preorder(TreeNode Node)
        {
            List> result = new List>();
            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> preorder()
        {
            return preorder(Head);
        }

        public List> inorder(TreeNode Node)
        {
            List> result = new List>();
            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> inorder()
        {
            return inorder(Head);
        }

        public List> postorder(TreeNode Node)
        {
            List> result = new List>();
            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> postorder()
        {
            return postorder(Head);
        }
    }

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

        public void println(List> list)
        {
            foreach (TreeNode 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;
        }
    }

写几个方法体测试一下

        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 };
            Listchar>> list1 = new Listchar>>();
            Listchar>> list2 = new Listchar>>();
            Listchar>> list3 = new Listchar>>();
            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 };
            Liststring>> list1 = new Liststring>>();
            Liststring>> list2 = new Liststring>>();
            Liststring>> list3 = new Liststring>>();
            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 };
            Liststring>> list1 = new Liststring>>();
            Liststring>> list2 = new Liststring>>();
            Liststring>> list3 = new Liststring>>();
            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 tmp1 = new TreeNode(p1);
            TreeNode tmp2 = new TreeNode(p2);
            TreeNode tmp3 = new TreeNode(p3);
            TreeNode tmp4 = new TreeNode(p4);
            TreeNode tmp5 = new TreeNode(p5);
            TreeNode tmp6 = new TreeNode(p6);
            TreeNode tmp7 = new TreeNode(p7);
            TreeNode tmp8 = new TreeNode(p8);
            TreeNode tmp9 = new TreeNode(p9);
            TreeNode tmp10 = new TreeNode(p10);
            TreeNode tmp11 = new TreeNode(p11);
            TreeNode[] arr1 = { tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp8, tmp9, tmp10, tmp11 };
            TreeNode[] arr2 = { tmp4, tmp3, tmp5, tmp2, tmp6, tmp1, tmp8, tmp7, tmp10, tmp9, tmp11 };
            TreeNode[] arr3 = { tmp4, tmp5, tmp3, tmp6, tmp2, tmp8, tmp10, tmp11, tmp9, tmp7, tmp1 };
            List> list1 = new List>();
            List> list2 = new List>();
            List> list3 = new List>();
            list1.AddRange(arr1);
            list2.AddRange(arr2);
            list3.AddRange(arr3);
            BinaryTree tree0 = new BinaryTree(list1, list2);
            BinaryTree tree1 = new BinaryTree();
            BinaryTree tree2 = new BinaryTree();
            BinaryTree tree3 = new BinaryTree();
            BinaryTree tree = new BinaryTree();
            tree1 = tree.preinBinaryTree(list1, list2);
            tree2 = tree.inpostBinaryTree(list2, list3);
            tree3 = tree.prepostBinaryTree(list1, list3);
            Tools tool = new Tools();
            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> list)
        {
            foreach(TreeNode l in list)
            {
                Console.Write(l.Data.Name.ToString() + " ");
            }
            Console.WriteLine();
        }

通过比较节点TreeNode< T>中实体对象的值来还原二叉树。
1. 当T为基本数据（值）类型时，二叉树中节点的值都是唯一的。
2. 当T为复合数据（引用）类型时，二叉树中节点的值可以相同，但是对象是唯一的。
通过测试可以检验一下。