tree234树的算法实现

        在数学上tree234 树和 红黑树是等价的,所以tree234树可以做为研究红黑树算法的辅助,因为从算法层面和理解层面红黑树要比tree234复杂

1. using System;
2. using System.Collections.Generic;
3. using System.Text;
5. namespace HBDiscover.DSObj.Tree234
6. {
7.     /// <summary>
8.     /// 数据项类
9.     /// </summary>
10.    public class DataItem
11.     {
12.         private long _data;
13.         public DataItem(long data) 
14.         {
15.             _data = data;
16.         }
18.         public long Data
19.         {
20.             get { return _data; }
21.             set { _data = value; }
22.         }
23.     }
25.     public class Node
26.     {
27.         private const int CONST_ORDER = 4;
28.         private int _itemNums;
29.         private Node _parent;
30.         private Node[] childNodes = new Node[CONST_ORDER];
31.         private DataItem[] items = new DataItem[CONST_ORDER - 1];
33.         /// <summary>
34.         /// 是否是叶节点
35.         /// </summary>
36.         public bool IsLeaf
37.         {
38.             get { return childNodes[0]==null; }           
39.         }
41.         /// <summary>
42.         /// 节点数据是否已满
43.         /// </summary>
44.         public bool IsFull
45.         {
46.             get { return _itemNums == CONST_ORDER - 1; }
47.         }
49.         /// <summary>
50.         /// 已存在数据项数
51.         /// </summary>
52.         public int ItemNums
53.         {
54.             get { return _itemNums; }
55.             set { _itemNums = value; }
56.         }
58.         public Node ParentNode
59.         {
60.             get { return _parent; }
61.             set { _parent = value; }
62.         }
64.         /// <summary>
65.         /// 数据项
66.         /// </summary>
67.         public DataItem[] DataItems
68.         {
69.             get { return items; }
70.         }
72.         /// <summary>
73.         /// 子节点
74.         /// </summary>
75.         public Node[] Child
76.         {
77.             get { return childNodes; }
78.         }
80.         /// <summary>
81.         /// 关联节点与当前节点的父子关系
82.         /// </summary>
83.         /// <param name="index"></param>
84.         /// <param name="node"></param>
85.         public void ConnectChild(int index, Node node)
86.         {
87.             childNodes[index] = node;
88.             if(node!=null)
89.                 node.ParentNode = this;
90.         }
91.         
92.         /// <summary>
93.         /// 断开与当前节点的父子关系
94.         /// </summary>
95.         /// <param name="index"></param>
96.         /// <param name="node"></param>
97.         /// <returns></returns>
98.         public Node DisConnectChild(int index)
99.         {
100.             Node tempNode = childNodes[index];
101.             if(tempNode!=null)
102.                 tempNode.ParentNode = null;
103.             return tempNode;
104.         }
106.         public int FindItem(long data)
107.         {
108.             for (int i = 0; i < CONST_ORDER - 1;i++)
109.             {
110.                 if (DataItems[i] == null)
111.                     break;
112.                 else if (data == DataItems[i].Data)
113.                     return i;
114.             }
115.             return -1;
116.         }
118.         public int InsertItem(long data)
119.         {
120.             DataItem item = new DataItem(data);
121.             return InsertItem(item);
122.         }
124.         public int InsertItem(DataItem newItem)
125.         {
126.             this.ItemNums++;
127.             long newData = newItem.Data;
129.             /*--------- 从中间数据2项开始比较--------*/
130.             for (int i = CONST_ORDER - 3; i >= 0; i--)
131.             {
132.                 if (DataItems[i] == null)
133.                     continue;
134.                 else
135.                 {
136.                     if (newData < DataItems[i].Data)
137.                     {
138.                         DataItems[i + 1] = DataItems[i];
139.                     }
140.                     else
141.                     {
142.                         DataItems[i+1] = newItem;
143.                         return i + 1;
144.                     }
145.                 }
146.             }
148.             DataItems[0] = newItem;
149.             return 0;
150.         }
152.         public DataItem RemoveItem()
153.         {
154.             DataItem temp = this.items[this.ItemNums - 1];
155.             this.items[this.ItemNums - 1] = null;
156.             this.ItemNums--;
157.             return temp;
158.         }
160.         public override string ToString()
161.         {
162.             string str = string.Empty;
163.             for(int i=0;i<this._itemNums;i++)
164.             {
165.                 str += this.DataItems[i].Data.ToString();
166.                 str += ",";
167.             }
168.             return str;
169.         }
171.     }
172.     public class Tree234
173.     {
174.         private Node root = new Node();
175.         public void Insert(long data)
176.         {
177.             Node curNode = root;
178.             while (true)
179.             {
180.                 if (curNode.IsFull)
181.                 {
182.                     Split(curNode);
184.                     curNode = curNode.ParentNode;//向上回朔
185.                     curNode = GetAvailableChild(curNode, data);
186.                 }
187.                 else if (curNode.IsLeaf)
188.                     break;
189.                 else //中继节点不是叶节点数据项也没有满
190.                     curNode = GetAvailableChild(curNode, data);
191.             }
192.             curNode.InsertItem(data);
194.         }
195.         /// <summary>
196.         /// 找到当前值所在的节点(可能向下找)
197.         /// </summary>
198.         /// <param name="data"></param>
199.         /// <returns></returns>
200.         public Node Find(long data)
201.         {
202.             Node curNode = root;
203.             while (true)
204.             {
205.                 if (curNode.FindItem(data) != -1)
206.                     return curNode;
207.                 else if (curNode.IsLeaf)
208.                 {
209.                     return null;
210.                 }
211.                 else
212.                     curNode = GetAvailableChild(curNode, data);
213.             }
214.         }
216.         /*  
217.          *       1,2,3           2
218.          *                  1(c0)|3(c1)  
219.          */
220.         /// <summary>
221.         /// 分列节点 
222.         /// </summary>
223.         /// <param name="node"></param>
224.         private void Split(Node node)
225.         {
226.             DataItem itemB, itemC;
227.             Node parent, child1, child2;
229.             itemC = node.RemoveItem();
230.             itemB = node.RemoveItem();
231.             child1 = node.DisConnectChild(2);
232.             child2 = node.DisConnectChild(3);
234.             /*-------------------- 左陔子操作-----------------*/
235.             if (node == root)
236.             {
237.                 root = new Node();
238.                 parent = root;
239.                 parent.ConnectChild(0, node);
240.             }
241.             else
242.             {
243.                 parent = node.ParentNode;
244.             }
246.             /*---------------- 给插入点的孩子节点腾地---------*/
247.             int index = parent.InsertItem(itemB);
248.             for (int i = parent.ItemNums - 1; i > index; i--)
249.             {
250.                 parent.Child[i + 1] = parent.Child[i];
251.             }
253.             /*-------------------- 插入右孩子-----------------*/
254.             Node newRightNode = new Node();
255.             newRightNode.InsertItem(itemC);
256.             parent.ConnectChild(index+1, newRightNode);
257.             newRightNode.ConnectChild(0, child1);
258.             newRightNode.ConnectChild(1, child2);
260.         }
261.         /// <summary>
262.         /// 找到符合给定数据的子孩子(数据在孩子节点中)
263.         /// </summary>
264.         /// <param name="theNode"></param>
265.         /// <param name="data"></param>
266.         /// <returns></returns>
267.         private static Node GetAvailableChild(Node theNode, long data)
268.         {
269.             int i;
270.             for (i = 0; i < theNode.ItemNums; i++)
271.             {
272.                 if (data < theNode.DataItems[i].Data)
273.                     return theNode.Child[i];
274.             }
276.             return theNode.Child[i];
277.         }
278.         string strDis = string.Empty;
279.         private string ToString(Node node, int level, int childNum)
280.         {
281.             strDis += "level:" + level.ToString() + ";childnumat:" + childNum.ToString();
282.             strDis += "|" + node.ToString() + "/r/n";
284.             for (int i = 0; i < node.ItemNums + 1; i++)
285.             {
286.                 Node temp = node.Child[i];
287.                 if (temp != null)
288.                     ToString(temp, level + 1, i);
289.             }
290.             return strDis;
291.         }
293.         public override string ToString()
294.         {
295.             return ToString(root,0,0);
296.         }
297.     }
298. }