STL容器及排序问题

deque(双端队列)底层是一是二维数组，功能上和vector相似，提供了'[]'和'='运算符重载函数
list(列表)的底层是一个双向链表，提供了前插，尾插，前删，尾删，提供了 '='的运算符重载函数

vector(向量)的底层是一个数组，有指针失效的情况。可以通过erase和迭代器来删除其中任何一个元素可以通过insert和迭代器将数组或者某个数组插入到指定位置。提供了 '[]' '='运算符重载函数

关联容器：支持高效的关键字查找和访问
1>map(映射),RBTree,经过排序的二元组集合，每个元素有键和值组成，键值唯一性提供 <键,值>对的存储,键对应的是first,值对应的是second，提供了‘=’和'[]'运算符重载函数
2>hash_map的底层数据结构哈希表。hash_map提供了'[]', '=', '()'运算符重载函数
3>multimap(多重映射)，RBTree，键值有重复性
4>unordered_map 哈希函数组织

1>set(集合),RBTree,包含了经过排了序的数据，值具有唯一性，提供了‘=’运算符重载函数。
2>hash_set是以hash_table作为底层的数据结构。提供了'[]'和'='运算符重载函数
3>multiset(多重集),RBTree,和集合set相似，键值有重复性

4>unordered_set

STL采用自己alocator分配内存，以内存池的方式来管理这些内存，会大大减少内存碎片从而会提升系统的整体性能。

hash_set是进行存储一些散列值，而hash_map存储的是键值对，根据键找值。hash_set和set进行比较，hash_set没有排序，不能得出名次，而set是进过排序的。红黑树的形成和哈希函数进行内存使用和插入效率问题比较。

使用set能很快判断某个值是否存在

#include <iostream>
using namespace std;
#include <string>
#include <map>
#include <set>
//计算每个单词出现的次数
int main()
{
	set<string> ex;
	string tt[] = {"nihao", "zhong", "guo"};
	ex.insert(tt, tt+3);
	map<string, int> mp;
	string st;
	mp["tt"] = 0;
	while(getline(cin, st), st != "#")//getline中cin拿到数据，string中
	{
		if(ex.find(st) == ex.end())//判断该值是否在set中出现
		{
			++mp[st];//如果是想要统计的就得到其计数器进行计数
		}
	}
	cout<<mp["tt"];
	return 0;
}

//set中不能存储相同值的值，而在multiset中可以存储，两者底层都是红黑树,两者底层使用的相同的红黑树，但是插入函数有所不同，set的层的插入函数是unique_insert,而multiset底层的插入函数是equel_insert
//set中插入的是简单的插入,判断是否相等，如果相等就不插入。而在multiset中，如果是自定义结构体只会依据定义的判断函数进行比较，如果相等就将值向其右边插入，所以从大到小打印出来的顺序是关键值相等的先插入先打印
#include <set>
struct node
{
	int x;
	int y;
	node(int z, int t):x(z), y(t){}
};
class compared
{
public:
	int operator()(node tx, node y){	return tx.x-y.x;}
};

int main()
{
	multiset<node, compared> set;
	set.insert(node(2,8));
	set.insert(node(2,5));
	multiset<node, compared>::iterator it = set.begin();

	for ( ; it != set.end(); ++it)
	{
		cout<<"x:"<<it->x<<"  y:"<<it->y<<endl;	
	}
	return 0;
}

/使用库函数进行排序//

class Type  
{  
public:  
    int a;  
    Type(int x, int y):a(x),b(y){}  
    Type():a(0),b(0){}  
    int b;  
};  
使用qsort对自定义类型进行排序，需要提供一个比较函数，传递给qsort的函数指针参数  
int compared(const void*x, const void *y)  
{  
    return ((Type*)x)->a - ((Type*)y)->a;  
}  
int main()  
{  
    int num = 12;  
    srand(34);  
    Type *tt = new Type[num];  
    for (int i=0; i<num; ++i)  
    {  
        new(tt+i) Type(rand()%100, rand()%100);  
    }  
    qsort(tt, num, sizeof(Type), compared);  
    for (int i=0; i<num; ++i)  
    {  
        cout<<tt[i].a<<" "<<tt[i].b<<endl;  
    }  
    return 0;  
}  
///set底层是红黑树，本可以排序，但是自定义类型的排序需要提供一个函数对象，实现比较大小功能  
  
class compType  
{  
public:  
    int operator()(Type x, Type y)  
    {  
        return x.a < y.a;  
    }  
};  
int main()  
{  
    typedef set<Type, compType> settype;  
    settype st;  
    st.insert(Type(35, 2));  
    st.insert(Type(32, 4));  
    st.insert(Type(50, 5));  
    settype::iterator it = st.begin();  
    for ( ; it!=st.end(); ++it)  
    {  
        cout<<it->a<<endl;  
    }  
    return 0;  
}