给出一颗二叉树的先序遍历、中序遍历、后序遍历中的两者,还原这棵二叉树并输出其另一种遍历的结果。
一个节点类TreeNode< T>
一个二叉树类BinaryTree< T>
一个工具类Tools< T>
一个测试类Person
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;
}
}
写几个方法体测试一下
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为复合数据(引用)类型时,二叉树中节点的值可以相同,但是对象是唯一的。
通过测试可以检验一下。