Done heap sort template.

Author: zh-plus

template/heap_sort.cpp

@@ -8,44 +8,109 @@
 #include "algorithm"
 #include "string"
 #include "sstream"
-#include <iterator>
+#include "iterator"
+#include "stack"
+#include "tuple"
 
 #define BOOST_IO std::ios_base::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr);
 #define ALTER_IN(filename) std::fstream f_in(filename); std::cin.rdbuf(f_in.rdbuf());
 
 using namespace std;
 
-template<typename C>
-class MaxHeap{
+class MaxHeap {
 public:
-    C *container;
+    vector<int> container;
+    int heap_size;
 
-    explicit MaxHeap(C container) {
-        this->container = new C(container);
+    explicit MaxHeap(const vector<int> &container) : container(container.size() + 1), heap_size(container.size()) {
+        this->container[0] = -1;
+        copy_n(begin(container), container.size(), begin(this->container) + 1);
+
+        // O(n) Heap Building.
+        for (int i = (heap_size >> 1); i >= 1; --i) {
+            max_heapify(i);
+        }
+    }
+
+    vector<int> sort() {
+        for (int i = heap_size; i >= 2; --i) {
+            swap(container[1], container[heap_size]);
+
+            // Reduce heap size, then heapify
+            --heap_size;
+            max_heapify(1);
+        }
+
+        return vector<int>(begin(container) + 1, end(container));
     }
 
-    void max_heapify(const int i){
+    void max_heapify(const int i) {
         int l = left(i);
         int r = right(i);
         int largest = i;
 
-        if (l <= this->container->length() && this->container[l] > this->container[i]) {
+        if (l <= heap_size && container[l] > container[i]) {
             largest = l;
         }
 
-        if (r <= this->container->length() && )
+        if (r <= heap_size && container[r] > container[largest]) {
+            largest = r;
+        }
+
+        if (largest != i) {
+            swap(container[i], container[largest]);
+            max_heapify(largest);
+        }
+    }
+
+    void max_heapify__loop(const int i) {
+        stack<int> s;
+        s.push(i);
+
+        int l, r, largest, current;
+
+        while (!s.empty()) {
+            current = s.top();
+            s.pop();
+
+            tie(l, r) = get_lr(i);
+            largest = current;
+
+            if (l < heap_size && container[l] > container[current]) {
+                largest = l;
+            }
+
+            if (r < heap_size && container[r] > container[largest]) {
+                largest = r;
+            }
+
+            if (largest != i) {
+                swap(container[current], container[largest]);
+                s.push(largest);
+            }
+        }
     }
 
+    int parent(const int i) { return i >> 1; }
 
+    int left(const int i) { return i << 1; }
 
-    int parent(const int i){ return i << 1; }
+    int right(const int i) { return (i << 1) + 1; }
 
-    int left(const int i) { return i >> 1; }
+    tuple<int, int> get_lr(const int i) {
+        return make_tuple(left(i), right(i));
+    }
+};
 
-    int right(const int i) { return (i >> 1) + 1; }
+class Test {
+public:
+    explicit Test(vector<int> vec) {
+        copy(begin(vec), end(vec), ostream_iterator<int>(cout, " "));
+        cout << endl;
+    }
 };
 
-int main(){
+int main() {
     BOOST_IO
     ALTER_IN("in.txt")
 
@@ -57,6 +122,8 @@ int main(){
 
     for (auto &row: matrix) {
         copy_n(istream_iterator<int>(cin), N, back_inserter(row));
+        MaxHeap heap(row);
+        row = heap.sort();
     }
 
     for (auto &row: matrix) {