Heap算法实现

1.  using System;
2. using System.Collections.Generic;
3. using System.Text;
5. namespace .DSObj
6. {
8.     /*****************************************************************************
9.      * 
10.      * 数组表示树                   [0]=8          parent = (index-1)/2;
11.      *                8             [1]=3          leftchild = index*2+1;
12.      *             /    /           [2]=6          rightchild = leftchild+1;
13.      *            3      6          [3]=0          最右边非叶节点(6)=maxIndex/2-1;
14.      *           / /    / /         [4]=3
15.      *          0   3  4   5        [5]=4
16.      *                              [6]=5
17.      * 
18.      * **************************************************************************/
20.     /// <summary>
21.     /// //
22.     /// </summary>
23.     public class Heap<T> where T : System.IComparable
24.     {
25.         T[] heapArr;
26.         int m_maxSize;
27.         int m_curIndex;
28.         public Heap(int maxSize)
29.         {
30.             heapArr = new T[maxSize];
31.             m_maxSize = maxSize;
32.             m_curIndex = 0;
33.         }
35.         public Heap(int maxSize,T[] items):this(maxSize)
36.         {
37.             Insert(items);
38.         }
40.         public bool Insert(T item)
41.         {
42.             if (m_curIndex == m_maxSize)
43.                 return false;
44.             heapArr[m_curIndex] = item;          
45.             TrickleUp(m_curIndex++);
47.             return true;
48.         }
50.         public void Insert(T[] items)
51.         {
52.             foreach (T temp in items)
53.                 Insert(temp);
54.         }
56.         public bool IsEmpty()
57.         {
58.             return m_curIndex == 0;
59.         }
61.         public T Remove()
62.         {
63.             T root = heapArr[0];
64.             //把最后一个元素放到顶部
65.             heapArr[0] = heapArr[--m_curIndex];
66.             TrickleDown(0);
67.             return root;
68.         }
70.         /// <summary>
71.         /// m_curIndex / 2 -1 = 堆中最右边非叶节点的节点(6)
72.         /// </summary>
73.         /// <param name="itemIndex"></param>
74.         private void TrickleDown(int itemIndex)
75.         {
76.             int largerIndex;//左右孩子大的索引
77.             T item = heapArr[itemIndex];
79.             //索引找到小于树的高度的节点，最大找到叶节点父节点。
80.             //叶节点没有子孩子 
81.             while (itemIndex < m_curIndex / 2)
82.             {
83.                 int lChildIndex = itemIndex * 2 + 1;
84.                 int rChildIndex = lChildIndex + 1;
85.                 if (rChildIndex < m_curIndex &
86.                     heapArr[rChildIndex].CompareTo(heapArr[lChildIndex]) > 0)
87.                     largerIndex = rChildIndex;
88.                 else
89.                     largerIndex = lChildIndex;
91.                 if (item.CompareTo(heapArr[largerIndex]) > 0)
92.                     break;
94.                 heapArr[itemIndex] = heapArr[largerIndex];
95.                 itemIndex = largerIndex;
96.             }
98.             heapArr[itemIndex] = item;
99.         }
101.         private void TrickleUp(int itemIndex)
102.         {
103.             int parentIndex = (itemIndex - 1) / 2;
104.             T item = heapArr[itemIndex];
105.             while (itemIndex>0 && parentIndex >= 0)
106.             {
107.                 if (item.CompareTo(heapArr[parentIndex]) > 0)
108.                 {
109.                     heapArr[itemIndex] = heapArr[parentIndex];
110.                     itemIndex = parentIndex;
112.                     //如果parentIndex=0,则已到根节点，则不用再往上找了
113.                     if(parentIndex>0)
114.                         parentIndex = (parentIndex - 1) / 2;
115.                 }
116.                 else
117.                     break;
118.             }
120.             heapArr[itemIndex] = item;
121.         }
123.         private int FindIndex(T item)
124.         {
125.             int index=0;
126.             while (index < m_curIndex / 2)
127.             {
128.                 int lChildIndex = index * 2 + 1;
129.                 int rChildIndex = lChildIndex + 1;
131.                 if (item.Equals(heapArr[lChildIndex]))
132.                     return lChildIndex;
134.                 if (item.Equals(heapArr[rChildIndex]))
135.                     return rChildIndex;
137.                 if (rChildIndex < m_curIndex &
138.                     item.CompareTo(heapArr[lChildIndex]) < 0)
139.                     index = rChildIndex;
140.                 else
141.                     index = lChildIndex;               
142.             }
144.             return -1;
145.         }
147.         public bool ChangeValue(T item,T newValue)
148.         {
149.            int index = FindIndex(item);
150.            if (index > 0)
151.            {
152.                heapArr[index] = newValue;
153.                if (item.CompareTo(newValue)<0)
154.                    TrickleUp(index);
155.                else
156.                    TrickleDown(index);
158.                return true;
159.            }
161.            return false;
162.         }
165.         public override string ToString()
166.         {
167.             string str = string.Empty;
168.             for (int i = 0; i < m_curIndex; i++)
169.             {
170.                 str += heapArr[i].ToString();
171.                 if (!string.IsNullOrEmpty(str))
172.                     str += "|";
173.             }
174.             return str;
175.         }
178.         堆排序部份//
180.         public static int[] HeapSort(int[] arr)
181.         {
182.             Heap<int> heap = new Heap<int>(arr.Length);
183.             for (int i = 0; i < arr.Length; i++)
184.             {
185.                 heap.heapArr[i] = arr[i];
186.                 heap.m_curIndex++;
187.             }
189.             for (int i = heap.m_curIndex / 2 - 1; i >= 0; i--)
190.             {
191.                 heap.TrickleDown(i);
192.             }
194.             for (int j = heap.m_curIndex - 1; j >= 0; j--)  
195.             {                        
196.                 int temp = heap.Remove();
197.                 heap.heapArr[j] = temp;
198.             }
200.             return heap.heapArr;
201.         } 
202.     }
203. }