STL: set 和 priority_queue

优先级队列默认是底层为vector实现的heap

set 基于平衡红黑树

两者插入元素时间复杂度都是O(log(n))

使用默认的greater 得到的结果不同

#include <iostream>
#include <queue>
#include <vector>
#include <set>
int main(){
using namespace std;
vector<int>vec{1,3,5,78,4,23};
set<int, greater<int> > myset;
priority_queue<int, vector<int>, greater<int> >myque;

for(int i=0; i<6; ++i){
myset.insert(vec[i]);
myque.push(vec[i]);
}

for(set<int, greater<int> >::iterator it=myset.begin() ; it!=myset.end(); ++it){
cout << *it <<" ";
}//从大到小：78 23 5 4 3 1
cout << endl;

for(int i=0; i<6; ++i){
cout << myque.top() <<" ";
myque.pop();
}// 小顶堆： 1 3 4 5 23 78

getchar();
getchar();
return 0;

}

优先级队列、sort、qsort 与 重载、自定义cmp函数的关系

#include <iostream>
#include <string>
#include <algorithm>   // for sort()
#include <queue>       // for priority_queue
#include <map>
#include <set>

using namespace std;

/*************************************************************************/
// 重载 < 运算
class student_cmp{
private:
string name;
int id;
public:
student_cmp(string name = "default", int id = 0) :
name(name) ,
id(id)
{
;
}
inline
string get_name(){
return name;
}

inline
int get_id(){
return id;
}
// priority_queue: id 大的优先级低， 从小到大排列  == greater<int>
// vector sort 中 从大到小排
bool operator < (const student_cmp &s)const{
return this->id > s.id;
}

friend ostream &operator << (ostream & os, const student_cmp &s){
os << s.name << ": " << s.id << endl;
return os;
}

};

/**********************************************************************/
// 没有重载< 运算， 使用自定义cmp函数
class student_nocmp{
private:
string name;
int id;

public:
student_nocmp(string name = "default", int id = 0) :
name(name),
id(id)
{
;
}

inline
string get_name(){
return name;
}

inline
int get_id(){
return id;
}

friend ostream &operator << (ostream & os, const student_nocmp &s){
os << s.name << ": " << s.id << endl;
return os;
}

};
// 优先级队列：从小到大排列
class mynocmp{
public:
bool operator ()(student_nocmp &a, student_nocmp &b)
{
return a.get_id() > b.get_id();
}
};

// for sort  必须返回bool类型
// vector: 从大到小排列
bool sort_nocmp (student_nocmp &a, student_nocmp &b)
{
return a.get_id() > b.get_id();
}

// for qsort  必须返回int类型, 参数是指针类型
// array: 从大到小排列
// 如果返回值小于0，则qsort 就得知第一个元素应该在前，如果返回值大于0，则第一个元素应该在后。
// 相减顺序与参数一致就是从小到大排序
int qsort_nocmp(const void *a, const void *b)
{
student_nocmp * p1, *p2;
p1 = (student_nocmp *)a;
p2 = (student_nocmp *)b;

return p1->get_id() - p2->get_id();
}
/**********************************************************************/
int main()
{
cout << "overload operator < in priority_queue..." << endl;

priority_queue<student_cmp> stuQueue;

stuQueue.push(student_cmp());
stuQueue.push(student_cmp("zhangsan", 23));
stuQueue.push(student_cmp("lisi", 14));
stuQueue.push(student_cmp("laowang", 36));
stuQueue.push(student_cmp("xiaoming", 28));

while (!stuQueue.empty()){
cout << stuQueue.top();
stuQueue.pop();
}
cout << endl;

cout << "without overload operator < in priority_queue..." << endl;
priority_queue<student_nocmp, vector<student_nocmp>, mynocmp> stunoQueue;

stunoQueue.push(student_nocmp());
stunoQueue.push(student_nocmp("zhangsan", 23));
stunoQueue.push(student_nocmp("lisi", 14));
stunoQueue.push(student_nocmp("laowang", 36));
stunoQueue.push(student_nocmp("xiaoming", 28));

while (!stunoQueue.empty()){
cout << stunoQueue.top();
stunoQueue.pop();
}
cout << endl;

/******sort******************/
cout << "overload operator < in vector..." << endl;
vector<student_cmp> veccmp;
veccmp.push_back(student_cmp());
veccmp.push_back(student_cmp("zhangsan", 23));
veccmp.push_back(student_cmp("lisi", 14));
veccmp.push_back(student_cmp("laowang", 36));
veccmp.push_back(student_cmp("xiaoming", 28));

sort(veccmp.begin(), veccmp.end());
for (vector<student_cmp>::iterator it = veccmp.begin(); it != veccmp.end(); ++it)
cout << *it;
cout << endl;

cout << "without overload operator < in vector..." << endl;
vector<student_nocmp> vecnocmp;
vecnocmp.push_back(student_nocmp());
vecnocmp.push_back(student_nocmp("zhangsan", 23));
vecnocmp.push_back(student_nocmp("lisi", 14));
vecnocmp.push_back(student_nocmp("laowang", 36));
vecnocmp.push_back(student_nocmp("xiaoming", 28));

sort(vecnocmp.begin(), vecnocmp.end(), &sort_nocmp);
for (vector<student_nocmp>::iterator it = vecnocmp.begin(); it != vecnocmp.end(); ++it)
cout << *it;
cout << endl;

cout << "without overload operator < in array..." << endl;
student_nocmp arrnocmp[5] = { student_nocmp(),
student_nocmp("zhangsan", 23),
student_nocmp("lisi", 14),
student_nocmp("laowang", 36),
student_nocmp("xiaoming", 28)
};

qsort(arrnocmp, 5, sizeof(student_nocmp), &qsort_nocmp);
for (int i = 0; i < 5; ++i)
cout << arrnocmp[i];
getchar();

return 0;
}

结果：



结论：

1. 优先级队列定义的< 运算 规定低优先级， 返回为ture的条件说明优先级低；

2. 类外部定义的cmp相当于实现重载operator <;

3. 由于qsort返回值是int型， /如果返回值小于0，则qsort 就得知第一个元素应该在前，如果返回值大于0，则第一个元素应该在后。即，相减顺序与参数一致就是从小到大排序；

4. sort 的效率比qsort高， 还是使用sort 就好了；