二叉树 C#

1. using System;
2. using System.Text;
4. namespace BinarySearchTree
5. {
6.     class Node//二叉树结点数据类型
7.     {
8.         public string info;//数据
9.         public Node lchild;//左子树
10.         public Node rchild;//右子树
11.         public Node(string i, Node l, Node r)
12.         {
13.             info = i;
14.             lchild = l;
15.             rchild = r;
16.         }
17.     }
18.     class BinaryTree//二叉树基础操作操作类
19.     {
20.         public Node ROOT;//根结点
21.         int height;//数的高度
22.         public BinaryTree()
23.         {
24.             ROOT = null;
25.         }
27.         public void insert(string element)//插入元素
28.         {
29.             Node tmp, parent = null, currentNode = null;
30.             find(element, ref parent, ref currentNode);
31.             if (currentNode != null)//如果currentNode不为空值说明currentNode.info==element，是重复元素
32.             {
33.                 Console.WriteLine("Duplicates words not allowed");
34.                 return;
35.             }
36.             else//如果currentNode为空值时插入新结点
37.             {
38.                 tmp = new Node(element, null, null);//tmp为新节点，lchild和rchild指正均为空
39.                 if (parent == null)//如果parent结点为空，说明树为空，则tmp作为根结点
40.                     ROOT = tmp;
41.                 else
42.                     if (string.Compare(element, parent.info) < 0)//如果parent不为空，则比较parent.info和element的大小
43.                         parent.lchild = tmp;
44.                     else
45.                         parent.rchild = tmp;
46.             }
47.         }
49.         public void find(string element, ref Node parent, ref Node currentNode)//寻找元素
50.         {
51.             currentNode = ROOT;
52.             parent = null;
53.             while ((currentNode != null) && (currentNode.info != element))
54.             {//当currentNode指针所指的当前结点不为空时，或者当前结点的info不为element时循环
55.                 parent = currentNode;//将parent指针指向currentNode指向的当前结点
56.                 if (string.Compare(element, currentNode.info) < 0)
57.                     currentNode = currentNode.lchild;//element比current.info小时，将currentNode指向左子树
58.                 else
59.                     currentNode = currentNode.rchild;
60.             }
61.         }
63.         public void delete(string element)//删除元素
64.         {
65.             Node parent = null, currentNode = null;
66.             find(element,ref parent,ref currentNode);
67.             if (currentNode != null)//找到目标结点
68.             {
69.                 if (currentNode.lchild == null && currentNode.rchild == null)//如果目标结点的左子树和右子树均为空
70.                 {
71.                     if (parent == null)//如果目标结点为根结点
72.                         ROOT = null;
73.                     //Release currentNode
74.                     else
75.                     {
76.                         if (parent.lchild == currentNode)
77.                             parent.lchild = null;
78.                         else
79.                             parent.rchild = null;
80.                         //Release currentNode
81.                     }
82.                 }
83.                 else if ((currentNode.lchild == null && currentNode.rchild != null)
84.                     || (currentNode.lchild != null && currentNode.rchild == null))//如果目标结点有一棵子树
85.                 {
86.                     if (parent == null)
87.                     {
88.                         if (currentNode.lchild!=null)
89.                             ROOT = currentNode.lchild;
90.                         else
91.                             ROOT = currentNode.rchild;
92.                         //Release currentNode
93.                     }
94.                     else
95.                     {
96.                         if (parent.lchild == currentNode)
97.                             if (currentNode.lchild != null)
98.                                 parent.lchild = currentNode.lchild;
99.                             else
100.                                 parent.lchild = currentNode.rchild;
101.                         else
102.                             if (currentNode.lchild != null)
103.                                 parent.rchild = currentNode.lchild;
104.                             else
105.                                 parent.rchild = currentNode.rchild;
106.                         //Release currentNode
107.                     }
108.                 }
109.                 else if (currentNode.lchild != null && currentNode.rchild != null)//如果目标结点有两颗子树
110.                 {
111.                     Node inorder_suc = currentNode.rchild;
112.                     parent = currentNode;
113.                     while (inorder_suc.lchild != null)//寻找currentNode右子树的最左子树
114.                     {
115.                         parent = inorder_suc;
116.                         inorder_suc = inorder_suc.lchild;
117.                     }
118.                     currentNode.info = inorder_suc.info;
120.                     if (inorder_suc.lchild == null && inorder_suc.rchild == null)//如果inorder_suc的左子树和右子树均为空
121.                     {
122.                         if (parent.lchild == inorder_suc)
123.                             parent.lchild = null;
124.                         else
125.                             parent.rchild = null;
126.                         //Release currentNode
127.                     }
129.                     if (inorder_suc.lchild == null || inorder_suc.rchild == null)//如果inorder_suc有一棵子树
130.                     {
131.                         if (parent.lchild == inorder_suc)
132.                             if (inorder_suc.lchild != null)
133.                                 parent.lchild = inorder_suc.lchild;
134.                             else
135.                                 parent.lchild = inorder_suc.rchild;
136.                         else
137.                             if (inorder_suc.lchild != null)
138.                                 parent.rchild = inorder_suc.lchild;
139.                             else
140.                                 parent.rchild = inorder_suc.rchild;
141.                         //Release currentNode
142.                     }
143.                 }
144.             }
145.         }
147.         //public void inorder(Node ptr)//中序遍历二叉树
148.         //{
149.         //    if (ROOT == null)
150.         //    {
151.         //        Console.WriteLine("Tree is empty");
152.         //        return;
153.         //    }
154.         //    if (ptr != null)
155.         //    {
156.         //        inorder(ptr.lchild);
157.         //        Console.Write(ptr.info + "    ");
158.         //        inorder(ptr.rchild);
159.         //    }
160.         //}
162.         //public void preorder(Node ptr)//先序遍历二叉树
163.         //{
164.         //    if (ROOT == null)
165.         //    {
166.         //        Console.WriteLine("Tree is empty");
167.         //        return;
168.         //    }
169.         //    if (ptr != null)
170.         //    {
171.         //        Console.Write(ptr.info + "    ");
172.         //        preorder(ptr.lchild);
173.         //        preorder(ptr.rchild);
174.         //    }
175.         //}
176.         //public void postorder(Node ptr)//后序遍历二叉树
177.         //{
178.         //    if (ROOT == null)
179.         //    {
180.         //        Console.WriteLine("Tree is empty");
181.         //        return;
182.         //    }
183.         //    if (ptr != null)
184.         //    {
185.         //        postorder(ptr.lchild);
186.         //        postorder(ptr.rchild);
187.         //        Console.Write(ptr.info + "    ");
188.         //    }
189.         //}
191.         public int getheight(Node ptr)//求树的高度
192.         {
193.             int lHeight = 0, rHeight = 0;
194.             if (ROOT == null)
195.                 return 0;
196.             else
197.             {
198.                 if (ptr != null)
199.                 {
200.                     lHeight = getheight(ptr.lchild);
201.                     rHeight = getheight(ptr.rchild);
202.                     return (lHeight > rHeight ? lHeight + 1 : rHeight + 1);
203.                 }
204.                 else
205.                     return 0;
206.             }
207.         }
209.         public void printtree(Node ptr,int level)//输出二叉树
210.         {
211.             if (ptr == null)
212.                 return;
213.             else
214.             {
215.                 if (ptr.rchild != null)
216.                     printtree(ptr.rchild, level + 1);
217.                 for (int i = 0; i < level; i++)
218.                     Console.Write("   ");
219.                 Console.WriteLine(ptr.info);
220.                 if (ptr.lchild != null)
221.                     printtree(ptr.lchild, level + 1);
222.             }
223.         }
225.         static void Main(string[] args)
226.         {
227.             BinaryTree b = new BinaryTree();
228.             while (true)
229.             {
230.                 Console.Clear(); 
231.                 b.height = b.getheight(b.ROOT);
232.                 Console.WriteLine("the height of tree:{0}", b.height);
233.                 Console.WriteLine("Print binary tree:");
234.                 b.printtree(b.ROOT, 1);
235.                 Console.WriteLine("/nMenu");
236.                 Console.WriteLine("1. Implement insert operation");
237.                 Console.WriteLine("2. Implement delete operation");
238.                 Console.WriteLine("3. Exit");
239.                 Console.Write("/nEnter your Choice:");
240.                 char ch = Convert.ToChar(Console.ReadLine());
241.                 switch (ch)
242.                 {
243.                     case '1':
244.                         {
245.                             Console.Write("Enter a word: ");
246.                             string word = Console.ReadLine();
247.                             b.insert(word);
248.                         }
249.                         break;
250.                     case '2':
251.                         {
252.                             Console.Write("Enter a word: ");
253.                             string word = Console.ReadLine();
254.                             b.delete(word);
255.                         }
256.                         break;
257.                     case '3':
258.                         return;
259.                     default:
260.                         Console.WriteLine("Invalid option");
261.                         break;
262.                 }
263.             }
264.         }
265.     }
266. }