学习笔记（二）——STL

//上一章讲到了<map>映照容器，提到了一个利用map分离各位数字的用法，下面上例程：

#include<iostream>
#include<string>
#include<map>

using namespace std;

int main()
{
    //定义map对象，当前没有任何元素
    map<char,int> m;
    //赋值：字符映射数字
    m['0']=0;
    m['1']=1;
    m['2']=2;
    m['3']=3;
    m['4']=4;
    m['5']=5;
    m['6']=6;
    m['7']=7;
    m['8']=8;
    m['9']=9;
    /*
    上面的复制过程可以简写为下面这个循环
    for(int j=0;j<10;j++)
    {
        m['0'+j]=j;
    }
    */
    int sum=0;
    string sa,sb;
    sa="6243";
    for(int i=0;i<sa.length();i++)
    {
        sum+=m[sa[i]];
    }
    cout<<"Sum = "<<sum<<endl;
    return 0;
}

下面进入正题。

众所周知，STL还提供了几种传统的容器，他们分别是队列<queue> 、 双端队列<deque> 、堆栈<stack> 、(双向)链表<list>。

1.<deque>

本想先讲stack，但是感觉抽象之后先从queue逐渐过渡到stack更好理解一些。

deque双向队列是一种双向开口的连续线性空间，可以高效的在头尾两端插入和删除元素。在使用上，deque与vector略显相似，给人一种“两头开口的vector”的印象。

于是懒惰的我就从MoreWindows大神那儿盗了图……

当然，懒惰如我也是要写代码的，例程如下：

//双向队列 deque
#include<deque>
#include<cstdio>
#include<algorithm>
#include<iostream>
using namespace std;
int main()
{
	deque<int> deq(20); //初始化一个双端队列
	deque<int>::iterator pos;
	int i;

    //
	for (i = 0; i < 20; ++i)
		deq[i] = i;

	//输出deque
	cout<<"输出deque中数据："<<endl;
	for (i = 0; i < 20; ++i)
		cout<<deq[i]<<" ";
	cout<<endl;

	//在头尾加入新数据
	cout<<"\n在头尾加入新数据..."<<endl;
	deq.push_back(100);
	deq.push_front(i);

	//输出deque
	cout<<"\n输出deque中数据"<<endl;
	for (pos = deq.begin(); pos != deq.end(); pos++)
		cout<<*pos<<" ";
	cout<<endl;

	//查找
	const int FINDNUMBER = 19;
	cout<<"\n查找"<<FINDNUMBER<<endl;
	pos = find(deq.begin(), deq.end(), FINDNUMBER);
	if (pos != deq.end())
        cout<<"find "<<*pos<<" success"<<endl;
	else
        cout<<"find failed"<<endl;

	//在头尾删除数据
	cout<<"\n在头尾删除数据"<<endl;
	deq.pop_back();
	deq.pop_front();

	//输出deque
	cout<<"\n输出deque中数据"<<endl;
	for (pos = deq.begin(); pos != deq.end(); pos++)
		cout<<*pos<<" ";
	cout<<endl;
	return 0;
}

2.<list>

list容器实现了双向链表的数据结构。双向链表中，数据元素是通过链表指针串联成逻辑意义上的线性表，这样，对链表任何一位置进行插入/删除/查找的速度都是极快的，这真是极好的，然而这并没有什么卵用，因为对于大部分人而言，链表中对指针的操作会要了他们的老命。STL中就出现了List这种可爱的东西，用来解放我等的大脑。

list的每个节点都有三个域：前驱元素指针域、数据域、后继元素指针域。前驱元素指针域保存了前驱元素的首地址；数据域存储本节点的数据；后继元素指针域则指向下一个元素。链表的实现方法可以参考这篇文章 C语言单链表练习  此处不再赘述，只表STL链表的使用方法。

由于其结构的原因，list 随机检索的性能非常的不好，因为它不像vector 那样直接找到元素的地址，而是要从头一个一个的顺序查找，这样目标元素越靠后，它的检索时间就越长。检索时间与目标元素的位置成正比。

虽然随机检索的速度不够快，但是它可以迅速地在任何节点进行插入和删除操作。因为list 的每个节点保存着它在链表中的位置，插入或删除一个元素仅对最多三个元素有所影响，不像vector 会对操作点之后的所有元素的存储地址都有所影响，这一点是vector 不可比拟的。

例程：

#include<list>
#include<cstdio>
#include<algorithm>
#include<iostream>
using namespace std;
int main()
{
	list<int> l;
	for(int i=1;i<=10;i++)
        l.push_back(i);
        //从后部追加元素

    for(int i=20;i>=10;i--)
        if(i%2)
            l.push_front(i);
        //从前部追加元素

    list<int>::iterator it;
    //list容器的指针只允许++和--操作，不允许+n
    for(it=l.begin();it!=l.end();it++)
    {
        cout<<*it<<" ";
    }
    cout<<endl;
    //遍历输出

    //迭代器移动，输出迭代器位置的键值
    it=l.begin();
    int countn=3;
    while(countn--)
        it++;
    cout<<*it<<endl;

    //反向迭代器
    list<int>::reverse_iterator rit;
    for(rit=l.rbegin();rit!=l.rend();rit++)
    {
        cout<<*it<<" ";
    }
    cout<<endl;

    //remove（n）移除所有制为n的节点
    l.remove(5);
    for(it=l.begin();it!=l.end();it++)
    {
        cout<<*it<<" ";
    }
    cout<<endl;

    //使用pop删除首尾节点
    l.pop_front();
    l.pop_back();
    for(it=l.begin();it!=l.end();it++)
    {
        cout<<*it<<" ";
    }
    cout<<endl;

    //erase删除迭代器位置的节点
    it=l.begin();
    it++;
    it++;
    it++;
    l.erase(it);
    for(it=l.begin();it!=l.end();it++)
    {
        cout<<*it<<" ";
    }
    cout<<endl;

    //使用find查找第一个目标键值的节点
    it=find(l.begin(),l.end(),8);
    if(it!=l.end())
        cout<<"find it "<<*it<<endl;
    else
        cout<<"not find"<<endl;

    //clear清空链表
    l.clear();
    cout<<l.size()<<endl;

    return 0;
}

3.<stack>

栈（statck）这种数据结构在计算机中是相当出名的，只要上过数据结构课的同学应该没有不知道的。栈是一种典型的先入后出（FILO）队列，在STL中，栈是以别的容器作为底部结构，再将接口改变，使之符合栈的特性就可以了。因此实现非常的方便。在STL中栈一共就5个常用操作函数（top()、push()、pop()、 size()、empty() ），很好记的。

此处直接扔一个用stl栈写的括号匹配，算是典型用例吧。

//使用STL栈的括号匹配
//作者Richr_Wong
#include<stack>
#include<iostream>
#include<cstdio>
#include<string>
using namespace std; 
int main()
{
	char temp[1000];
	int len;
	memset(temp,0,sizeof(temp));
	stack<char> queue;
	cin>>temp;
	bool flag;
	len=strlen(temp);
	flag=1;
	for(int i=0;i<len;i++)
	{
		char temp2=temp[i];
		switch(temp2)
		{
			case '(':
			case '[':
			case '{':
				queue.push(temp2);
			//左括号入栈 
			break;
			//出现右括号则与栈顶元素做比较，配对共同出栈，不配对结束。	
			case ')':
				if(queue.top()!='(')
					flag=0;
				else
					queue.pop();
			break;
			case '}':
				if(queue.top()!='{')
					flag=0;
				else
					queue.pop();
			break;
			case ']':
				if(queue.top()!='[')
					flag=0;
				else
					queue.pop();
			break;
		}
	}
	if(queue.empty()!=1)
	{
		flag=0;
	}
	if(flag==1)
		cout<<"匹配";
	else 
		cout<<"不匹配";
	return 0; 
}

4.<queue>

queue单向队列与栈有点类似，一个是在同一端存取数据，另一个是在一端存入数据，另一端取出数据。单向队列中的数据是先进先出（First In First Out,FIFO）。queue的使用方法比较简单，一个例程说明白：

#include<queue>
#include<cstdio>
#include<algorithm>
#include<iostream>
using namespace std;
int main()
{
    queue<int> q;
    
    //元素入队
    for(int i=1;i<=10;i++)
        q.push(i);
        
    //返回队列大小
    cout<<q.size()<<endl;
    
    //返回队列空满
    cout<<q.empty()<<endl;
    
    //输出队列头
    cout<<q.front()<<endl;
    
    //输出队列尾
    cout<<q.back()<<endl;
    
    //当队列不为空，弹出队列元素
    while(q.empty()!=true)//
    {
        cout<<q.front()<<" ";
        q.pop();
    }
    
    cout<<endl;
    return 0;
}