随笔——封装最小堆和最大堆

#pragma once
#include <vector>
using namespace std;

template <typename T>
class Oheap {
public:
	typedef enum Heap_type
	{
		MAX = 0,
		MIN,
	} HEAP_TYPE_E;

	Oheap(HEAP_TYPE_E type): mType(type){
	};

	Oheap(vector<T> data, HEAP_TYPE_E type):mType(type),mData(data) {
		int len = mData.size() - 1;
		for (int i = len / 2 + 1; i >= 0; --i) {
			adjust(i, len);
		}
	}

	T top() {
		T ret;
		if (!mData.empty())
			ret = mData[0];

		return ret;
	};

	void insert(T val) {
		mData.emplace_back(val);
		int len = mData.size() - 1, cur = len;
		int father = (cur - 1) / 2;
		while (father >= 0 && checkT(mData[cur], mData[father])) {
			EX(cur, father);

			adjust(cur, len);

			cur = father;
			father = (cur - 1) / 2;
		}
	};

	void pop() {
		if (mData.empty())
			return;

		EX(0, mData.size() - 1);

		mData.pop_back();

		adjust(0, mData.size() - 1);
	};
private:
	HEAP_TYPE_E mType;
	vector<T> mData;
	
	bool checkT(T x, T y) {
		if (mType == MAX) {
			return x > y;
		}
		else if (mType == MIN) {
			return x < y;
		}else{
			return false;
		}
	}

	void EX(int i, int j) {
		T tmp = mData[i];
		mData[i] = mData[j];
		mData[j] = tmp;
	}

	void adjust(int cur, int len) {
		int next = cur, left = cur * 2 + 1, right = cur * 2 + 2;

		if (left <= len && checkT(mData[left], mData[next])) {
			next = left;
		}

		if (right <= len && checkT(mData[right], mData[next])) {
			next = right;
		}

		if (next != cur) {
			EX(next, cur);
			adjust(next, len);
		}
	}
};