83 lines
2.3 KiB
C++
83 lines
2.3 KiB
C++
#pragma once
|
|
|
|
#include <array>
|
|
|
|
// examples of how the heap can be used
|
|
//
|
|
// std::array<int, 10> a1 = {73, 6, 57, 88, 60, 42, 83, 72, 48, 85};
|
|
// dlos::Heap<int, a1.size()> h = dlos::Heap<int, a1.size()>(a1);
|
|
// h.maxHeap();
|
|
// dlos::heapsort(h);
|
|
// for (int i = 0; i < a1.size(); i++) {
|
|
// std::cout << h.getValueAt(i) << ", ";
|
|
// if (i == a1.size() - 1) std::cout << std::endl;
|
|
// }
|
|
//
|
|
// std::array<int, 20> a2 = {98, 8, 108, 91, 139, 49, 181, 212, 77, 85, 73, 6, 57, 88, 60, 42, 83, 72, 48, 85};
|
|
// dlos::heapsort(a2);
|
|
// for (int i = 0; i < a2.size(); i++) {
|
|
// std::cout << a2[i] << ", ";
|
|
// if (i == a2.size() - 1) std::cout << std::endl;
|
|
// }
|
|
|
|
namespace dlos {
|
|
|
|
template <typename T, size_t N>
|
|
class Heap {
|
|
public:
|
|
int size = 0;
|
|
|
|
private:
|
|
std::array<T, N> &arr;
|
|
|
|
public:
|
|
Heap(std::array<T, N> &arr) : arr(arr) { size = N; }
|
|
|
|
T getValueAt(int i) const { return arr[i]; }
|
|
|
|
void nodeSwap(int a, int b) {
|
|
T temp = arr[a];
|
|
arr[a] = arr[b];
|
|
arr[b] = temp;
|
|
}
|
|
|
|
void siftDown(int i) {
|
|
int target = indexOfLargerChild(i);
|
|
while (target > 0 && arr[i] < arr[target]) {
|
|
nodeSwap(i, target);
|
|
i = target;
|
|
target = indexOfLargerChild(i);
|
|
};
|
|
}
|
|
|
|
void maxHeap() {
|
|
for (int i = parent(size - 1); i >= 0; i--) {
|
|
siftDown(i);
|
|
}
|
|
}
|
|
|
|
private:
|
|
int parent(int i) { return (i > 0) ? (i - 1) / 2 : -1; }
|
|
|
|
int leftChild(int i) { return i * 2 + 1; }
|
|
|
|
int rightChild(int i) { return i * 2 + 2; }
|
|
|
|
int leftSibling(int i) { return (i % 2 == 0) ? i - 1 : -1; }
|
|
|
|
int rightSibling(int i) { return (i % 2 == 1) ? i + 1 : -1; }
|
|
|
|
int indexOfLargerChild(int i) {
|
|
int larger = leftChild(i);
|
|
if (larger >= size) {
|
|
return -1;
|
|
}
|
|
if (larger + 1 < size && arr[larger] < arr[larger + 1]) {
|
|
larger = larger + 1;
|
|
}
|
|
return larger;
|
|
}
|
|
};
|
|
|
|
}
|