编程练习——堆heap

 因为vs2005中c++的Heap构造有些问题，所以才重写了heap类。

不知道vs2008中这个是不是个bug。

 

1. /* created by chico chen
2. *  date 2008/10/25
3. */
4. template<class T,class Cmp>
5. class Heap
6. {
7. private:
8.     vector<T> heap;
9.     void ShiftDown(int index)
10.     {
11.         while(!IsLeaf(index))
12.         {
13.             int l = Lchild(index);
14.             int r = Rchild(index);
15.             if(r != -1)
16.             {
17.                 if(Cmp::Up(heap[r],heap[l]))
18.                 {
19.                     // put the up node to the left
20.                     swap(heap[l],heap[r]);
21.                 }
22.             }
23.             if(Cmp::Up(heap[l],heap[index]))
24.             {
25.                 // up the left child 
26.                 swap(heap[l],heap[index]);
27.                 index = l;
28.             }
29.             else
30.             {
31.                 break;
32.             }
33.         }
35.     }
36.     void ShiftUp(int index)
37.     {
38.         int parent = -1;
39.         while(index != 0)
40.         {
41.             parent = Parent(index);
42.             if(Cmp::Up(heap[index],heap[parent]))
43.             {
44.                 swap(heap[index],heap[parent]);
45.                 index = parent;
46.             }
47.             else
48.             {
49.                 break;
50.             }
51.         }
52.         
53.     }
54.     void ReHeapAll()
55.     {
56.         for(int i=Parent(heap.size()-1); i>= 0; i--)
57.         {
58.             ShiftDown(i);
59.         }
60.     }
61.     void ReHeapOne(int index)
62.     // set one prior and re-position the index node
63.     {
64.         T data = heap[index];
65.         ShiftDown(index);
66.         if(Cmp::Eq(data,heap[index]))
67.         {
68.             ShiftUp(index);
69.         }
70.     }
71.     int Parent(int index)
72.     // parent node of the index node
73.     {
74.         return (index-1)/2;
75.     }
76.     int Lchild(int index)
77.     // Left child of the index node
78.     {
79.         if(!IsLeaf(index))
80.             return index*2+1;
81.         return -1;
82.     }
83.     int Rchild(int index)
84.     // Right child of the index node
85.     {
86.         if(!IsLeaf(index))
87.         {
88.             int r= index*2+2;
89.             if(r<heap.size())
90.                 return r;
91.         }
92.         return -1;
93.     }
95.     int IsLeaf(int index)
96.     {
97.         assert(index < heap.size());
98.         if(heap.size() == 1)
99.             return true;
100.         int lastNode = Parent(heap.size()-1);
101.         return lastNode < index;
102.     }
104.     int FindData(T& data)
105.     {
106.         int len = heap.size();
107.         for(int i = 0; i < len; i++)
108.         {
109.             if(Cmp::Eq(data,heap[i]))
110.             {
111.                 return i;
112.             }
113.         }
114.         return -1;// can not find the data
115.     }
117.     void printTree(int index,int count)
118.     {
119.         if(index < heap.size() && index >=0)
120.         {
121.             
122.             printTree(Rchild(index),count+4);
123.             for(int i = 0; i < count; i++)
124.             {
125.                 cout << " ";
126.             }
127.             cout <<heap[index]<<endl;
128.             printTree(Lchild(index),count+4);
129.         }
130.     }
131. public:
132.     Heap()
133.     {
134.         heap = vector<T>();
135.     }
136.     ~Heap()
137.     {
138.         // heap destroyed
139.     }
140.     bool IsEmpty()
141.     {
142.         return heap.size() == 0;
143.     }
147.     void Insert(T& data)
148.     {
149.         heap.push_back(data);
150.         ShiftUp(heap.size()-1);
151.     }
152.     void Delete(int index)
153.     {
154.         int last = heap.size()-1;
155.         if(index>=0 && index <= last)
156.         {
157.             
158.             swap(heap[index],heap[last]);
159.             heap.pop_back();
160.             ReHeapOne(index);
161.         }
162.     }
163.     void Delete(T& data)
164.     {
165.         int index = FindData(data);
166.         if(index != -1)
167.             Delete(index);
168.     }
171.     void RemoveTop()
172.     {
174.         if(!IsEmpty()&&heap.size()>1)
175.         {   
176.             swap(heap[0],heap[heap.size()-1]);
177.             heap.pop_back();
178.             ShiftDown(0);
179.         }
180.         else if(heap.size() == 1)
181.         {
182.             heap.pop_back();
183.         }
184.         
185.     }
186.     T& Top()
187.     {
188.         return heap[0];
189.     }
191.     void Print()
192.     {
193.         printTree(0,1);
194.     }
196.     
198. };