使用C#實現資料結構堆
阿新 • • 發佈：2021-02-03
一、 堆的介紹：
堆是用來排序的，通常是一個可以被看做一棵樹的陣列物件。堆滿足已下特性：
1. 堆中某個節點的值總是不大於或不小於其父節點的值
任意節點的值小於（或大於）它的所有後裔，所以最小元（或最大元）在堆的根節點上（堆序性）。堆有大根堆和小根堆，將根節點最大的堆叫做最大堆或大根堆，根節點最小的堆叫做最小堆或小根堆。
2. 堆總是一棵完全二叉樹
除了最底層，其他層的節點都被元素填滿，且最底層儘可能地從左到右填入。
堆示意圖：
將堆元素從上往下從左到右放進陣列物件中，子父節點索引滿足關係：
parentIndex = （index+1）/ 2 - 1;
childLeftIndex = parentIndex * 2 + 1;
childRightIndex = (parentIndex + 1) * 2;
其中：index為任一節點索引；parentIndex該節點父索引；childLeftIndex該父節點下的子左節點；childRightIndex該父節點下的子右節點。
建立堆的大概思路：
1. 向堆中新增元素：
加到陣列尾處，迴圈比對其父節點值（大根堆和小根堆比對策略不一樣），比對結果的目標索引不是父節點索引則交換子父節點元素，繼續向上比對其父父節點…；直至比對過程中目標索引為父節點索引或達到根節點結束，新堆建立完成。
2. 向堆中取出元素：
取出根節點元素，並將堆末尾元素插入根節點（為了保證堆的完全二叉樹特性），從根部再迴圈向下比對父節點、子左節點、子右節點值，比對結果目標索引不為父節點交換目標索引和父節點的值，向下繼續比對；直至比對過程中目標索引為父節點索引或達到堆尾部結束，新堆建立完成。
二、 程式碼實現：
因為大根堆和小根堆只是比較策略不同，所以整合了兩者，用的時候可以直接設定堆的類別；預設小根堆，預設比較器。實現程式碼如下：
1 public class Heap<T>
2 {
3 private T[] _array;//陣列，存放堆資料
4 private int _count;//堆資料數量
5 private HeapType _typeName;//堆型別
6 private const int _DefaultCapacity = 4;//預設陣列容量/最小容量
7 private const int _ShrinkThreshold = 50;//收縮閾值（百分比）
8 private const int _MinimumGrow = 4;//最小擴容量
9 private const int _GrowFactor = 200; // 陣列擴容百分比,預設2倍
10 private IComparer<T> _comparer;//比較器
11 private Func<T, T, bool> _comparerFunc;//比較函式
12
13
14 //堆資料數量
15 public int Count => _count;
16 //堆型別
17 public HeapType TypeName => _typeName;
18
19
20 public Heap() : this(_DefaultCapacity, HeapType.MinHeap, null) { }
21 public Heap(int capacity) : this(capacity, HeapType.MinHeap, null) { }
22 public Heap(HeapType heapType) : this(_DefaultCapacity, heapType, null) { }
23 public Heap(int capacity, HeapType heapType, IComparer<T> comparer)
24 {
25 Init(capacity, heapType, comparer);
26 }
27 public Heap(IEnumerable<T> collection, HeapType heapType, IComparer<T> comparer)
28 {
29 if (collection == null)
30 throw new IndexOutOfRangeException();
31 Init(collection.Count(), heapType, comparer);
32 using (IEnumerator<T> en = collection.GetEnumerator())//避免T在GC堆中有非託管資源，GC不能釋放，需手動
33 {
34 while (en.MoveNext())
35 Enqueue(en.Current);
36 }
37 }
38 private void Init(int capacity, HeapType heapType, IComparer<T> comparer)
39 {
40 if (capacity < 0)
41 throw new IndexOutOfRangeException();
42 _count = 0;
43 _array = new T[capacity];
44 _comparer = comparer ?? Comparer<T>.Default;
45 _typeName = heapType;
46 switch (heapType)
47 {
48 default:
49 case HeapType.MinHeap:
50 _comparerFunc = (T t1, T t2) => _comparer.Compare(t1, t2) > 0;//目標物件t2小
51 break;
52 case HeapType.MaxHeap:
53 _comparerFunc = (T t1, T t2) => _comparer.Compare(t1, t2) < 0;//目標物件t2大
54 break;
55 }
56 }
57
58
59 public T Dequeue()
60 {
61 if (_count == 0)
62 throw new InvalidOperationException();
63 T result = _array[0];
64 _array[0] = _array[--_count];
65 _array[_count] = default(T);
66
67 if (_array.Length > _DefaultCapacity && _count * 100 <= _array.Length * _ShrinkThreshold)//縮容
68 {
69 int newCapacity = Math.Max(_DefaultCapacity, (int)((long)_array.Length * (long)_ShrinkThreshold / 100));
70 SetCapacity(newCapacity);
71 }
72 AdjustHeap(_array, 0, _count);
73 return result;
74 }
75 public void Enqueue(T item)
76 {
77 if (_count >= _array.Length)//擴容
78 {
79 int newCapacity = Math.Max(_array.Length+_MinimumGrow, (int)((long)_array.Length * (long)_GrowFactor / 100));
80 SetCapacity(newCapacity);
81 }
82
83 _array[_count++] = item;
84 int parentIndex;
85 int targetIndex;
86 int targetCount = _count;
87 while (targetCount > 1)
88 {
89 parentIndex = targetCount / 2 - 1;
90 targetIndex = targetCount - 1;
91 if (!_comparerFunc.Invoke(_array[parentIndex], _array[targetIndex]))
92 break;
93 Swap(_array, parentIndex, targetIndex);
94 targetCount = parentIndex + 1;
95 }
96 }
97 private void AdjustHeap(T[] array, int parentIndex, int count)
98 {
99 if (_count < 2)
100 return;
101 int childLeftIndex = parentIndex * 2 + 1;
102 int childRightIndex = (parentIndex + 1) * 2;
103
104 int targetIndex = parentIndex;
105 if (childLeftIndex < count && _comparerFunc.Invoke(array[parentIndex], array[childLeftIndex]))
106 targetIndex = childLeftIndex;
107 if (childRightIndex < count && _comparerFunc.Invoke(array[targetIndex], array[childRightIndex]))
108 targetIndex = childRightIndex;
109 if (targetIndex != parentIndex)
110 {
111 Swap(_array, parentIndex, targetIndex);
112 AdjustHeap(_array, targetIndex, _count);
113 }
114 }
115
116 private void SetCapacity(int capacity)
117 {
118 T[] newArray = new T[capacity];
119 Array.Copy(_array, newArray, _count);
120 _array = newArray;
121 }
122
123 private void Swap(T[] array, int index1, int index2)
124 {
125 T temp = array[index1];
126 array[index1] = array[index2];
127 array[index2] = temp;
128 }
129
130 public void Clear()
131 {
132 Array.Clear(_array, 0, _count);
133 Init(_DefaultCapacity, HeapType.MinHeap, null);
134 }
135 }
136
137 public enum HeapType { MinHeap, MaxHeap }三、 使用測試：
建一個Person類用來測試，例子中Person比較規則是：先按年齡比較，年齡相同再按身高比較。具體比較大小是由選擇堆的類別進行不同的排序規則：如Person類中小根堆先按年齡小者排序，年齡相同者按身高大者排序；而使用大根堆則相反。兩種比較器寫法，前者直接使用預設比較器；後者需要將比較器注入到堆中。
1 public class Person : IComparable<Person>
2 {
3 public string name { get; set; }
4 public int Age { get; set; }
5
6 public int Height { get; set; }
7 public override string ToString()
8 {
9 return $"我叫{name}，年齡{Age}，身高{Height}";
10 }
11
12 //小根堆：先排年齡小，年齡相同，按身高大的先排；大根堆相反
13 public int CompareTo(Person other)
14 {
15 if (this.Age.CompareTo(other.Age) != 0)
16 return this.Age.CompareTo(other.Age);
17 else if (this.Height.CompareTo(other.Height) != 0)
18 return ~this.Height.CompareTo(other.Height);
19 else
20 return 0;
21 }
22 }
23
24 public class personComparer : IComparer<Person>
25 {
26 //大根堆：先排年齡大，年齡相同，按身高大的先排；小根堆相反
27 public int Compare(Person x, Person y)
28 {
29 if (x.Age.CompareTo(y.Age) != 0)
30 return x.Age.CompareTo(y.Age);
31 else if (x.Height.CompareTo(y.Height) != 0)
32 return x.Height.CompareTo(y.Height);
33 else
34 return 0;
35 }
36 }
View Code
主函式呼叫：
1 static void Main(string[] args)
2 {
3 int[] array = { 3, 5, 8, 3, 7, 1 };
4 Heap<int> heap0 = new Heap<int>(array, HeapType.MaxHeap, null);
5 Console.WriteLine(heap0.TypeName);
6 Console.WriteLine(heap0.Dequeue());
7 Console.WriteLine(heap0.Dequeue());
8 Console.WriteLine(heap0.Dequeue());
9 Console.WriteLine(heap0.Dequeue());
10 int length = heap0.Count;
11 for (int count = 0; count < length; count++)
12 {
13 Console.WriteLine(heap0.Dequeue());
14 }
15
16
17
18 Person person1 = new Person() { Age = 12, Height = 158, name = "張三" };
19 Person person2 = new Person() { Age = 13, Height = 160, name = "李四" };
20 Person person3 = new Person() { Age = 10, Height = 150, name = "王二" };
21 Person person4 = new Person() { Age = 10, Height = 152, name = "麻子" };
22 Person person5 = new Person() { Age = 12, Height = 150, name = "劉五" };
23 List<Person> people = new List<Person>();
24 people.Add(person1);
25 people.Add(person2);
26 people.Add(person3);
27 people.Add(person4);
28 people.Add(person5);
29 Heap<Person> heap2 = new Heap<Person>(people, HeapType.MinHeap, null);
30 Person person6 = new Person() { Age = 9, Height = 145, name = "趙六" };
31 heap2.Enqueue(person6);
32 Console.WriteLine(heap2.TypeName);
33 Console.WriteLine(heap2.Dequeue());
34 Console.WriteLine(heap2.Dequeue());
35 Console.WriteLine(heap2.Dequeue());
36 Console.WriteLine(heap2.Dequeue());
37
38
39 PersonComparer personComparer = new PersonComparer();
40 Heap<Person> heap3 = new Heap<Person>(1,HeapType.MaxHeap,personComparer);
41 heap3.Enqueue(person1);
42 heap3.Enqueue(person2);
43 heap3.Enqueue(person3);
44 heap3.Enqueue(person4);
45 heap3.Enqueue(person5);
46 heap3.Enqueue(person6);
47 Console.WriteLine(heap3.TypeName);
48 Console.WriteLine(heap3.Dequeue());
49 Console.WriteLine(heap3.Dequeue());
50 Console.WriteLine(heap3.Dequeue());
51 Console.WriteLine(heap3.Dequeue());
52
53
54
55 Console.ReadKey();
56 }
57
View Code
輸出結果：
參考：
https://blog.csdn.net/qq826364410/article/details/79770791
https://docs.microsoft.com/zh-cn/dotnet/api/system.collections.generic.comparer-1?view=net-5.0
&n