void minHeap(int arr[], int size)
{
int i, left, right, tmp, val;
for(i = size / 2; i >= 1; i--)
{
/*taking 1 as the start index
if parent node = i
so left child = 2i and
right child = 2i+1*/
tmp = i;
left = (2 * i);
right = (2 * i) + 1;
if(left < size && arr[left] < arr[tmp])
{
tmp = left;
}
if(right < size && arr[right] < arr[tmp])
{
tmp = right;
}
if(tmp != i)
{
val = arr[i];
arr[i] = arr[tmp];
arr[tmp] = val;
minHeap(arr, size);
}
}
}
vector<double> medianSlidingWindow(vector<int>& nums, int k) {
vector<double> result;
if (k == 0 || nums.size() < k) return result;
Heap minHeap(true), maxHeap(false);
int i = 0;
for (; i != k; ++i) {
if (maxHeap.empty() || nums[i] > maxHeap.top().val) minHeap.insert(HeapNode(i, nums[i]));
else maxHeap.insert(HeapNode(i, nums[i]));
if (maxHeap.sIze() < minHeap.sIze()) {
maxHeap.insert(minHeap.top());
minHeap.pop();
} else if (maxHeap.sIze() > minHeap.sIze() + 1) {
minHeap.insert(maxHeap.top());
maxHeap.pop();
}
}
for (; i != nums.size(); ++i) {
if (k & 1) result.push_back(maxHeap.top().val);
else result.push_back(((double)maxHeap.top().val + minHeap.top().val) / 2.0);
maxHeap.remove(i - k); minHeap.remove(i - k);
if (maxHeap.empty() || nums[i] > maxHeap.top().val) minHeap.insert(HeapNode(i, nums[i]));
else maxHeap.insert(HeapNode(i, nums[i]));
if (maxHeap.sIze() < minHeap.sIze()) {
maxHeap.insert(minHeap.top());
minHeap.pop();
} else if (maxHeap.sIze() > minHeap.sIze() + 1) {
minHeap.insert(maxHeap.top());
maxHeap.pop();
}
}
if (k & 1) result.push_back(maxHeap.top().val);
else result.push_back(((double)maxHeap.top().val + minHeap.top().val) / 2.0);
return result;
}
void heapSort(int array[], int size) {
int heapSize = size + 1, i;
int heap[heapSize];
heap[0]=0;
for (i = 0; i < size; i++) {
heap[i + 1] = array[i];
}
for (i = heapSize / 2; i >= 1; i--) {
minHeap(heap, heapSize, i);
}
showArray(heap,heapSize);
while (heapSize > 1) {
swap(&heap[1], &heap[heapSize-1]);
minHeap(heap, heapSize, 1);
heapSize--;
}
for (i=0-1;i<size;i++){
array[i]=heap[size-i];
}
}
int heapSort(int a[], unsigned int size)
{
int i =0;
minHeap(a, size);
printArray(a, size, "MinHeap: ");
for(i = size -1; i > 0; i--)
{
swap(&a[i], &a[0]);
MinHeapFixdown(a, 0, i-1);
printArray(a, i, "heapSort ");
}
return 0;
}
void TestHeap(){
int arr[]={1,2,3,4,5,6,7,8,9};
Heap<int,greater<int>> heap(arr,sizeof(arr)/sizeof(*arr));
heap.Print();
heap.Pop();
heap.Print();
heap.Push(8);
heap.Print();
Heap<int> minHeap(arr,sizeof(arr)/sizeof(*arr));
minHeap.Print();
minHeap.Pop();
minHeap.Print();
minHeap.Push(1);
minHeap.Print();
}
vector<pair<int, int>> kSmallestPairs(vector<int>& nums1, vector<int>& nums2, int k) {
int len1 = nums1.size(), len2 = nums2.size();
vector<pair<int, int>> res;
if (len1 == 0 || len2 == 0) return res;
auto cmp = [&](pair<int, int> a, pair<int, int> b) { return nums1[a.first] + nums2[a.second] > nums1[b.first] + nums2[b.second];};
priority_queue<pair<int, int>, vector<pair<int, int>>, decltype(cmp)> minHeap(cmp);
minHeap.emplace(0, 0);
while (k-- && !minHeap.empty()) {
pair<int, int> index = minHeap.top();
minHeap.pop();
res.emplace_back(nums1[index.first], nums2[index.second]);
if (index.first + 1 < len1) minHeap.emplace(index.first+1, index.second);
if (index.first == 0 && index.second + 1 < len2) minHeap.emplace(index.first, index.second+1);
}
return res;
}
void heapSort(int arr[], int size)
{
int i, j, tmp, sorted[size];
sorted[0] = -1;
for(i = size , j = 1; i >= 1; i--, j++)
{
minHeap(arr, i);
sorted[j] = arr[1];
arr[1] = arr[i - 1];
}
for(i = 0; i < size; i++)
{
arr[i] = sorted[i];
}
}
int minHeap(int a[], int index, int k){
int minIndex = index;
int leftIndex = index * 2;
int rightIndex = index * 2 + 1;
if(leftIndex < k && a[leftIndex] < a[minIndex]){
minIndex = leftIndex;
}
if(rightIndex < k && a[rightIndex] < a[minIndex]){
minIndex = rightIndex;
}
if(minIndex != index){
int temp = a[minIndex];
a[minIndex] = a[index];
a[index] = temp;
minHeap(a, minIndex, k);
}
return 0;
}
int buildHeap(int a[], int k){
for(int i = k; i >= 1; i--){
minHeap(a, i, k);
}
}
