C++stl 向量，链表，栈，队列（vector, list, stack, queue）

随机存取的向量-vector

#include <iostream>
#include <vector>
#include<algorithm>
using namespace std;

bool comp(const int &a, const int &b)
{
    return a > b;
}

void VectorMain()
{
    // constructors used in the same order as described above:
    vector<int> first;                                // empty vector of ints
    vector<int> second(4, 100);                       // four ints with value 100
    vector<int> third(second.begin(), second.end());  // iterating through second
    vector<int> fourth(third);                       // a copy of third

    // the iterator constructor can also be used to construct from arrays:
    int myints[] = { 16,2,77,29 };
    vector<int> fifth(myints, myints + sizeof(myints) / sizeof(int));

    cout << "The contents of fifth are:";
    for (vector<int>::iterator it = fifth.begin(); it != fifth.end(); ++it)
        cout << ' ' << *it;
    cout << '\n';

    // sort
    sort(fifth.begin(), fifth.end());
    cout << "The ascend contents of fifth are:";
    for (vector<int>::iterator it = fifth.begin(); it != fifth.end(); ++it)
        cout << ' ' << *it;
    cout << '\n';

    // descend
    sort(fifth.begin(), fifth.end(), comp);
    cout << "The descend contents of fifth are:";
    for (vector<int>::iterator it = fifth.begin(); it != fifth.end(); ++it)
        cout << ' ' << *it;
    cout << '\n';

    // push_back, pop_back, empty, clear
}

链表

#include <iostream>
#include <cmath>
#include <vector>
#include <list>
using namespace std;

// a binary predicate implemented as a function:
bool same_integral_part(double first, double second)
{
    return (int(first) == int(second));
}

// a binary predicate implemented as a class:
struct is_near {
    bool operator() (double first, double second)
    {
        return (fabs(first - second)<5.0);
    }
};

void ListMain()
{
    // constructors used in the same order as described above:
    std::list<int> first;                                // empty list of ints
    std::list<int> second(4, 100);                       // four ints with value 100
    std::list<int> third(second.begin(), second.end());  // iterating through second
    std::list<int> fourth(third);                       // a copy of third

    double mydoubles[] = { 12.15,  2.72, 73.0,  12.77,  3.14,
        12.77, 73.35, 72.25, 15.3,  72.25 };
    std::list<double> mylist(mydoubles, mydoubles + 10);

    mylist.sort();             //  2.72,  3.14, 12.15, 12.77, 12.77,
                               // 15.3,  72.25, 72.25, 73.0,  73.35

    mylist.unique();           //  2.72,  3.14, 12.15, 12.77
                               // 15.3,  72.25, 73.0,  73.35

    mylist.unique(same_integral_part);  //  2.72,  3.14, 12.15
                                        // 15.3,  72.25, 73.0

    mylist.unique(is_near());           //  2.72, 12.15, 72.25

    std::cout << "mylist contains:";
    for (std::list<double>::iterator it = mylist.begin(); it != mylist.end(); ++it)
        std::cout << ' ' << *it;
    std::cout << '\n';

    ///insert/
    std::list<int> mylist1;
    std::list<int>::iterator it;

    // set some initial values:
    for (int i = 1; i <= 5; ++i) mylist1.push_back(i); // 1 2 3 4 5

    it = mylist1.begin();
    ++it;       // it points now to number 2           ^

    mylist1.insert(it, 10);                        // 1 10 2 3 4 5

                                                  // "it" still points to number 2                      ^
    mylist1.insert(it, 2, 20);                      // 1 10 20 20 2 3 4 5

    --it;       // it points now to the second 20            ^

    std::vector<int> myvector(2, 30);
    mylist1.insert(it, myvector.begin(), myvector.end());
    // 1 10 20 30 30 20 2 3 4 5
    //               ^
    std::cout << "mylist contains:";
    for (it = mylist1.begin(); it != mylist1.end(); ++it)
        std::cout << ' ' << *it;
    std::cout << '\n';

    // front(), back(), push_back(value), pop_back(), push_front(value), pop_front(), empty(), clear(), remove(value)
}

stack:

push(value) //向容器顶部插入元素
pop() //删除容器顶部的元素
top() //返回容器顶部的元素
size() //返回容器的元素个数
empty() //检查是否为空

queue:

back() //返回队列最后一个元素的引用
empty() //检查是否为空
front() //返回队列第一个元素的引用
push(value) //队列尾添加一个元素
pop() //删除队列第一个元素
size() //返回队列的元素个数