c++13.0 STL[stack,queue,set,dequeue]

set:集合,红黑树实现
 特点:
   1.0 内部的元素根据其值自动排序。
   2.0 内部元素只能出现一次。

#include<iostream>
#include<string>
#include<set>
#include<algorithm>
using namespace std;

void displaySet(set<int> se);
void findSet(set<int> se, int n);
int main()
{
    set<int> se;
/*
iterator insert( iterator i, const TYPE &val );
void insert( input_iterator start, input_iterator end );
pair insert( const TYPE &val );
说明：
● 在迭代器i前插入val；
● 将迭代器start开始到end结束返回内的元素插入到集合中；
● 在当前集合中插入val元素，并返回指向该元素的迭代器
和一个布尔值来说明val是否成功的被插入了。
*/
    se.insert(11);
    se.insert(66);
    se.insert(33);
    se.insert(22);
    cout << "set集合的元素" << endl;
    displaySet(se);
    cout << endl;
/*
void erase( iterator i );
void erase( iterator start, iterator end );
size_type erase( const key_type &key );
● 删除i元素；
● 删除从start开始到end结束的元素；
● 删除等于key值的所有元素（返回被删除的元素的个数）。
*/
    set<int>::iterator it;
    se.erase(se.begin());
    cout << "删除第一个元素" << endl;
    cout << "set集合的元素" << endl;
    displaySet(se);
    cout << endl;
    findSet(se, 22);
    
    set<int> se1;
    se1.insert(22);
    se1.insert(88);
    se1.insert(33);
    cout << "se1集合的元素" << endl;
    displaySet(se1);
    cout << endl;


    system("pause");
    return 0;
}

void displaySet(set<int> se)
{
    set<int>::iterator it;

/*
iterator begin();
返回指向当前集合中第一个元素的迭代器。
const_iterator end();
返回指向当前集合中最后一个元素的迭代器。

*/

    for (it=se.begin();it!=se.end(); it++)
    {
        cout << *it << "  ";
    }

}

void findSet(set<int> se,int n)
{
    /*
    iterator find( const key_type &key );
    在当前集合中查找等于key值的元素，并返回指向该元素的迭代器；
    如果没有找到，返回指向集合最后一个元素的迭代器。
    */
    set<int>::iterator it;
    it = se.find(n);
    if (it != se.end())
        cout << "值为"<<n<<"元素存在" << endl;
    else
        cout << "值为" << n << "元素不存在" << endl;
}

set集合的元素
11  22  33  66
删除第一个元素
set集合的元素
22  33  66
值为22元素存在
se1集合的元素
22  33  88

 queue:队列。可以链表实现，可以数组实现。
   特点:先进先出。

#include<iostream>
#include<string>
#include<queue>
#include<algorithm>
using namespace std;

void displayQueue(queue<double> qu);

int main() {

    queue<double> qu;

/*
void push( const TYPE &val );
push()函数往队列中加入一个元素。
*/

    qu.push(2.22);
    qu.push(3.33);
    qu.push(4.44);
    cout << "队列qu中的元素：" << endl;
    displayQueue(qu);
    cout << endl;
//back() 返回最后一个元素 

    system("pause");
    return 0;
}

void displayQueue(queue<double> qu)
{

/*
TYPE &back();
back()返回一个引用，指向队列的最后一个元素。
*/

/*
    void pop();
    pop()函数删除队列的一个元素。
*/
    while (!qu.empty())
    {
        cout << qu.front() << " ";
        qu.pop();
    }

}

队列qu中的元素：
2.22 3.33 4.44

stack:堆栈，函数递归，等好多问题都使用到了堆栈。
特点:先进后出。

#include<iostream>
#include<string>
#include<stack>
using namespace std;

void displayStack(stack<char> st);

int main() {
    stack<char> st;
    /*
    Syntax : void push(const TYPE &val);
    push() 函数将 val 值压栈，使其成为栈顶的第一个元素
    */
    st.push('a');
    st.push('b');
    st.push('c');
    //先进后出的特点。
    displayStack(st);
    cout << endl;

    /*
    语法:   void pop();
    pop() 函数移除堆栈中最顶层元素。
    */
    cout << "删除头部一个元素" << endl;
    system("pause");
    return 0;
}

void displayStack(stack<char> st)
{

    /*
    TYPE &top();
    top() 函数返回对栈顶元素的引用. 举例,如下代码显现和清空一个堆栈。
    */

    /*
    语法:   void pop();
    pop() 函数移除堆栈中最顶层元素。
    */

    while(st.empty()==0)
    {
        cout<<st.top();
        st.pop();
    }
}

cba

 deque：双端队列。
学习了数据结构你就知道，它有2个指针，可以双向遍历队列。

#include<iostream>
#include<string>
#include<deque>
using namespace std;

void display(deque<int> de);
int main()
{
    deque<int> de;

/*
push_back
语法:
void push_back( const TYPE &val );
push_back()函数在双向队列的尾部加入一个值为val的元素。
*/
    de.push_back(6);
    de.push_back(8);
    de.push_back(9);
    display(de);
    cout << endl;
/*
push_front
语法:
void push_front( const TYPE &val );

*/
    cout << "头部插入10:" << endl;
    de.push_front(10);
    display(de);
    cout << endl;

/*
pop_back
语法:
void pop_back();
pop_back()删除双向队列尾部的元素。
*/

cout << "删除尾部元素" << endl;
de.pop_back();
display(de);
cout << endl;

/*
pop_front
语法:
void pop_front();
pop_front()删除双向队列头部的元素。
*/

cout << "删除头部元素" << endl;
de.pop_front();
display(de);
cout << endl;

/*
Constructors
语法:   deque();
deque( size_type size );
deque( size_type num, const TYPE &val );
deque( const deque &from );
deque( input_iterator start, input_iterator end );
C++ Deques能用以下方式创建:

无参，创建一个空双向队列
size - 创建一个大小为size的双向队列
num and val - 放置num个val的拷贝到队列中，
from - 从from创建一个内容一样的双向队列
start 和 end - 创建一个队列，保存从start到end的元素。

*/

int arr[6] = { 11,33,22,66,55,44 };
deque<int> dearr(arr, arr + 6);
cout << "新双端队列为:" << endl;
display(dearr);
cout << endl;

/*
insert
iterator insert( iterator pos, size_type num, const TYPE &val );
void insert( iterator pos, input_iterator start, input_iterator end );
insert()在pos前插入num个val值，或者插入从start到end范围内的元素到pos前面

*/
deque<int>::iterator it;
 de.insert(de.end(),dearr.begin(), dearr.end() );
cout <<"把队列dearr插入到de中："<< endl;
display(de);
cout << endl;
    system("pause");
    return 0;
}

void display(deque<int> de)
{
    deque<int>::iterator it;
    for (it = de.begin(); it != de.end(); it++)
        cout << *it << " " ;

}

6 8 9
头部插入10:
10 6 8 9
删除尾部元素
10 6 8
删除头部元素
6 8
新双端队列为:
11 33 22 66 55 44
把队列dearr插入到de中：
6 8 11 33 22 66 55 44