平衡二叉树（B-Tree) C#

1. using System;
3. namespace BTree
4. {
5.     class Node//二叉树结点数据类型
6.     {
7.         public int data;//数据
8.         public Node lchild;//左子树
9.         public Node rchild;//右子树
10.         public Node(int i, Node l, Node r)
11.         {
12.             data = i;
13.             lchild = l;
14.             rchild = r;
15.         }
16.     }
17.     class BTree
18.     {
19.         public Node ROOT;
20.         public BTree()
21.         {
22.             ROOT = null;
23.         }
24.         public void insert(int element)
25.         {
26.             Node tmp, parent = null, currentNode = null;
27.             find(element, ref parent, ref currentNode);
28.             if (currentNode != null)//如果currentNode不为空值说明currentNode.info==element，是重复元素
29.             {
30.                 Console.WriteLine("Duplicates words not allowed");
31.                 return;
32.             }
33.             else//如果currentNode为空值时插入新结点
34.             {
35.                 tmp = new Node(element, null, null);//tmp为新节点，lchild和rchild指正均为空
36.                 if (parent == null)//如果parent结点为空，说明树为空，则tmp作为根结点
37.                     ROOT = tmp;
38.                 else
39.                     if (element < parent.data)//如果parent不为空，则比较parent.data和element的大小
40.                         parent.lchild = tmp;
41.                     else
42.                         parent.rchild = tmp;
43.             }
44.         }
46.         public void find(int element, ref Node parent, ref Node currentNode)//寻找元素
47.         {
48.             currentNode = ROOT;
49.             parent = null;
50.             while ((currentNode != null) && (currentNode.data != element))
51.             {//当currentNode指针所指的当前结点不为空时，或者当前结点的info不为element时循环
52.                 parent = currentNode;//将parent指针指向currentNode指向的当前结点
53.                 if (element < currentNode.data)
54.                     currentNode = currentNode.lchild;//element比current.data小时，将currentNode指向左子树
55.                 else
56.                     currentNode = currentNode.rchild;
57.             }
58.         }
60.         public void delete(int element)
61.         {
62.             Node parent = null, currentNode = null;
63.             find(element, ref parent, ref currentNode);
64.             if (currentNode != null)//找到目标结点
65.             {
66.                 if (currentNode.lchild == null && currentNode.rchild == null)//如果目标结点的左子树和右子树均为空
67.                 {
68.                     if (parent == null)//如果目标结点为根结点
69.                         ROOT = null;
70.                     //Release currentNode
71.                     else
72.                     {
73.                         if (parent.lchild == currentNode)
74.                             parent.lchild = null;
75.                         else
76.                             parent.rchild = null;
77.                         //Release currentNode
78.                     }
79.                 }
80.                 else if ((currentNode.lchild == null && currentNode.rchild != null)
81.                     || (currentNode.lchild != null && currentNode.rchild == null))//如果目标结点有一棵子树
82.                 {
83.                     if (parent == null)
84.                     {
85.                         if (currentNode.lchild != null)
86.                             ROOT = currentNode.lchild;
87.                         else
88.                             ROOT = currentNode.rchild;
89.                         //Release currentNode
90.                     }
91.                     else
92.                     {
93.                         if (parent.lchild == currentNode)
94.                             if (currentNode.lchild != null)
95.                                 parent.lchild = currentNode.lchild;
96.                             else
97.                                 parent.lchild = currentNode.rchild;
98.                         else
99.                             if (currentNode.lchild != null)
100.                                 parent.rchild = currentNode.lchild;
101.                             else
102.                                 parent.rchild = currentNode.rchild;
103.                         //Release currentNode
104.                     }
105.                 }
106.                 else if (currentNode.lchild != null && currentNode.rchild != null)//如果目标结点有两颗子树
107.                 {
108.                     Node inorder_suc = currentNode.rchild;
109.                     parent = currentNode;
110.                     while (inorder_suc.lchild != null)//寻找currentNode右子树的最左子树
111.                     {
112.                         parent = inorder_suc;
113.                         inorder_suc = inorder_suc.lchild;
114.                     }
115.                     currentNode.data = inorder_suc.data;
117.                     if (inorder_suc.lchild == null && inorder_suc.rchild == null)//如果inorder_suc的左子树和右子树均为空
118.                     {
119.                         if (parent.lchild == inorder_suc)
120.                             parent.lchild = null;
121.                         else
122.                             parent.rchild = null;
123.                         //Release currentNode
124.                     }
126.                     if (inorder_suc.lchild == null || inorder_suc.rchild == null)//如果inorder_suc有一棵子树
127.                     {
128.                         if (parent.lchild == inorder_suc)
129.                             if (inorder_suc.lchild != null)
130.                                 parent.lchild = inorder_suc.lchild;
131.                             else
132.                                 parent.lchild = inorder_suc.rchild;
133.                         else
134.                             if (inorder_suc.lchild != null)
135.                                 parent.rchild = inorder_suc.lchild;
136.                             else
137.                                 parent.rchild = inorder_suc.rchild;
138.                         //Release currentNode
139.                     }
140.                 }
141.             }
142.         }
144.         public void balanceTree(ref Node pivot, ref int BF)
145.         {
146.             Node X, Y, parent = null, currentNode = null;
147.             if (BF < 0)//if tree is initially right heavy
148.             {
149.                 X = pivot.rchild;
150.                 if (getHeight(X.lchild, ref pivot, ref BF) < getHeight(X.rchild, ref pivot, ref BF))
151.                 {//the new node is inserted in the right subtree of X
152.                     find(pivot.data, ref parent, ref currentNode);
153.                     if (pivot != ROOT)
154.                     {
155.                         if (parent.lchild == pivot)
156.                             parent.lchild = X;
157.                         else
158.                             parent.rchild = X;
159.                     }
160.                     else
161.                         ROOT = X;
162.                     pivot.rchild = X.lchild;
163.                     X.lchild = pivot;
164.                 }
165.                 else//the new node is inserted in the left subtree of x
166.                 {
167.                     Y = X.lchild;
169.                     X.lchild = Y.rchild;
170.                     Y.rchild = X;
171.                     pivot.rchild = Y;
173.                     //repeat once the code above when getHeight(X.lchild) < getHeight(X.rchild) 
174.                     X = pivot.rchild;
175.                     find(pivot.data, ref parent, ref currentNode);
176.                     if (pivot != ROOT)
177.                     {
178.                         if (parent.lchild == pivot)
179.                             parent.lchild = X;
180.                         else
181.                             parent.rchild = X;
182.                     }
183.                     else
184.                         ROOT = X;
185.                     pivot.rchild = X.lchild;
186.                     X.lchild = pivot;
187.                 }
188.             }
189.             else//if the tree is initially left heavy
190.             {
191.                  X = pivot.lchild;
192.                  if (getHeight(X.lchild, ref pivot, ref BF) > getHeight(X.rchild, ref pivot, ref BF))
193.                  {//the new node is inserted in the left subtree of X
194.                      find(pivot.data, ref parent, ref currentNode);
195.                      if (pivot != ROOT)
196.                      {
197.                          if (parent.lchild == pivot)
198.                              parent.lchild = X;
199.                          else
200.                              parent.rchild = X;
201.                      }
202.                      else
203.                          ROOT = X;
204.                      pivot.lchild = X.rchild;
205.                      X.rchild = pivot;
206.                  }
207.                  else//the new node is inserted in the right subtree of x
208.                  {
209.                      Y = X.rchild;
210.                      X.rchild = Y.lchild;
211.                      Y.lchild = X;
212.                      pivot.lchild = Y;
214.                      //repeat once the code above when getHeight(X.lchild) > getHeight(X.rchild) 
215.                      X = pivot.lchild;
216.                      find(pivot.data, ref parent, ref currentNode);
217.                      if (pivot != ROOT)
218.                      {
219.                          if (parent.lchild == pivot)
220.                              parent.lchild = X;
221.                          else
222.                              parent.rchild = X;
223.                      }
224.                      else
225.                          ROOT = X;
226.                      pivot.lchild = X.rchild;
227.                      X.rchild = pivot;
228.                  }
229.             }
230.         }
232.         public int getHeight(Node ptr, ref Node pivot, ref int BF)
233.         {
234.             int lHeight = 0, rHeight = 0;
235.             if (ROOT == null && pivot != null)
236.                 return 0;
237.             else
238.             {
239.                 if (ptr!= null)
240.                 {
241.                     lHeight = getHeight(ptr.lchild, ref pivot, ref BF);
242.                     rHeight = getHeight(ptr.rchild, ref pivot, ref BF);
243.                     if (Math.Abs(lHeight - rHeight) > 1 && pivot == null)//notice here!! "pivot==null",otherwise make a mistake
244.                     {//here get pivot and balance factor
245.                         pivot = ptr;
246.                         BF = lHeight - rHeight;
247.                     }
248.                     return (lHeight > rHeight ? lHeight + 1 : rHeight + 1);
249.                 }
250.                 else
251.                     return 0;
252.             }
253.         }
255.         public void printTree(Node ptr, int level)//输出二叉树
256.         {
257.             if (ptr == null)
258.                 return;
259.             else
260.             {
261.                 if (ptr.rchild != null)
262.                     printTree(ptr.rchild, level + 1);
263.                 for (int i = 0; i < level; i++)
264.                     Console.Write("   ");
265.                 Console.WriteLine(ptr.data);
266.                 if (ptr.lchild != null)
267.                     printTree(ptr.lchild, level + 1);
268.             }
269.         }
270.     }
271.     class Program
272.     {
273.         static void Main(string[] args)
274.         {
275.             char ch;
276.             int data, BF;
277.             Node pivot;
278.             BTree b = new BTree();
279.             while (true)
280.             {
281.                 Console.Clear();
282.                 BF = 0;
283.                 pivot = null;
284.                 b.getHeight(b.ROOT, ref pivot, ref BF);
285.                 if (pivot != null)
286.                     b.balanceTree(ref pivot, ref BF);
287.                 Console.WriteLine("print B-Tree:");
288.                 b.printTree(b.ROOT, 1);
289.                 Console.WriteLine("------MENU------");
290.                 Console.WriteLine("1. inseret data");
291.                 Console.WriteLine("2. delete data");
292.                 Console.WriteLine("3. Exit");
293.                 ch = char.Parse(Console.ReadLine());
294.                 switch (ch)
295.                 {
296.                     case '1':
297.                         {
298.                             Console.Write("enter a data:");
299.                             data = int.Parse(Console.ReadLine());
300.                             b.insert(data);
301.                             break;
302.                         }
303.                     case '2':
304.                         {
305.                             Console.WriteLine("enter a data:");
306.                             data = int.Parse(Console.ReadLine());
307.                             b.delete(data);
308.                             break;
309.                         }
310.                     case '3':
311.                         return;
312.                     default:
313.                         {
314.                             Console.WriteLine("Invalid option");
315.                             break;
316.                         }
317.                 }
318.             }
319.         }
320.     }
321. }