sort, priority_queue, set, map排序顺序

#include <cstdlib>
#include <iostream>
#include <queue>
#include <set>
#include <map>
#include <algorithm>


using namespace std;


int myints[]= {1,3,5,2,4,6};


class Node{
public:
Node(int x):m_nX(x){}

int getX() const{ 
return m_nX;
}

bool operator<(const Node& other) const{
return m_nX < other.getX();
}

bool operator>(const Node& other) const{
return m_nX > other.getX();
}

private:
int m_nX;
};


vector<Node> nodeVec;


void print(const vector<int>& vec){
for(int i=0;i<vec.size();i++)
cout<<vec[i]<<" ";
cout<<endl;
}


void print(const vector<Node>& nodeVec){
for(int i=0;i<nodeVec.size();i++)
cout<<nodeVec[i].getX()<<" ";
cout<<endl;
}


void testSortInt(){
vector<int> vec(myints, myints+6);
sort(vec.begin(),vec.end(),less<int>());
print(vec);
sort(vec.begin(),vec.end(),greater<int>());
print(vec);
}


void testSortWithNode(){
sort(nodeVec.begin(),nodeVec.end(),less<Node>());
print(nodeVec);
sort(nodeVec.begin(),nodeVec.end(),greater<Node>());
print(nodeVec);
}


void initNodeVec(){
Node a(1);
Node b(3);
Node c(5);
Node d(2);
Node e(4);
Node f(6);

nodeVec.push_back(a);
nodeVec.push_back(b);
nodeVec.push_back(c);
nodeVec.push_back(d);
nodeVec.push_back(e);
nodeVec.push_back(f);
}


void print(priority_queue<int, vector<int>, less<int> >& queue){
while(!queue.empty()){
cout<<queue.top()<<" ";
queue.pop();
}
cout<<endl;
}




void print(priority_queue<int, vector<int>, greater<int> >& queue){
while(!queue.empty()){
cout<<queue.top()<<" ";
queue.pop();
}
cout<<endl;
}


void testPriorityQueueWithInt(){
priority_queue<int, vector<int>, less<int> > lessQueue(myints,myints+6);
print(lessQueue);
priority_queue<int, vector<int>, greater<int> > greaterQueue(myints,myints+6);
print(greaterQueue);
}


void print(priority_queue<Node, vector<Node>, less<Node> >& queue){
while(!queue.empty()){
cout<<queue.top().getX()<<" ";
queue.pop();
}
cout<<endl;
}


void print(priority_queue<Node, vector<Node>, greater<Node> >& queue){
while(!queue.empty()){
cout<<queue.top().getX()<<" ";
queue.pop();
}
cout<<endl;
}


void testPriorityQueueWithNode(){
priority_queue<Node, vector<Node>, less<Node> > lessQueue(nodeVec.begin(),nodeVec.end());
print(lessQueue);
priority_queue<Node, vector<Node>, greater<Node> > greaterQueue(nodeVec.begin(),nodeVec.end());
print(greaterQueue);
}


void testSetWithInt(){
set<int, less<int> > lessSet(myints,myints+6);
set<int, less<int> >::iterator iter1;
for(iter1=lessSet.begin();iter1!=lessSet.end();iter1++)
cout<<*iter1<<" ";
cout<<endl;

set<int, greater<int> > greaterSet(myints,myints+6);
set<int, greater<int> >::iterator iter2;
for(iter2=greaterSet.begin();iter2!=greaterSet.end();iter2++)
cout<<*iter2<<" ";
cout<<endl;
}


void testSetWithNode(){
set<Node, less<Node> > lessSet(nodeVec.begin(),nodeVec.end());
set<Node, less<Node> >::iterator iter1;
for(iter1=lessSet.begin();iter1!=lessSet.end();iter1++)
cout<<iter1->getX()<<" ";
cout<<endl;

set<Node, greater<Node> > greaterSet(nodeVec.begin(),nodeVec.end());
set<Node, greater<Node> >::iterator iter2;
for(iter2=greaterSet.begin();iter2!=greaterSet.end();iter2++)
cout<<iter2->getX()<<" ";
cout<<endl;
}


void testMapWithInt(){
map<int, int, less<int> > lessMap;
for(int i=0;i<6;i++)
lessMap[myints[i]]=myints[i];
map<int, int, less<int> >::iterator iter1;
for(iter1=lessMap.begin();iter1!=lessMap.end();iter1++)
cout<<iter1->first<<" "<<iter1->second<<"\t";
cout<<endl;

map<int, int, greater<int> > greaterMap;
for(int i=0;i<6;i++)
greaterMap[myints[i]]=myints[i];
map<int, int, greater<int> >::iterator iter2;
for(iter2=greaterMap.begin();iter2!=greaterMap.end();iter2++)
cout<<iter2->first<<" "<<iter2->second<<"\t";
cout<<endl;
}


void testMapWithNode(){
map<Node, Node, less<Node> > lessMap;
for(int i=0;i<6;i++)
lessMap.insert(pair<Node,Node>(nodeVec[i],nodeVec[i]));
map<Node, Node, less<Node> >::iterator iter1;
for(iter1=lessMap.begin();iter1!=lessMap.end();iter1++)
cout<<iter1->first.getX()<<" "<<iter1->second.getX()<<"\t";
cout<<endl;

map<Node, Node, greater<Node> > greaterMap;
for(int i=0;i<6;i++)
greaterMap.insert(pair<Node,Node>(nodeVec[i],nodeVec[i]));
map<Node, Node, greater<Node> >::iterator iter2;
for(iter2=greaterMap.begin();iter2!=greaterMap.end();iter2++)
cout<<iter2->first.getX()<<" "<<iter2->second.getX()<<"\t";
cout<<endl;
}


int main()
{
cout<<"sort int"<<endl;
testSortInt();
cout<<"sort node"<<endl;
nodeVec.clear();
initNodeVec();
testSortWithNode();
cout<<endl;

cout<<"priority int"<<endl;
testPriorityQueueWithInt();
cout<<"priority node"<<endl;
nodeVec.clear();
initNodeVec();
testPriorityQueueWithNode();
cout<<endl;


cout<<"set int"<<endl;
testSetWithInt();
cout<<"set node"<<endl;
nodeVec.clear();
initNodeVec();
testSetWithNode();
cout<<endl;


cout<<"map int"<<endl;
testMapWithInt();
cout<<"map node"<<endl;
nodeVec.clear();
initNodeVec();
testMapWithNode();
cout<<endl;
    system("PAUSE");
    return EXIT_SUCCESS;
}