forked from RemoteTechnologiesGroup/RemoteTech
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathBinaryHeap.cs
More file actions
123 lines (107 loc) · 3.21 KB
/
Copy pathBinaryHeap.cs
File metadata and controls
123 lines (107 loc) · 3.21 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
using System.Collections;
using System.Collections.Generic;
namespace RemoteTech.SimpleTypes
{
// Sadly there is no way to enforce immutability C#.
// Do not modify sorting order externally! Increase/Decrease().
public class BinaryHeap<T> : IEnumerable<T>
{
public int Count { get { return mData.Count; } }
public int Capacity { get { return mData.Capacity; } }
public bool IsReadOnly { get { return false; } }
private readonly List<T> mData;
private readonly Comparer<T> mComparer;
public BinaryHeap() : this(0) { }
public BinaryHeap(int size)
{
mData = new List<T>(size);
mComparer = Comparer<T>.Default;
}
public void Clear()
{
mData.Clear();
}
public T Peek()
{
return mData[0];
}
public T Remove()
{
T top = mData[0];
mData[0] = mData[mData.Count - 1];
mData.RemoveAt(mData.Count - 1);
if (mData.Count > 0)
{
Decrease(0);
}
return top;
}
public void Add(T item)
{
mData.Add(item);
Increase(mData.Count - 1);
}
public void Increase(int id)
{
T item = mData[id];
int parent_id = (id - 1) >> 1;
// While the item precedes its parent and hasn't reached root.
while ((parent_id >= 0) && (mComparer.Compare(item, mData[parent_id]) < 0))
{
// Propagate the parent downwards.
mData[id] = mData[parent_id];
id = parent_id;
parent_id = (id - 1) >> 1;
}
// Place the item where it belongs.
mData[id] = item;
}
public void Decrease(int id)
{
T item = mData[id];
while (true)
{
int new_id;
int child1 = (id << 1) + 1;
if (child1 > mData.Count - 1)
{
break;
}
int child2 = (id << 1) + 2;
// Check whether to use the left or right node.
if (child2 > mData.Count - 1)
{
new_id = child1;
}
else
{
new_id = mComparer.Compare(mData[child1], mData[child2]) < 0 ? child1 : child2;
}
// Propagate the child upwards if needed
if (mComparer.Compare(item, mData[new_id]) > 0)
{
mData[id] = mData[new_id];
id = new_id;
}
else
{
break;
}
}
// Place the item where it belongs.
mData[id] = item;
}
public int IndexOf(T item)
{
return mData.IndexOf(item);
}
public IEnumerator<T> GetEnumerator()
{
return mData.GetEnumerator();
}
IEnumerator IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
}
}