C#实现二叉树 二叉链表结构

  1 Binary Tree
  2 
  3 using System;
  4 using System.Collections.Generic;
  5 using System.Linq;
  6 using System.Text;
  7 
  8 namespace DataStructure
  9 {
 10     /// <summary>
 11     /// 二叉链表结点类
 12     /// </summary>
 13     /// <typeparam name="T"></typeparam>
 14     public  class TreeNode<T>
 15     {
 16         private T data;               //数据域
 17         private TreeNode<T> lChild;   //左孩子   树中一个结点的子树的根结点称为这个结点的孩子
 18         private TreeNode<T> rChild;   //右孩子
 19 
 20         public TreeNode(T val, TreeNode<T> lp, TreeNode<T> rp)
 21         {
 22             data = val;
 23             lChild = lp;
 24             rChild = rp;
 25         }
 26 
 27         public TreeNode(TreeNode<T> lp, TreeNode<T> rp)
 28         {
 29             data = default(T);
 30             lChild = lp;
 31             rChild = rp;
 32         }
 33 
 34         public TreeNode(T val)
 35         {
 36             data = val;
 37             lChild = null;
 38             rChild = null;
 39         }
 40 
 41         public TreeNode()
 42         {
 43             data = default(T);
 44             lChild = null;
 45             rChild = null;
 46         }
 47 
 48         public T Data
 49         {
 50             get { return data; }
 51             set { data = value; }
 52         }
 53 
 54         public TreeNode<T> LChild
 55         {
 56             get { return lChild; }
 57             set { lChild = value; }
 58         }
 59 
 60         public TreeNode<T> RChild
 61         {
 62             get { return rChild; }
 63             set { rChild = value; }
 64         }
 65 
 66     }
 67 
 68     /// <summary>
 69     /// 定义索引文件结点的数据类型
 70     /// </summary>
 71     public struct indexnode
 72     {
 73         int key;         //键
 74         int offset;      //位置
 75         public indexnode(int key, int offset)
 76         {
 77             this.key = key;
 78             this.offset = offset;
 79         }
 80 
 81         //键属性
 82         public int Key
 83         {
 84             get { return key; }
 85             set { key = value; }
 86         }
 87         //位置属性
 88         public int Offset
 89         {
 90             get { return offset; }
 91             set { offset = value; }
 92         }
 93 
 94 
 95     }
 96 
 97 
 98     public class LinkBinaryTree<T>
 99     {
100         private TreeNode<T> head;       //头引用
101 
102         public TreeNode<T> Head
103         {
104             get { return head; }
105             set { head = value; }
106         }
107 
108         public LinkBinaryTree()
109         {
110             head = null;
111         }
112 
113         public LinkBinaryTree(T val)
114         {
115             TreeNode<T> p = new TreeNode<T>(val);
116             head = p;
117         }
118 
119         public LinkBinaryTree(T val, TreeNode<T> lp, TreeNode<T> rp)
120         {
121             TreeNode<T> p = new TreeNode<T>(val, lp, rp);
122             head = p;
123         }
124 
125         //判断是否是空二叉树
126         public bool IsEmpty()
127         {
128             if (head == null)
129                 return true;
130             else
131                 return false;
132         }
133 
134         //获取根结点
135         public TreeNode<T> Root()
136         {
137             return head;
138         }
139 
140         //获取结点的左孩子结点
141         public TreeNode<T> GetLChild(TreeNode<T> p)
142         {
143             return p.LChild;
144         }
145 
146         public TreeNode<T> GetRChild(TreeNode<T> p)
147         {
148             return p.RChild;
149         }
150 
151         //将结点p的左子树插入值为val的新结点，原来的左子树称为新结点的左子树
152         public void InsertL(T val, TreeNode<T> p)
153         {
154             TreeNode<T> tmp = new TreeNode<T>(val);
155             tmp.LChild = p.LChild;
156             p.LChild = tmp;
157         }
158 
159         //将结点p的右子树插入值为val的新结点，原来的右子树称为新节点的右子树
160         public void InsertR(T val, TreeNode<T> p)
161         {
162             TreeNode<T> tmp = new TreeNode<T>(val);
163             tmp.RChild = p.RChild;
164             p.RChild = tmp;
165         }
166 
167         //若p非空 删除p的左子树
168         public TreeNode<T> DeleteL(TreeNode<T> p)
169         {
170             if ((p == null) || (p.LChild == null))
171                 return null;
172             TreeNode<T> tmp = p.LChild;
173             p.LChild = null;
174             return tmp;
175         }
176 
177         //若p非空 删除p的右子树
178         public TreeNode<T> DeleteR(TreeNode<T> p)
179         {
180             if ((p == null) || (p.RChild == null))
181                 return null;
182             TreeNode<T> tmp = p.RChild;
183             p.RChild = null;
184             return tmp;
185         }
186 
187         //编写算法 在二叉树中查找值为value的结点
188 
189         public TreeNode<T> Search(TreeNode<T> root, T value)
190         {
191             TreeNode<T> p = root;
192             if (p == null)
193                 return null;
194             if (!p.Data.Equals(value))
195                 return p;
196             if (p.LChild != null)
197             {
198                 return Search(p.LChild, value);
199             }
200             if (p.RChild != null)
201             {
202                 return Search(p.RChild, value);
203             }
204             return null;
205         }
206 
207         //判断是否是叶子结点
208         public bool IsLeaf(TreeNode<T> p)
209         {
210             if ((p != null) && (p.RChild == null) && (p.LChild == null))
211                 return true;
212             else
213                 return false;
214         }
215 
216 
217         //中序遍历
218         //遍历根结点的左子树->根结点->遍历根结点的右子树 
219         public void inorder(TreeNode<T> ptr)
220         {
221             if (IsEmpty())
222             {
223                 Console.WriteLine("Tree is Empty !");
224                 return;
225             }
226             if (ptr != null)
227             {
228                 inorder(ptr.LChild);
229                 Console.WriteLine(ptr.Data + " ");
230                 inorder(ptr.RChild);
231             }
232         }
233 
234 
235         //先序遍历
236         //根结点->遍历根结点的左子树->遍历根结点的右子树 
237         public void preorder(TreeNode<T> ptr)
238         {
239             if (IsEmpty())
240             {
241                 Console.WriteLine("Tree is Empty !");
242                 return;
243             }
244             if (ptr != null)
245             {
246                 Console.WriteLine(ptr.Data + " ");
247                 preorder(ptr.LChild);
248                 preorder(ptr.RChild);
249             }
250         }
251 
252 
253         //后序遍历
254         //遍历根结点的左子树->遍历根结点的右子树->根结点
255         public void postorder(TreeNode<T> ptr)
256         {
257             if (IsEmpty())
258             {
259                 Console.WriteLine("Tree is Empty !");
260                 return;
261             }
262             if (ptr != null)
263             {
264                 postorder(ptr.LChild);
265                 postorder(ptr.RChild);
266                 Console.WriteLine(ptr.Data + "");
267             }
268         }
269 
270 
271         //层次遍历
272         //引入队列 
273         public void LevelOrder(TreeNode<T> root)
274         {
275             if (root == null)
276             {
277                 return;
278             }
279             CSeqQueue<TreeNode<T>> sq = new CSeqQueue<TreeNode<T>>(50);
280             sq.EnQueue(root);
281             while (!sq.IsEmpty())
282             {
283                 //结点出队
284                 TreeNode<T> tmp = sq.DeQueue();
285                 //处理当前结点
286                 Console.WriteLine("{0}", tmp);
287                 //将当前结点的左孩子结点入队
288                 if (tmp.LChild != null)
289                 {
290                     sq.EnQueue(tmp.LChild);
291                 }
292                 if (tmp.RChild != null)
293                 {
294                     sq.EnQueue(tmp.RChild);
295                 }
296             }
297         }
298     }
299 
300     /// <summary>
301     /// 二叉搜索树：结点的左子节点的值永远小于该结点的值，而右子结点的值永远大于该结点的值 称为二叉搜索树
302     /// </summary>
303     public class LinkBinarySearchTree : LinkBinaryTree<indexnode>
304     {
305         //定义增加结点的方法
306         public void insert(indexnode element)
307         {
308             TreeNode<indexnode> tmp, parent = null, currentNode = null;
309             //调用FIND方法
310             find(element, ref parent, ref currentNode);
311             if (currentNode != null)
312             {
313                 Console.WriteLine("Duplicates words not allowed");
314                 return;
315             }
316             else
317             {
318                 //创建结点
319                 tmp = new TreeNode<indexnode>(element);
320                 if (parent == null)
321                     Head = tmp;
322                 else
323                 {
324                     if (element.Key < parent.Data.Key)
325                         parent.LChild = tmp;
326                     else
327                         parent.RChild = tmp;
328                 }
329             }
330         }
331 
332         //定义父结点
333         public void find(indexnode element, ref TreeNode<indexnode> parent, ref TreeNode<indexnode> currentNode)
334         {
335             currentNode = Head;
336             parent = null;
337             while ((currentNode != null) && (currentNode.Data.Key.ToString() != element.Key.ToString()) && (currentNode.Data.Offset .ToString() != element.Offset .ToString()))//
338             {
339                 parent = currentNode;
340                 if (element.Key < currentNode.Data.Key)
341                     currentNode = currentNode.LChild;
342                 else
343                     currentNode = currentNode.RChild;
344             }
345         }
346 
347         //定位结点
348         public void find(int key)
349         {
350             TreeNode<indexnode> currentNode = Head;
351             while ((currentNode != null) && (currentNode.Data.Key.ToString () != key.ToString ()))
352             {
353                 Console.WriteLine(currentNode.Data.Offset.ToString());
354                 if (key < currentNode.Data.Key)
355                     currentNode = currentNode.LChild;
356                 else
357                     currentNode = currentNode.RChild;
358             }
359         }
360 
361         //中序遍历
362         //遍历根结点的左子树->根结点->遍历根结点的右子树 
363         public void inorderS(TreeNode<indexnode> ptr)
364         {
365             if (IsEmpty())
366             {
367                 Console.WriteLine("Tree is Empty !");
368                 return;
369             }
370             if (ptr != null)
371             {
372                 inorderS(ptr.LChild);
373                 Console.WriteLine(ptr.Data.Key  + " ");
374                 inorderS(ptr.RChild);
375             }
376         }
377 
378 
379         //先序遍历
380         //根结点->遍历根结点的左子树->遍历根结点的右子树 
381         public void preorderS(TreeNode<indexnode> ptr)
382         {
383             if (IsEmpty())
384             {
385                 Console.WriteLine("Tree is Empty !");
386                 return;
387             }
388             if (ptr != null)
389             {
390                 Console.WriteLine(ptr.Data.Key  + " ");
391                 preorderS(ptr.LChild);
392                 preorderS(ptr.RChild);
393             }
394         }
395 
396 
397         //后序遍历
398         //遍历根结点的左子树->遍历根结点的右子树->根结点
399         public void postorderS(TreeNode<indexnode> ptr)
400         {
401             if (IsEmpty())
402             {
403                 Console.WriteLine("Tree is Empty !");
404                 return;
405             }
406             if (ptr != null)
407             {
408                 postorderS(ptr.LChild);
409                 postorderS(ptr.RChild);
410                 Console.WriteLine(ptr.Data.Key + "");
411             }
412         }
413     }
414 
415 
416     /// <summary>
417     /// 循环顺序队列
418     /// </summary>
419     /// <typeparam name="T"></typeparam>
420     class CSeqQueue<T>
421     {
422         private int maxsize;       //循环顺序队列的容量
423         private T[] data;          //数组，用于存储循环顺序队列中的数据元素
424         private int front;         //指示最近一个已经离开队列的元素所占有的位置 循环顺序队列的对头
425         private int rear;          //指示最近一个进入队列的元素的位置           循环顺序队列的队尾
426 
427         public T this[int index]
428         {
429             get { return data[index]; }
430             set { data[index] = value; }
431         }
432 
433         //容量属性
434         public int Maxsize
435         {
436             get { return maxsize; }
437             set { maxsize = value; }
438         }
439 
440         //对头指示器属性
441         public int Front
442         {
443             get { return front; }
444             set { front = value; }
445         }
446 
447         //队尾指示器属性
448         public int Rear
449         {
450             get { return rear; }
451             set { rear = value; }
452         }
453 
454         public CSeqQueue()
455         {
456 
457         }
458 
459         public CSeqQueue(int size)
460         {
461             data = new T[size];
462             maxsize = size;
463             front = rear = -1;
464         }
465 
466         //判断循环顺序队列是否为满
467         public bool IsFull()
468         {
469             if ((front == -1 && rear == maxsize - 1) || (rear + 1) % maxsize == front)
470                 return true;
471             else
472                 return false;
473         }
474 
475         //清空循环顺序列表
476         public void Clear()
477         {
478             front = rear = -1;
479         }
480 
481         //判断循环顺序队列是否为空
482         public bool IsEmpty()
483         {
484             if (front == rear)
485                 return true;
486             else
487                 return false;
488         }
489 
490         //入队操作
491         public void EnQueue(T elem)
492         {
493             if (IsFull())
494             {
495                 Console.WriteLine("Queue is Full !");
496                 return;
497             }
498             rear = (rear + 1) % maxsize;
499             data[rear] = elem;
500         }
501 
502         //出队操作
503         public T DeQueue()
504         {
505             if (IsEmpty())
506             {
507                 Console.WriteLine("Queue is Empty !");
508                 return default(T);
509             }
510             front = (front + 1) % maxsize;
511             return data[front];
512         }
513 
514         //获取对头数据元素
515         public T GetFront()
516         {
517             if (IsEmpty())
518             {
519                 Console.WriteLine("Queue is Empty !");
520                 return default(T);
521             }
522             return data[(front + 1) % maxsize];//front从-1开始
523         }
524 
525         //求循环顺序队列的长度
526         public int GetLength()
527         {
528             return (rear - front + maxsize) % maxsize;
529         }
530     }
531 
532 
533     /// <summary>
534     /// 哈夫曼树结点类
535     /// </summary>
536     public class HNode
537     {
538         private int weight;          //结点权值
539         private int lChild;          //左孩子结点
540         private int rChild;          //右孩子结点
541         private int parent;          //父结点
542 
543         public int Weight
544         {
545             get { return weight; }
546             set { weight = value; }
547         }
548 
549         public int LChild
550         {
551             get { return lChild; }
552             set { lChild = value; }
553         }
554 
555         public int RChild
556         {
557             get { return rChild; }
558             set { rChild = value; }
559         }
560 
561         public int Parent
562         {
563             get { return parent; }
564             set { parent = value; }
565         }
566 
567         public HNode()
568         {
569             weight = 0;
570             lChild = -1;
571             rChild = -1;
572             parent = -1;
573         }
574     }
575 class BinaryTree
576     {
577 
578         static void Main(string[] args)
579         {
580             LinkBinarySearchTree bs = new LinkBinarySearchTree();
581             while (true)
582             {
583                 //菜单
584                 Console.WriteLine("\nMenu");
585                 Console.WriteLine("1.创建二叉搜索树");
586                 Console.WriteLine("2.执行中序遍历");
587                 Console.WriteLine("3.执行先序遍历");
588                 Console.WriteLine("4.执行后序遍历");
589                 Console.WriteLine("5.显示搜索一个结点的路径");
590                 Console.WriteLine("6.exit");
591 
592                 Console.WriteLine("\n输入你的选择(1-5)");
593                 char ch = Convert.ToChar(Console.ReadLine());
594                 Console.WriteLine();
595 
596                 switch (ch)
597                 {
598                     case ‘1‘:
599                         {
600                             int key, offset;
601                             string flag;
602                             do
603                             {
604                                 Console.WriteLine("请输入键：");
605                                 key = Convert.ToInt32(Console.ReadLine());
606                                 Console.WriteLine("请输入位置：");
607                                 offset = Convert.ToInt32(Console.ReadLine());
608                                 indexnode element = new indexnode(key, offset);
609                                 bs.insert(element);
610                                 Console.WriteLine("继续添加新的结点(Y/N)？");
611                                 flag = Console.ReadLine();
612                             } while (flag == "Y" || flag == "y");
613                         }
614                         break;
615                     case ‘2‘:
616                         {
617                             bs.inorderS(bs.Head);
618                         }
619                         break;
620                     case ‘3‘:
621                         {
622                             bs.preorderS(bs.Head);
623                         }
624                         break;
625                     case ‘4‘:
626                         {
627                             bs.postorderS(bs.Head);
628                         }
629                         break;
630                     case ‘5‘:
631                         {
632                             int key;
633                             Console.WriteLine("请输入键");
634                             key = Convert.ToInt32(Console.ReadLine());
635                             bs.find(key);
636                         }
637                         break;
638                     case ‘6‘:
639                         return;
640                     default:
641                         {
642                             Console.WriteLine("Invalid option");
643                             break;
644                         }
645                 }
646             }
647         }
648 }