C++ STL 进阶:手写 priority_ueue 与仿函数机制详解

template<class T, class Container = vector<T>, class Compare = Less<T>>
//Container，Compare 是我们对库里面的结构进行了显示构造便于我们理解底层结构
class priority_queue {
public:
    priority_queue() = default;  // 编译器生成默认构造
private:
    Container _con;               // 底层容器
};

template<class InputIterator>
priority_queue(InputIterator first, InputIterator last)
	:_con(first, last)
{
	//给一个迭代器区间构造优先队列的底层是堆结构
	//向下调整建队构造
	for (int i = (_con.size() - 1 - 1) / 2; i >= 0; i--) {
		adjust_down(i);
	}
}

void adjust_down(size_t parent) {
	Compare com;
	size_t child = parent * 2 + 1;
	while (child < _con.size()) {
		if (child + 1 < _con.size() && com(_con[child], _con[child + 1])) {
			child++;
		}
		// 如果 父节点优先级 < 孩子节点优先级，则交换
		// 在大堆中：parent < child -> com(parent, child) 为 true -> 交换
		// 在小堆中：parent > child -> com(parent, child) 为 true -> 交换
		if (com(_con[parent], _con[child])) {
			swap(_con[parent], _con[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else {
			break;
		}
	}
}

void push(const T& x) {
    _con.push_back(x);
    adjust_up(_con.size() - 1);
}

void adjust_up(size_t child) {
	Compare com;
	size_t parent = (child - 1) / 2;
	while (child > 0) {
		//if (_con[parent] < _con[child])
		if(com(_con[parent],_con[child])){
			swap(_con[parent], _con[child]);//调用的库里面的函数
			child = parent;
			parent = (child - 1) / 2;
		}
		else {
			break;
		}
	}
}

void pop() {
	assert(!empty());
    std::swap(_con[0], _con[_con.size() - 1]);
    _con.pop_back();
    adjust_down(0);
}

const T& top() const { return _con[0]; }
bool empty() const { return _con.empty(); }
size_t size() const { return _con.size(); }

template<class T, class Container = vector<T>, class Compare = Less<T>>
//Container让我们可以很轻松的更改priority_queue的底层存储逻辑
//这里只是给一个缺省值我们可以显示给的
class priority_queue {
    Container _con;
};

template<class T>
class Less {
public:
	bool operator()(const T& x, const T& y) {
		return x < y;
	}
};
template<class T>
class Greater {
public:
	bool operator()(const T& x, const T& y) {
		return x > y;
	}
};

int main() {
//默认使用 Less → 大堆
	ZL::priority_queue<int> pq1;
//显示指定Greater->建大堆
	ZL::priority_queue<int, vector<int>, Greater<int>> pq2;
	pq1.push(100);
	pq1.push(5);
	pq1.push(200);
	pq1.push(10);
	while (!pq1.empty()) {
		cout << pq1.top() << " ";
		pq1.pop();
	}
	return 0;
}

template<class T, class Compare>
void BubbleSort(T* a, int n, Compare com) {
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n - i - 1; ++j) {
            if (com(a[j + 1], a[j]))   // 比较规则由仿函数决定
                swap(a[j], a[j + 1]);
        }
    }
}
int main() {
	int a[] = { 1,3,4,5,6,3,2 };
	//让类可以像函数一样调用
	BubbleSort(a, 7, Less<int>());//排升序
	BubbleSort(a, 7, Greater<int>());//排降序
	for (auto ch : a) {
		cout << ch;//自动迭代不用++
	}
	cout << endl;
}

struct OP1 {
	bool operator()(int x) {
		return x % 2 == 0;
	}
};
int main() {
	int a[] = { 1,3,2,9,1,3,4,5 };
	//查找第一个偶数
	auto it = find_if(a, a + 7, OP1());
	cout << *it << endl
	return 0;
}

struct OP2 {
		int operator()(int x) {
			if (x % 2 == 0)
				return x * 2;
			else
				return x;
		}

};
int main() {
	//transform 是 C++ 标准库中的一个算法，用于对容器中的每个元素执行某种操作，并将结果存储到另一个位置。
	//它属于 <algorithm> 头文件。
	transform(v.begin(), v.end(), v.begin(), OP2());
	for (auto& e : v) {
		cout << e << " ";
	}
	cout << endl;
	return 0;
}

//struct PDateLess
//{
//	bool operator()(const Date* p1, const Date* p2)//仿函数
//	{
//	return *p1 < *p2;//这里能直接对存储地址解引用对比出谁的日期大是因为
//在日期结构体中对<运算符进行了重载
//	}
int main() {
	ZL::priority_queue<Date*, vector<Date*>, PDateLess> q1;
	q1.push(new Date(2018, 10, 29));
	q1.push(new Date(2018, 10, 28));
	q1.push(new Date(2018, 10, 30));
	while (!q1.empty()) {
		cout << *q1.top() << " ";
		q1.pop();
	}
	cout << endl;
	return 0;
}