面试题：二叉树的遍历

1.定义队列用到的Node类：

 1   class Node<T>
 2     {
 3         T Val;
 4         Node<T> Next;
 5         public Node() { }
 6         public Node(T val)
 7         {
 8             Val = val;
 9             this.Next = null;
10         }
11         public T Value
12         {
13             get { return Val; }
14             set { Val = value; }
15         }
16         public Node<T> NextNode
17         {
18             get { return Next; }
19             set { Next = value; }
20         }
21     }
View Code

2.定义Queue类：

 1     class Queue<T> 
 2     {
 3         T Val;  //节点值
 4         Node<T> First;
 5         Node<T> Last;
 6         public T Value
 7         {
 8             get { return Val; }
 9             set { Val = value; }
10         }
11         public Node<T> FirstNode
12         {
13             get { return First; }
14             set { First = value; }
15         }
16         public Node<T> LastNode
17         {
18             get { return Last; }
19             set { Last = value; }
20         }
21         public Queue() { }
22         public Queue(Node<T> Head)
23         {
24             FirstNode = Head;
25         }
26         public Queue(Node<T> Head, Node<T> End)
27         {
28             FirstNode = Head;
29             LastNode = End;
30         }
31         public Node<T> Push(T Value)
32         {
33             Node<T> temp = new Node<T>(Value);
34             if (FirstNode == null)
35             {
36                 temp.NextNode = null;
37                 FirstNode = temp;
38                 LastNode = temp;
39             }
40             else if (FirstNode == LastNode)
41             {
42                 LastNode = temp;
43                 FirstNode.NextNode = LastNode;
44             }
45             else
46             {
47                 LastNode.NextNode = temp;
48                 LastNode = temp;
49             }
50             return FirstNode;
51         }
52         public Node<T> Pop(ref Queue<T> que)
53         {
54             if (que.FirstNode == null) return null;
55             Node<T> temp = que.FirstNode;
56             if (que.FirstNode == que.LastNode)
57             {
58                 que.FirstNode = null;
59                 que.LastNode = null;
60             }
61             else
62             {
63                 que.FirstNode = que.FirstNode.NextNode;
64                 temp.NextNode = null;
65             }
66             return temp;
67         }
68     }
View Code

3.定义Stack类：

 1     class Stack<T>
 2     {
 3         Node<T> Head;
 4         public Node<T> HeadNode
 5         {
 6             get{ return Head; }
 7             set { Head = value; }
 8         }
 9         public Stack() { }
10         public Stack(Node<T> node)
11         {
12             if (node != null)
13             {
14                 HeadNode = node;
15             }
16         }
17         public Node<T> Pop()
18         {
19             if (HeadNode == null)
20             {
21                 return null;
22             }
23             else
24             {
25                 Node<T> temp = HeadNode;
26                 Node<T> outNode = HeadNode;
27                 if (temp.NextNode == null)
28                 {
29                     HeadNode = null;
30                     return temp;
31                 }
32                 else
33                 {
34                     while (temp != null)
35                     {
36                         if (temp.NextNode != null && temp.NextNode.NextNode == null)
37                         {
38                             outNode = temp.NextNode;
39                             temp.NextNode = null;
40                             break;
41                         }
42                         temp = temp.NextNode;
43                     }
44                     return outNode;
45                 }
46             }
47         }
48         public Node<T> Push(Node<T> node)
49         {
50             if (HeadNode == null)
51             {
52                 HeadNode = node;
53             }
54             else
55             {
56                 Node<T> temp = HeadNode;
57                 while (temp != null)
58                 {
59                     if (temp.NextNode == null)
60                     {
61                         temp.NextNode = node;
62                         break;
63                     }
64                     temp = temp.NextNode;
65                 }
66             }
67             return HeadNode;
68         }
69     }
View Code

4.定义TreeNode类：

 1     class TreeNode<T>
 2     {
 3         T Val;  //节点值
 4         TreeNode<T> Left;  //左子节点
 5         TreeNode<T> Right; //右子节点
 6         TreeNode<T> Parent;//父节点
 7         public TreeNode() { }
 8         public TreeNode(T value)
 9         {
10             Val = value;           
11         }
12         public T Value
13         {
14             get { return Val; }
15             set { Val = value; }
16         }
17         public TreeNode<T> LeftNode
18         {
19             get { return Left; }
20             set { Left = value; }
21         }
22         public TreeNode<T> RightNode
23         {
24             get { return Right; }
25             set { Right = value; }
26         }
27         public TreeNode<T> ParentNode
28         {
29             get { return Parent; }
30             set { Parent = value; }
31         }
32 
33         /// <summary>
34         /// 建立树节点之间的关系
35         /// </summary>
36         /// <param name="nodeA"></param>
37         /// <param name="nodeB"></param>
38         /// <param name="nodeC"></param>
39         public void setNodeInfo(TreeNode<T> nodeA, TreeNode<T> nodeB, TreeNode<T> nodeC)
40         {
41             this.ParentNode = nodeA;
42             this.LeftNode = nodeB;
43             this.RightNode = nodeC;
44         }
45 }
View Code

5.在TreeNode类中添加遍历TreeNode的方法：

1）先根遍历

 1         /// <summary>
 2         /// 先根遍历
 3         /// </summary>
 4         /// <param name="root"></param>
 5         public void Traverse_RootFirst(TreeNode<T> root)
 6         {
 7             if (root != null)
 8             {
 9                 Console.Write(root.Val+"\t");
10                 Traverse_RootFirst(root.LeftNode);
11                 Traverse_RootFirst(root.RightNode);
12             }
13         }

2）中根遍历

 1         /// <summary>
 2         /// 中根遍历
 3         /// </summary>
 4         /// <param name="root"></param>
 5         public void Traverse_LeftFirst(TreeNode<T> root)
 6         {
 7             if (root != null)
 8             {
 9                 Traverse_LeftFirst(root.LeftNode);
10                 Console.Write(root.Val + "\t");
11                 Traverse_LeftFirst(root.RightNode);
12             }
13         }

3）后根遍历

 1         /// <summary>
 2         /// 后根遍历
 3         /// </summary>
 4         /// <param name="root"></param>
 5         public void Traverse_RightFirst(TreeNode<T> root)
 6         {
 7             if (root != null)
 8             {
 9                 Traverse_RightFirst(root.LeftNode);
10                 Traverse_RightFirst(root.RightNode);
11                 Console.Write(root.Val + "\t");
12             }
13         }

4）层次遍历

 1         /// <summary>
 2         /// 层次遍历
 3         /// </summary>
 4         /// <param name="root"></param>
 5         public void LevelTraverse(TreeNode<T> root)
 6         {
 7             if (root != null)
 8             {
 9                 Queue<TreeNode<T>> que1 = new Queue<TreeNode<T>>();
10                 Queue<TreeNode<T>> que2 = new Queue<TreeNode<T>>();
11                 que1.Push(root);
12                 while (que1 != null)
13                 {                    
14                     TreeNode<T> temp = new TreeNode<T>();
15                     while (que1.FirstNode != null)
16                     {
17                         Console.Write(que1.FirstNode.Value.Value + "\t");
18                         temp = que1.FirstNode.Value;
19                         if (temp.LeftNode != null)
20                         {
21                             que2.Push(temp.LeftNode);
22                         }
23                         if (temp.RightNode != null)
24                         {
25                             que2.Push(temp.RightNode);
26                         }
27                         que1.Pop(ref que1);
28                     }
29                     while (que2.FirstNode != null)
30                     {
31                         Console.Write(que2.FirstNode.Value.Value + "\t");
32                         temp = que2.FirstNode.Value;
33                         if (temp.Left != null)
34                         {
35                             que1.Push(temp.Left);
36                         }
37                         if (temp.Right != null)
38                         {
39                             que1.Push(temp.Right);
40                         }
41                         que2.Pop(ref que2);
42                     }                
43                 }
44             }
45         }

5）蛇形遍历

 1         /// <summary>
 2         /// 蛇形遍历
 3         /// </summary>
 4         /// <param name="root"></param>
 5         public void SerpentineLevelTraverse(TreeNode<T> root)
 6         {
 7             if (root != null)
 8             {
 9                 Queue<TreeNode<T>> que = new Queue<TreeNode<T>>();
10                 Stack<TreeNode<T>> st = new Stack<TreeNode<T>>();
11                 int time = 1;//设置一个变量判断是否为奇数行
12                 que.Push(root);
13                 while (que.FirstNode != null)
14                 {
15                     TreeNode<T> temp = new TreeNode<T>();
16                     while (que.FirstNode != null)
17                     {
18                         temp = que.FirstNode.Value;
19                         Console.Write(temp.Value + "\t");
20                         if (time % 2 == 1)//如果是奇数行，栈内先入左子节点，如果是偶数行，栈内先入右子节点
21                         {
22                             if (temp.LeftNode != null)
23                             {
24                                 st.Push(new Node<TreeNode<T>>(temp.LeftNode));
25                             }
26                             if (temp.RightNode != null)
27                             {
28                                 st.Push(new Node<TreeNode<T>>(temp.RightNode));
29                             }
30                         }
31                         else
32                         {
33                             if (temp.RightNode != null)
34                             {
35                                 st.Push(new Node<TreeNode<T>>(temp.RightNode));
36                             }
37                             if (temp.LeftNode != null)
38                             {
39                                 st.Push(new Node<TreeNode<T>>(temp.LeftNode));
40                             }
41                         }
42                         que.Pop(ref que);
43                     }
44                     time++;
45                     while (st.HeadNode != null)
46                     {
47                         temp = st.Pop().Value;
48                         que.Push(temp);
49                     }
50                 }
51             }
52         }

 主函数：

 1 static void Main(string[] args)
 2         {
 3             TreeNode<string> nodeA = new TreeNode<string>("A");
 4             TreeNode<string> nodeB = new TreeNode<string>("B");
 5             TreeNode<string> nodeC = new TreeNode<string>("C");
 6             TreeNode<string> nodeD = new TreeNode<string>("D");
 7             TreeNode<string> nodeE = new TreeNode<string>("E");
 8             TreeNode<string> nodeF = new TreeNode<string>("F");
 9             TreeNode<string> nodeG = new TreeNode<string>("G");
10             TreeNode<string> nodeH = new TreeNode<string>("H");
11             TreeNode<string> nodeI = new TreeNode<string>("I");
12             TreeNode<string> nodeJ = new TreeNode<string>("J");
13             TreeNode<string> nodeK = new TreeNode<string>("K");
14             nodeA.setNodeInfo(null, nodeB, nodeC);
15             nodeB.setNodeInfo(nodeA, nodeD, nodeE);
16             nodeC.setNodeInfo(nodeA, nodeF, nodeG);
17             nodeD.setNodeInfo(nodeB, null, nodeH);
18             nodeE.setNodeInfo(nodeB, nodeI, nodeJ);
19             nodeF.setNodeInfo(nodeC, null, null);
20             nodeH.setNodeInfo(nodeD, null, nodeK);
21             //nodeA.LevelTraverse(nodeA);
22             nodeA.SerpentineLevelTraverse(nodeA);
23             Console.ReadKey();
24         }

 

蛇形遍历的输出结果：

posted @ 2017-11-08 14:21  美美美少女  阅读(2223)  评论(0)  编辑  收藏  举报