1.stack,size(),empty(),pop()函数

#include<stack>

#include <iostream>

 

using namespace std;

 

//通过push()方法入栈

//通过size()方法求栈中元素的个数

//通过empty()方法判断栈是否为空

//通过pop()求栈中最顶端的元素

void main()

{

    int num;

    cin >> num;

    stack<int> mystack;

    for (; num; num /= 2)

    {

        mystack.push(num % 2);

        std::cout << "当前元素个数" << mystack.size() << endl;

    }

    while (!mystack.empty())

    {

        int num = mystack.top();

        std::cout << num << " ";

        mystack.pop();

    }

 

    cin.get();

    cin.get();

}

运行结果：

2.queue,队列

#include <queue>

#include <iostream>

#include <string>

#include <stdlib.h>

#include <list>

 

#include <deque> //双端队列

 

//提供了二维动态数组的功能，头部，尾部，任意操作

 

using namespace std;

 

void main()

{

    queue<char *> myq;

    myq.push("calc");

    myq.push("notepad");

    myq.push("tasklist");

    myq.push("mspaint");

 

    while (!myq.empty())

    {

        char *p = myq.front();//获取

        system(p);

        myq.pop();

    }

 

    cin.get();

    //运行结果是：

    //弹出计算器

    //弹出notepad

    //显示进程

    //弹出mspaint

}

案例2

#include <queue>

#include <iostream>

#include <string>

#include <stdlib.h>

#include <list>

 

#include <deque> //双端队列

 

//提供了二维动态数组的功能，头部，尾部，任意操作

 

using namespace std;

 

void main()

{

    deque<int> mydq;

    mydq.push_back(1);

    mydq.push_back(11);

    mydq.push_back(111);

    mydq.push_back(1111);

    mydq.push_back(11111);

    mydq.push_front(123);

    mydq.insert(mydq.begin() + 3, 100);//插入

 

    //类似数组的方式打印出结果

    for (int i = 0; i < mydq.size(); i++)

    {

        std::cout << mydq[i] << std::endl;

    }

 

    std::cout << "------------------" << std::endl;

 

    //通过begin和end的方式实现打印出结果

    auto ib = mydq.begin();

    auto ie = mydq.end();

    for (; ib != ie; ib++)

    {

        std::cout << *ib << std::endl;

    }

 

    cin.get();

}

运行结果：

案例3：

关于队列的erase()，删除某个元素

#include <queue>

#include <iostream>

#include <string>

#include <stdlib.h>

#include <list>

 

#include <deque> //双端队列

 

//提供了二维动态数组的功能，头部，尾部，任意操作

 

using namespace std;

//删除元素

void main()

{

    deque<int> mydq;

    mydq.push_back(1);

    mydq.push_back(11);

    mydq.push_back(111);

    mydq.push_back(1111);

    mydq.push_back(11111);

    mydq.push_back(123);

    //删除头部元素

    mydq.erase(mydq.begin());

    //删除尾部元素

    mydq.erase(mydq.end() - 1);

 

    auto ib = mydq.begin();

    auto ie = mydq.end();

    for (; ib != ie;ib++)

    {

        std::cout << *ib << std::endl;

    }

 

    cin.get();

}

运行结果：

案例4

关于pop_front()和pop_back()

#include <queue>

#include <iostream>

#include <string>

#include <stdlib.h>

#include <list>

 

#include <deque> //双端队列

 

//提供了二维动态数组的功能，头部，尾部，任意操作

 

using namespace std;

//删除元素

void main()

{

    deque<int> mydq;

    mydq.push_back(1);

    mydq.push_back(11);

    mydq.push_back(111);

    mydq.push_back(1111);

    mydq.push_back(11111);

    mydq.push_back(123);

    //头部弹出

    mydq.pop_front();

    //尾部弹出

    mydq.pop_back();

 

    auto ib = mydq.begin();

    auto ie = mydq.end();

    for (; ib != ie;ib++)

    {

        std::cout << *ib << std::endl;

    }

 

    cin.get();

}

运行结果：

案例5：

#include <queue>

#include <iostream>

#include <string>

#include <stdlib.h>

#include <list>

 

#include <deque> //双端队列

 

//提供了二维动态数组的功能，头部，尾部，任意操作

 

using namespace std;

//删除元素

void main()

{

    deque<int> mydq;

    mydq.push_back(1);

    mydq.push_back(11);

    mydq.push_back(111);

    mydq.push_back(1111);

    mydq.push_back(11111);

    mydq.push_back(123);

    //清空

    mydq.clear();

 

    auto ib = mydq.begin();

    auto ie = mydq.end();

    for (; ib != ie;ib++)

    {

        std::cout << *ib << std::endl;

    }

 

    cin.get();

}

运行结果：

案例6

swap实现两个栈中的内容交换

#include <queue>

#include <iostream>

#include <string>

#include <stdlib.h>

#include <list>

 

#include <deque> //双端队列

 

//提供了二维动态数组的功能，头部，尾部，任意操作

 

using namespace std;

//swap()两个栈中的数据交换

void main()

{

    deque<int> mydq1;

    mydq1.push_back(1);

    mydq1.push_back(11);

    mydq1.push_back(111);

    mydq1.push_back(1111);

    mydq1.push_back(11111);

 

    deque<int> mydq2;

    mydq2.push_back(2);

    mydq2.push_back(21);

    mydq2.push_back(211);

    mydq2.push_back(2111);

    mydq2.push_back(21111);

 

    mydq1.swap(mydq2);

 

    {

        auto ib = mydq1.begin();

        auto ie = mydq1.end();

        for (; ib != ie; ib++)

        {

            std::cout << *ib << std::endl;

        }

    }

 

    std::cout << "---------------" << std::endl;

 

    {

        auto ib = mydq2.begin();

        auto ie = mydq2.end();

        for (; ib != ie;ib++)

        {

            std::cout << *ib << std::endl;

        }

    }

 

    cin.get();

}

案例7.

关于front(),back(),max_size(),size()

#include <queue>

#include <iostream>

#include <string>

#include <stdlib.h>

#include <list>

 

#include <deque> //双端队列

 

//提供了二维动态数组的功能，头部，尾部，任意操作

 

using namespace std;

//swap()两个栈中的数据交换

void main()

{

    deque<int> mydq1;

    mydq1.push_back(1);

    mydq1.push_back(11);

    mydq1.push_back(111);

    mydq1.push_back(1111);

    mydq1.push_back(11111);

 

    //第一个元素

    std::cout << mydq1.front() << std::endl;

    //最后一个元素值

    std::cout << mydq1.back() << std::endl;

    //栈所允许的最大个数

    std::cout << mydq1.max_size() << std::endl;

    //当前栈的个数

    std::cout << mydq1.size() << std::endl;

 

    cin.get();

}

运行结果：

3.优先队列

优先队列实现的参数的结果是有序的

#include <queue>

#include <iostream>

 

using namespace std;

//优先队列实现了自动排序功能

void main()

{

    priority_queue<int> myq;

    myq.push(10);

    myq.push(12);

    myq.push(11);

    myq.push(110);

    myq.push(101);//自动排序

 

    while (!myq.empty())

    {

        std::cout << myq.top() << endl;

        myq.pop();

    }

 

    cin.get();

}

运行结果：

4.优先队列之2

案例：

#include <queue>

#include <iostream>

#include <string>

#include <stdlib.h>

#include <list>

 

#include<deque>//双端队列

using namespace std;

struct student

{

    int age;

    string name;

};

 

//这里按照年龄比较大小

struct stuless

{

    bool operator()(const student &s1, const student &s2)

    {

        return s1.age < s2.age;

    }

};

 

void main()

{

                //类名 存储方式是deque方式 按照年龄排序

    priority_queue<student, deque<student>, stuless> myq;

    student s1;

    s1.age = 10;

    s1.name = "谭胜";

    student s2;

    s2.age = 9;

    s2.name = "熊飞";

    student s3;

    s3.age = 19;

    s3.name = "熊peng飞";

    myq.push(s1);

    myq.push(s2);

    myq.push(s3);

    while (!myq.empty())

    {

        std::cout << myq.top().age << myq.top().name << endl;

        myq.pop();

    }

    cin.get();

}

运行结果是：