线索二叉树（threaded binary search tree) C#

1. using System;
3. namespace ThreadedBinaryTree
4. {
5.     class Node
6.     {
7.         public Node lchild;
8.         public int lthread;//0 represent a thread,1 represent a link
9.         public int data;
10.         public Node rchild;
11.         public int rthread;
12.         public Node(int Data,int Lthread,int Rthread,Node Lchild,Node Rchild)
13.         {
14.             data = Data;
15.             lchild = Lchild;
16.             rchild = Rchild;
17.             lthread = Lthread;
18.             rthread = Rthread;
19.         }
20.     }
21.     class ThreadedBST
22.     {
23.         private Node head;
24.         public ThreadedBST()//Constructor
25.         {
26.             head = new Node(0, 0, 1, null, null);
27.             head.lchild = head;
28.             head.rchild = head;
29.         }
30.         public void find(int element, ref Node parent, ref Node currentNode)
31.         {
32.             if (head.lthread != 0)//tree is not empty
33.             {
34.                 currentNode = head.lchild;//the top element of the tree
35.                 parent = head;
36.                 while (currentNode != null && currentNode.data != element)
37.                 {
38.                     parent = currentNode;
39.                     if (element < currentNode.data && currentNode.lthread == 1)
40.                         currentNode = currentNode.lchild;
41.                     else if (element < currentNode.data && currentNode.lthread == 0)//reach the leaf node of left subtree
42.                         currentNode = null;
43.                     else if (element > currentNode.data && currentNode.rthread == 1)
44.                         currentNode = currentNode.rchild;
45.                     else if (element > currentNode.data && currentNode.rthread == 0)//reach the leaf node of right subtree
46.                         currentNode = null;
47.                 }
48.             }
49.             else//tree is empty
50.             {
51.                 parent = head;
52.                 Console.WriteLine("Tree is empty");
53.             }
54.         }
55.         public void insert(int element)
56.         {
57.             Node newNode, currentNode=null, parent=null;
58.             find(element,ref parent,ref currentNode);
59.             if (currentNode != null)
60.                 return;
61.             newNode = new Node(element, 0, 0, null, null);
62.             if (parent != head)//if tree is not empty
63.             {
64.                 if (element < parent.data)
65.                 {
66.                     newNode.lchild = parent.lchild;
67.                     newNode.rchild = parent;
68.                     parent.lthread = 1;
69.                     parent.lchild = newNode;
70.                 }
71.                 else if (element > parent.data)
72.                 {
73.                     newNode.rchild = parent.rchild;
74.                     newNode.lchild = parent;
75.                     parent.rthread = 1;
76.                     parent.rchild = newNode;
77.                 }
78.             }
79.             else//if tree is empty
80.             {
81.                 head.lthread = 1;
82.                 head.lchild = newNode;
83.                 newNode.lchild = newNode.rchild = head;
84.             }
85.         }
87.         //if the right child of the node is a link, then we can traverse to the leftmost node in the 
88.         //right subtree of that node to find its inorder successor.However, if the right child of the 
89.         //node is a thread, then the thread will point to the inorder successor of that node
90.         public Node Inorder_successor(ref Node currentNode)//search the successor of currentNode
91.         {
92.             Node inorder_current=null;
93.             if (currentNode.rthread == 0)
94.             {//if the right child of currentNode is a thread,then the node which the thread point to is successor
95.                 return currentNode.rchild;
96.             }
97.             inorder_current = currentNode.rchild;//make currentNode point to the right child of currentNode
98.             while (inorder_current.lthread != 0)//loop until reach the leaf node of left subtree
99.                 inorder_current  = inorder_current.lchild;
100.             return inorder_current;
101.         }
103.         public Node Inorder_predecessor(ref Node currentNode)//search the predecessor of currentNode
104.         {
105.             Node inorder_current = null;
106.             if (currentNode.lthread == 0)
107.                 return currentNode.lchild;
108.             inorder_current = currentNode.lchild;
109.             while (inorder_current.rthread != 0)
110.                 inorder_current = inorder_current.rchild;
111.             return inorder_current;
112.         }
114.         public void Inorder_traversal()
115.         {
116.             Node currentNode;
117.             if (head.lthread == 0)
118.             {
119.                 Console.WriteLine("Tree is empty");
120.                 return;
121.             }
122.             currentNode = head.lchild;
123.             while (currentNode.lthread != 0)//the fist-visit node is the leftmost node of the tree
124.                 currentNode = currentNode.lchild;
125.             Console.Write(currentNode.data + "   ");
126.             while (currentNode.rchild != head)
127.             {
128.                 currentNode = Inorder_successor(ref currentNode);
129.                 Console.Write(currentNode.data + "   ");
130.             }
131.         }
132.         public void delete(int element)
133.         {
134.             Node parent=null, currentNode=null, child=null, successor=null, predecessor=null, inorder_parent=null;
135.             find(element, ref parent, ref currentNode);
136.             if (currentNode != null)
137.             {
138.                 successor = Inorder_successor(ref currentNode);
139.                 predecessor = Inorder_predecessor(ref currentNode);
141.                 if (currentNode.lthread == 0 && currentNode.rthread == 0)//node to be deleted is a leaf node
142.                 {
143.                     if (parent != head)
144.                     {
145.                         if (parent.lchild == currentNode)
146.                         {
147.                             parent.lthread = 0;
148.                             parent.lchild = currentNode.lchild;
149.                         }
150.                         else
151.                         {
152.                             parent.rthread = 0;
153.                             parent.rchild = currentNode.rchild;
154.                         }
155.                     }
156.                     else
157.                     {
158.                         head.lthread = 0;
159.                         head.lchild = head;
160.                     }
161.                 }
163.                 else if ((currentNode.lthread == 0 && currentNode.rthread != 0)
164.                     || (currentNode.lthread != 0 && currentNode.rthread == 0))
165.                 //node to be deleted has one child
166.                 {
167.                     if (currentNode.lthread == 1)//if currentNode has a left child
168.                     {
169.                         child = currentNode.lchild;
170.                         if (parent.lchild == currentNode)//if currentNode is the left child of parent
171.                             parent.lchild = child;
172.                         else
173.                             parent.rchild = child;
174.                         predecessor.rchild = successor;
175.                         predecessor.rthread = 0;
176.                     }
177.                     else//current has a right child
178.                     {
179.                         child = currentNode.rchild;
180.                         if (parent.lchild == currentNode)
181.                             parent.lchild = child;
182.                         else
183.                             parent.rchild = child;
184.                         successor.lchild = predecessor;
185.                         successor.lthread = 0;
186.                     }
187.                 }
189.                 else if (currentNode.lthread == 1 && currentNode.rthread == 1)
190.                 {//node to be delete has two children
191.                     find(successor.data, ref parent, ref successor);
192.                     inorder_parent = parent;//the parent of successor
193.                     currentNode.data = successor.data;
195.                     currentNode = successor;//now delete the successor ,make currentNode point to the successor
196.                     if (currentNode.lthread == 0 && currentNode.rthread == 0)//node to be deleted is a leaf node
197.                     {
198.                         if (parent != head)
199.                         {
200.                             if (parent.lchild == currentNode)
201.                             {
202.                                 parent.lthread = 0;
203.                                 parent.lchild = currentNode.lchild;
204.                             }
205.                             else
206.                             {
207.                                 parent.rthread = 0;
208.                                 parent.rchild = currentNode.rchild;
209.                             }
210.                         }
211.                         else
212.                         {
213.                             head.lthread = 0;
214.                             head.lchild = head;
215.                         }
216.                     }
218.                     if ((currentNode.lthread == 0 && currentNode.rthread != 0)
219.                         || (currentNode.lthread != 0 && currentNode.rthread == 0))
220.                     //node to be deleted has one child
221.                     {
222.                         if (currentNode.lthread == 1)//if currentNode has a right child
223.                         {
224.                             child = currentNode.lchild;
225.                             if (parent.lchild == currentNode)//if currentNode is the left child of parent
226.                                 parent.lchild = child;
227.                             else
228.                                 parent.rchild = child;
229.                             successor.lchild = predecessor;
230.                             successor.lthread = 0;
231.                         }
232.                         else//current has a left child
233.                         {
234.                             child = currentNode.rchild;
235.                             if (parent.lchild == currentNode)
236.                                 parent.lchild = child;
237.                             else
238.                                 parent.rchild = child;
239.                             successor.lchild = predecessor;
240.                             successor.rthread = 0;
241.                         }
242.                     }
243.                 }
244.             }
245.         }
246.         static void Main(string[] args)
247.         {
248.             ThreadedBST b = new ThreadedBST();
249.             while (true)
250.             {
251.                 Console.Clear();
252.                 Console.Write("Inorder traverse:");
253.                 b.Inorder_traversal();
255.                 Console.WriteLine("/nMenu");
256.                 Console.WriteLine("1. Implement insert operation");
257.                 Console.WriteLine("2. Implement delete operation");
258.                 Console.WriteLine("3. Exit");
259.                 Console.Write("/nEnter your Choice:");
260.                 char ch = Convert.ToChar(Console.ReadLine());
261.                 switch (ch)
262.                 {
263.                     case '1':
264.                         {
265.                             Console.Write("Enter a number: ");
266.                             int num =Convert.ToInt32( Console.ReadLine());
267.                             b.insert(num);
268.                         }
269.                         break;
270.                     case '2':
271.                         {
272.                             Console.Write("Enter a number: ");
273.                             int num =Convert.ToInt32( Console.ReadLine());
274.                             b.delete(num);
275.                         }
276.                         break;
277.                     case '3':
278.                         return;
279.                     default:
280.                         Console.WriteLine("Invalid option");
281.                         break;
282.                 }
283.             }
284.         }
285.     }
286. }