算法系列15天速成——第十二天 树操作【中】

算法系列15天速成——第十二天 树操作【中】

转自：http://blog.csdn.net/m13666368773/article/details/7530313

先前说了树的基本操作，我们采用的是二叉链表来保存树形结构，当然二叉有二叉的困扰之处，比如我想找到当前结点

的“前驱”和“后继”，那么我们就必须要遍历一下树，然后才能定位到该“节点”的“前驱”和“后继”，每次定位都是O（n），这

不是我们想看到的，那么有什么办法来解决呢？

   （1） 在节点域中增加二个指针域，分别保存“前驱”和“后继”，那么就是四叉链表了，哈哈，还是有点浪费空间啊。

   （2） 看下面的这个二叉树，我们知道每个结点有2个指针域，4个节点就有8个指针域，其实真正保存节点的指针

            仅有3个，还有5个是空闲的，那么为什么我们不用那些空闲的指针域呢，达到资源的合理充分的利用。

一： 线索二叉树

 

1  概念

      刚才所说的在空闲的指针域里面存放“前驱”和“后继”就是所谓的线索。

        <1>  左线索：   在空闲的左指针域中存放该“结点”的“前驱”被认为是左线索。

        <2>  右线索：   在空闲的右指针域中存放该“结点“的”后继“被认为是右线索。

      当“二叉链表”被套上这种线索，就被认为是线索链表，当“二叉树”被套上这种线索就被认为是线索二叉树，当然线索根据

二叉树的遍历形式不同被分为“先序线索”，“中序线索”，“后序线索”。

 

2  结构图

      说了这么多，我们还是上图说话，就拿下面的二叉树，我们构建一个中序线索二叉树，需要多动动脑子哟。

     <1> 首先要找到“中序遍历”中的首结点D，因为“D结点”是首节点，所以不存在“前驱”，左指针自然是空，

            ”D节点”的右指针存放的是“后继”，那么根据“中序遍历”的规则应该是B，所以D的右指针存放着B节点。

     <2>  接着就是“B节点”，他的左指针不为空，所以就不管了，但是他的“右指针”空闲，根据规则“B结点“的右

             指针存放的是"A结点“。

     <3>  然后就是“A节点”，他已经被塞的满满的，所以就没有“线索”可言了。

     <4>  最后就是“C节点”，根据规则，他的“左指针”存放着就是“A节点“，”C节点“是最后一个节点，右指针自然就是空的，你懂的。

3 基本操作

   

   常用的操作一般有“创建线索二叉树”，”查找后继节点“，”查找前驱节点“，”遍历线索二叉树“，下面的操作我们就以”中序遍历“

来创建中序线索二叉树。

 

<1>  线索二叉树结构

          从“结构图”中可以看到，现在结点的指针域中要么是”子节点（SubTree）“或者是”线索（Thread）“，此时就要设立标志位来表示指针域

      存放的是哪一种。

[csharp]  view plain  copy

1. #region 节点标识(用于判断孩子是节点还是线索)  
2.      /// <summary>  
3.  /// 节点标识(用于判断孩子是节点还是线索)  
4.  /// </summary>  
5.      public enum NodeFlag  
6.      {  
7.          SubTree = 1,  
8.          Thread = 2  
9.      }  
10.      #endregion  
11.   
12.      #region 线索二叉树的结构  
13.      /// <summary>  
14.  /// 线索二叉树的结构  
15.  /// </summary>  
16.  /// <typeparam name="T"></typeparam>  
17.      public class ThreadTree<T>  
18.      {  
19.          public T data;  
20.          public ThreadTree<T> left;  
21.          public ThreadTree<T> right;  
22.          public NodeFlag leftFlag;  
23.          public NodeFlag rightFlag;  
24.      }  
25.      #endregion  

<2>  创建线索二叉树

        刚才也说了如何构建中序线索二叉树，在代码实现中，我们需要定义一个节点来保存当前节点的前驱，我练习的时候迫不得已，只能使用两个

    ref来实现地址操作，达到一个Tree能够让两个变量来操作。

[csharp]  view plain  copy

1. #region 中序遍历构建线索二叉树  
2.          /// <summary>  
3.  /// 中序遍历构建线索二叉树  
4.  /// </summary>  
5.  /// <typeparam name="T"></typeparam>  
6.  /// <param name="tree"></param>  
7.          public void BinTreeThreadingCreate_LDR<T>(ref ThreadTree<T> tree, ref ThreadTree<T> prevNode)  
8.          {  
9.              if (tree == null)  
10.                  return;  
11.    
12.              //先左子树遍历，寻找起始点  
13.              BinTreeThreadingCreate_LDR(ref tree.left, ref prevNode);  
14.    
15.              //如果left为空，则说明该节点可以放“线索”  
16.              tree.leftFlag = (tree.left == null) ? NodeFlag.Thread : NodeFlag.SubTree;  
17.    
18.              //如果right为空，则说明该节点可以放“线索”  
19.              tree.rightFlag = (tree.right == null) ? NodeFlag.Thread : NodeFlag.SubTree;  
20.    
21.              if (prevNode != null)  
22.              {  
23.                  if (tree.leftFlag == NodeFlag.Thread)  
24.                      tree.left = prevNode;  
25.                  if (prevNode.rightFlag == NodeFlag.Thread)  
26.                      prevNode.right = tree;  
27.              }  
28.    
29.              //保存前驱节点  
30.              prevNode = tree;  
31.    
32.              BinTreeThreadingCreate_LDR(ref tree.right, ref prevNode);  
33.          }  
34.          #endregion  

 

<3> 查找后继结点

         现在大家都知道，后继结点都是保存在“结点“的右指针域中，那么就存在”两种情况“。

            《1》 拿“B节点“来说，他没有右孩子，则肯定存放着线索（Thread),所以我们直接O（1）的返回他的线索即可。

            《2》 拿“A节点”来说，他有右孩子，即右指针域存放的是SubTree，悲哀啊，如何才能得到“A节点“的后继呢？其实也很简单，

                    根据”中序“的定义，”A节点“的后继必定是”A节点“的右子树往左链找的第一个没有左孩子的节点（只可意会，不可言传，嘻嘻）。

[csharp]  view plain  copy

1. #region 查找指定节点的后继  
2.          /// <summary>  
3.  /// 查找指定节点的后继  
4.  /// </summary>  
5.  /// <typeparam name="T"></typeparam>  
6.  /// <param name="tree"></param>  
7.          public ThreadTree<T> BinTreeThreadNext_LDR<T>(ThreadTree<T> tree)  
8.          {  
9.              if (tree == null)  
10.                  return null;  
11.    
12.              //如果查找节点的标志域中是Thread，则直接获取  
13.              if (tree.rightFlag == NodeFlag.Thread)  
14.                  return tree.right;  
15.              else  
16.              {  
17.                  //根据中序遍历的规则是寻找右子树中中序遍历的第一个节点  
18.                  var rightNode = tree.right;  
19.    
20.                  //如果该节点是subTree就需要循环遍历  
21.                  while (rightNode.leftFlag == NodeFlag.SubTree)  
22.                  {  
23.                      rightNode = rightNode.left;  
24.                  }  
25.                  return rightNode;  
26.              }  
27.          }  
28.          #endregion  

 

<4> 查找前驱节点
        

        这个跟（3)的操作很类似，同样也具有两个情况。

          《1》  拿“C结点”来说，他没有“左子树”，则说明“C节点”的左指针为Thread，此时，我们只要返回左指针域即可得到前驱结点。

          《2》  拿"A节点“来说，他有”左子树“，则说明”A节点“的左指针为SubTree，那么怎么找的到”A节点“的前驱呢？同样啊，根据

                   ”中序遍历“的性质，我们可以得知在”A节点“的左子树中往”右链“中找到第一个没有”右孩子“的节点。

[csharp]  view plain  copy

1. #region 查找指定节点的前驱  
2.          /// <summary>  
3.  /// 查找指定节点的前驱  
4.  /// </summary>  
5.  /// <typeparam name="T"></typeparam>  
6.  /// <param name="tree"></param>  
7.  /// <returns></returns>  
8.          public ThreadTree<T> BinTreeThreadPrev_LDR<T>(ThreadTree<T> tree)  
9.          {  
10.              if (tree == null)  
11.                  return null;  
12.    
13.              //如果标志域中存放的是线索，那么可以直接找出来  
14.              if (tree.leftFlag == NodeFlag.Thread)  
15.                  return tree.left;  
16.              else  
17.              {  
18.                  //根据”中序“的规则可知，如果不为Thread，则要找出左子树的最后节点  
19.  //也就是左子树中最后输出的元素  
20.                  var leftNode = tree.left;  
21.    
22.                  while (leftNode.rightFlag == NodeFlag.SubTree)  
23.                      leftNode = leftNode.right;  
24.    
25.                  return leftNode;  
26.              }  
27.          }  
28.          #endregion  

<5> 遍历线索二叉树

          因为我们构建线索的时候采用的是“中序”，那么我们遍历同样采用“中序”，大家是否看到了“线索”的好处，此时我们找某个节点的时间复杂度变为了

        O(1) ~0(n)的时间段，比不是线索的时候查找“前驱"和“后继”效率要高很多。

[csharp]  view plain  copy

1. #region 遍历线索二叉树  
2.          /// <summary>  
3.  /// 遍历线索二叉树  
4.  /// </summary>  
5.  /// <typeparam name="T"></typeparam>  
6.  /// <param name="tree"></param>  
7.          public void BinTreeThread_LDR<T>(ThreadTree<T> tree)  
8.          {  
9.              if (tree == null)  
10.                  return;  
11.    
12.              while (tree.leftFlag == NodeFlag.SubTree)  
13.                  tree = tree.left;  
14.    
15.              do  
16.              {  
17.                  Console.Write(tree.data + "\t");  
18.    
19.                  tree = BinTreeThreadNext_LDR(tree);  
20.    
21.              } while (tree != null);  
22.    
23.          }  
24.          #endregion  

 

最后上一下总的运行代码

[csharp]  view plain  copy

1. View Code   
2.  using System;  
3.  using System.Collections.Generic;  
4.  using System.Linq;  
5.  using System.Text;  
6.    
7.  namespace ThreadChainTree  
8.  {  
9.      class Program  
10.      {  
11.          static void Main(string[] args)  
12.          {  
13.              ThreadTreeManager manager = new ThreadTreeManager();  
14.    
15.              //生成根节点  
16.              ThreadTree<string> tree = CreateRoot();  
17.    
18.              //生成节点  
19.              AddNode(tree);  
20.    
21.              ThreadTree<string> prevNode = null;  
22.    
23.              //构建线索二叉树  
24.              manager.BinTreeThreadingCreate_LDR(ref tree, ref prevNode);  
25.    
26.              Console.WriteLine("\n线索二叉树的遍历结果为：\n");  
27.              //中序遍历线索二叉树  
28.              manager.BinTreeThread_LDR(tree);  
29.          }  
30.   
31.          #region 生成根节点  
32.          /// <summary>  
33.  /// 生成根节点  
34.  /// </summary>  
35.  /// <returns></returns>  
36.          static ThreadTree<string> CreateRoot()  
37.          {  
38.              ThreadTree<string> tree = new ThreadTree<string>();  
39.    
40.              Console.WriteLine("请输入根节点，方便我们生成树\n");  
41.    
42.              tree.data = Console.ReadLine();  
43.    
44.              Console.WriteLine("根节点生成已经生成\n");  
45.    
46.              return tree;  
47.          }  
48.          #endregion  
49.   
50.          #region 插入节点操作  
51.          /// <summary>  
52.  /// 插入节点操作  
53.  /// </summary>  
54.  /// <param name="tree"></param>  
55.          static ThreadTree<string> AddNode(ThreadTree<string> tree)  
56.          {  
57.              ThreadTreeManager mananger = new ThreadTreeManager();  
58.    
59.              while (true)  
60.              {  
61.                  ThreadTree<string> node = new ThreadTree<string>();  
62.    
63.                  Console.WriteLine("请输入要插入节点的数据：\n");  
64.    
65.                  node.data = Console.ReadLine();  
66.    
67.                  Console.WriteLine("请输入要查找的父节点数据：\n");  
68.    
69.                  var parentData = Console.ReadLine();  
70.    
71.                  if (tree == null)  
72.                  {  
73.                      Console.WriteLine("未找到您输入的父节点，请重新输入。");  
74.                      continue;  
75.                  }  
76.    
77.                  Console.WriteLine("请确定要插入到父节点的：1 左侧，2 右侧");  
78.    
79.                  Direction direction = (Direction)Enum.Parse(typeof(Direction), Console.ReadLine());  
80.    
81.                  tree = mananger.BinTreeThreadAddNode(tree, node, parentData, direction);  
82.    
83.                  Console.WriteLine("插入成功，是否继续？  1 继续， 2 退出");  
84.    
85.                  if (int.Parse(Console.ReadLine()) == 1)  
86.                      continue;  
87.                  else  
88.                      break;  
89.              }  
90.    
91.              return tree;  
92.          }  
93.          #endregion  
94.      }  
95.   
96.      #region 节点标识(用于判断孩子是节点还是线索)  
97.      /// <summary>  
98.  /// 节点标识(用于判断孩子是节点还是线索)  
99.  /// </summary>  
100.      public enum NodeFlag  
101.      {  
102.          SubTree = 1,  
103.          Thread = 2  
104.      }  
105.      #endregion  
106.   
107.      #region 线索二叉树的结构  
108.      /// <summary>  
109.  /// 线索二叉树的结构  
110.  /// </summary>  
111.  /// <typeparam name="T"></typeparam>  
112.      public class ThreadTree<T>  
113.      {  
114.          public T data;  
115.          public ThreadTree<T> left;  
116.          public ThreadTree<T> right;  
117.          public NodeFlag leftFlag;  
118.          public NodeFlag rightFlag;  
119.      }  
120.      #endregion  
121.   
122.      #region 插入左节点或者右节点  
123.      /// <summary>  
124.  /// 插入左节点或者右节点  
125.  /// </summary>  
126.      public enum Direction { Left = 1, Right = 2 }  
127.      #endregion  
128.   
129.      #region 线索二叉树的基本操作  
130.      /// <summary>  
131.  /// 线索二叉树的基本操作  
132.  /// </summary>  
133.      public class ThreadTreeManager  
134.      {  
135.          #region 将指定节点插入到二叉树中  
136.          /// <summary>  
137.  /// 将指定节点插入到二叉树中  
138.  /// </summary>  
139.  /// <typeparam name="T"></typeparam>  
140.  /// <param name="tree"></param>  
141.  /// <param name="node"></param>  
142.  /// <param name="direction">插入做左是右</param>  
143.  /// <returns></returns>  
144.          public ThreadTree<T> BinTreeThreadAddNode<T>(ThreadTree<T> tree, ThreadTree<T> node, T data, Direction direction)  
145.          {  
146.              if (tree == null)  
147.                  return null;  
148.    
149.              if (tree.data.Equals(data))  
150.              {  
151.                  switch (direction)  
152.                  {  
153.                      case Direction.Left:  
154.                          if (tree.left != null)  
155.                              throw new Exception("树的左节点不为空，不能插入");  
156.                          else  
157.                              tree.left = node;  
158.    
159.                          break;  
160.                      case Direction.Right:  
161.                          if (tree.right != null)  
162.                              throw new Exception("树的右节点不为空，不能插入");  
163.                          else  
164.                              tree.right = node;  
165.    
166.                          break;  
167.                  }  
168.              }  
169.    
170.              BinTreeThreadAddNode(tree.left, node, data, direction);  
171.              BinTreeThreadAddNode(tree.right, node, data, direction);  
172.    
173.              return tree;  
174.          }  
175.          #endregion  
176.   
177.          #region 中序遍历构建线索二叉树  
178.          /// <summary>  
179.  /// 中序遍历构建线索二叉树  
180.  /// </summary>  
181.  /// <typeparam name="T"></typeparam>  
182.  /// <param name="tree"></param>  
183.          public void BinTreeThreadingCreate_LDR<T>(ref ThreadTree<T> tree, ref ThreadTree<T> prevNode)  
184.          {  
185.              if (tree == null)  
186.                  return;  
187.    
188.              //先左子树遍历，寻找起始点  
189.              BinTreeThreadingCreate_LDR(ref tree.left, ref prevNode);  
190.    
191.              //如果left为空，则说明该节点可以放“线索”  
192.              tree.leftFlag = (tree.left == null) ? NodeFlag.Thread : NodeFlag.SubTree;  
193.    
194.              //如果right为空，则说明该节点可以放“线索”  
195.              tree.rightFlag = (tree.right == null) ? NodeFlag.Thread : NodeFlag.SubTree;  
196.    
197.              if (prevNode != null)  
198.              {  
199.                  if (tree.leftFlag == NodeFlag.Thread)  
200.                      tree.left = prevNode;  
201.                  if (prevNode.rightFlag == NodeFlag.Thread)  
202.                      prevNode.right = tree;  
203.              }  
204.    
205.              //保存前驱节点  
206.              prevNode = tree;  
207.    
208.              BinTreeThreadingCreate_LDR(ref tree.right, ref prevNode);  
209.          }  
210.          #endregion  
211.   
212.          #region 查找指定节点的后继  
213.          /// <summary>  
214.  /// 查找指定节点的后继  
215.  /// </summary>  
216.  /// <typeparam name="T"></typeparam>  
217.  /// <param name="tree"></param>  
218.          public ThreadTree<T> BinTreeThreadNext_LDR<T>(ThreadTree<T> tree)  
219.          {  
220.              if (tree == null)  
221.                  return null;  
222.    
223.              //如果查找节点的标志域中是Thread，则直接获取  
224.              if (tree.rightFlag == NodeFlag.Thread)  
225.                  return tree.right;  
226.              else  
227.              {  
228.                  //根据中序遍历的规则是寻找右子树中中序遍历的第一个节点  
229.                  var rightNode = tree.right;  
230.    
231.                  //如果该节点是subTree就需要循环遍历  
232.                  while (rightNode.leftFlag == NodeFlag.SubTree)  
233.                  {  
234.                      rightNode = rightNode.left;  
235.                  }  
236.                  return rightNode;  
237.              }  
238.          }  
239.          #endregion  
240.   
241.          #region 查找指定节点的前驱  
242.          /// <summary>  
243.  /// 查找指定节点的前驱  
244.  /// </summary>  
245.  /// <typeparam name="T"></typeparam>  
246.  /// <param name="tree"></param>  
247.  /// <returns></returns>  
248.          public ThreadTree<T> BinTreeThreadPrev_LDR<T>(ThreadTree<T> tree)  
249.          {  
250.              if (tree == null)  
251.                  return null;  
252.    
253.              //如果标志域中存放的是线索，那么可以直接找出来  
254.              if (tree.leftFlag == NodeFlag.Thread)  
255.                  return tree.left;  
256.              else  
257.              {  
258.                  //根据”中序“的规则可知，如果不为Thread，则要找出左子树的最后节点  
259.  //也就是左子树中最后输出的元素  
260.                  var leftNode = tree.left;  
261.    
262.                  while (leftNode.rightFlag == NodeFlag.SubTree)  
263.                      leftNode = leftNode.right;  
264.    
265.                  return leftNode;  
266.              }  
267.          }  
268.          #endregion  
269.   
270.          #region 遍历线索二叉树  
271.          /// <summary>  
272.  /// 遍历线索二叉树  
273.  /// </summary>  
274.  /// <typeparam name="T"></typeparam>  
275.  /// <param name="tree"></param>  
276.          public void BinTreeThread_LDR<T>(ThreadTree<T> tree)  
277.          {  
278.              if (tree == null)  
279.                  return;  
280.    
281.              while (tree.leftFlag == NodeFlag.SubTree)  
282.                  tree = tree.left;  
283.    
284.              do  
285.              {  
286.                  Console.Write(tree.data + "\t");  
287.    
288.                  tree = BinTreeThreadNext_LDR(tree);  
289.    
290.              } while (tree != null);  
291.    
292.          }  
293.          #endregion  
294.      }  
295.      #endregion  
296.  }  

 

将文章开头处的数据输入到存储结构中