vector容器，deque容器，sort算法

 

vector维护一段线性的空间，vector提供的是随机访问的迭代器，意思是可以随机访问线性表中的元素。

#include<iostream>
using namespace std;
#include<vector>
void test()
{
    vector<int>v;
    for (int i = 0; i < 10; ++i)
    {
    	v.push_back(i);
    	cout << v.capacity() << endl;
    }
    cout << v[2];
}
int main()
{
    test();
    return 0;
}

vector的数据结构：

#include<iostream>
using namespace std;
#include<vector>
void printfs(vector<int> s)
{
    for (vector<int>::iterator it = s.begin(); it <s.end(); ++it)
    {    
        cout << (*it) <<" ";
    }
    cout << endl;
}
void test()
{
    int p[] = { 1, 2, 3, 4, 5, 6 };
    vector<int>p1(p,p+sizeof(p)/sizeof(int));     //这个就相当于用123456填充p1。(p,p+sizeof(p)/sizeof(int))p就相当于begin,p+sizeof(p)/sizeof(int)就相当于end
    vector<int>p2(p1.begin(), p1.end());
    printfs(p1);
    printfs(p2);
}
void test2()
{
    vector<int>v(10, 100);
    printfs(v);
}
int main()
{
    test();
    test2();
    return 0;
}

void printfs(vector<int> s)
{
    for (vector<int>::iterator it = s.begin(); it <s.end(); ++it)
    {
    	cout << (*it) << " ";
    }
    cout << endl;
}
void test2()
{
    vector<int>v(10, 100);
    vector<int>v1(5, 10);
    v1.swap(v);         //将两个容器之中的数据互换
    printfs(v1);
}
int main()
{
    test2();
    return 0;
}

void printfs(vector<int> s)
{
    for (vector<int>::iterator it = s.begin(); it <s.end(); ++it)
    {
    	cout << (*it) << " ";
    }
    out << endl;
}
void test2()
{
    vector<int>v(10, 100);
    vector<int>v1(5, 10);
    v1.swap(v);         //将两个容器之中的数据互换
    printfs(v1);
    if (v1.empty())     //判断容器 是否为空，返回值是bool类型，为空返回1，不为空返回0
    {
    	cout << "为空" << endl;
    }
    else
    	cout << "不是空" << endl;
}
int main()
{
    test2();
    return 0;
}

 

其他的就不在这里测了，自己下去测

swap收缩空间：

匿名对象特点：当前行结束空间释放。

#include<iostream>
using namespace std;
#include<vector>
void test2()
{
    vector<int>v;
    for (int i = 0; i < 10000; ++i)
    {
    	v.push_back(i);
    }
    cout << "容量" << v.capacity() << endl;         //容量12138
    cout << "大小" << v.size() << endl;             //大小10000
    v.resize(3);
    cout << "容量" << v.capacity() << endl;         //容量12138
    cout << "大小" << v.size() << endl;				//大小3
    vector<int>(v).swap(v);
    cout << "容量" << v.capacity() << endl;         //容量3
    cout << "大小" << v.size() << endl;				//大小3
}
//这里关于vector<int>(v).swap(v);做一下解释
//vector<int>(v)利用v来构造一个匿名对象（匿名对象特点：当前行结束空间释放）
//然后就会得到大小和容量都为3的匿名对象，然后再利用swap交换数据（实际上是交换指针指的指向），对象指向交换后的空间
//当前行结束指向旧空间的对象被释放
int main()
{
    test2();
    return 0;
}

 

//reserve()
#include<iostream>
using namespace std;
#include<vector>
void test2()
{
    vector<int>v;
    int* p = nullptr;
    int num = 0;
    for (int i = 0; i < 10000; ++i)
    {
    	v.push_back(i);
    	if (p != &v[0])           //10000个空间不是一次开辟的，而是根据数据尾插来进行慢慢扩大的，
    	{                         //但是顺序的结构使得扩展的时候旧空间后面不一定有足够的新空间
    		p = &v[0];            //所以每找一次新的空间首元素地址就会发生改变，我们的目的就是查看更换了多少次空间
    		++num;
    	}
    }
    cout << num << endl;
}
void test()
{
    vector<int>v;
    v.reserve(10000);                  //与上面代码相比，reserve就是直接给容器预留出10000个空间，
    int* p = nullptr;                  //这时候在已知容量的情况下这样比较节省时间
    int num = 0;
    for (int i = 0; i < 10000; ++i)
    {
    	v.push_back(i);
    	if (p != &v[0])          
    	{                         
    		p = &v[0];            
    		++num;
    	}
    }
    cout << num << endl;
}

int main()
{
    test2();
    test();
    return 0;
}


运行结果：
24           //第一个寻找24次
1            //预留之后1次
请按任意键继续. . .

vector内部有自己扩容算法

#include<iostream>
using namespace std;
#include<vector>
void test()
{
    vector<int>v;
    v.push_back(10);
    v.push_back(20);
    v.push_back(30);
    v.push_back(40);
    cout << v.front() << endl;
    cout << v.back() << endl;
}
int main()
{
    test();
    return 0;
}

#include<iostream>
using namespace std;
#include<vector>
void printfs(vector<int> s)
{
    for (vector<int>::iterator it = s.begin(); it <s.end(); ++it)
    {
    	cout << (*it) << " ";
    }
    cout << endl;
}
void test()
{
    vector<int>v;
    v.push_back(10);
    v.push_back(20);
    v.push_back(30);
    v.push_back(40);
    cout << v.front() << endl;
    cout << v.back() << endl;
    v.insert((++v.begin()), 2, 100);        //第一个参数必须是迭代器，也就是指针，第二个参数可有可无，
    printfs(v);                             //要是没有默认是1，要是有的话就是你要插入的第三个参数的个数
    v.pop_back();   //尾删
    printfs(v);
    v.erase(v.begin());         //指定迭代器删除
    printfs(v);
    v.erase((v.begin())+2, v.end());       //指定迭代器范围删除    (v.begin())+指针后移两个int位
    printfs(v);
    v.clear();      //清空数据
    printfs(v);
    if (v.empty())       //判断是否为空，为空返回1
    {
    	cout << "已清空\n";
    }
}
int main()
{
    test();
    return 0;
}







运行结果：
10
40
10 100 100 20 30 40
10 100 100 20 30
100 100 20 30
100 100

已清空
请按任意键继续. . .

#include<iostream>
using namespace std;
#include<vector>
void test1()
{
    vector<int>v;
    v.push_back(10);
    v.push_back(20);
    v.push_back(30);
    v.push_back(40);
    printfs(v);
    for (vector<int>::reverse_iterator it = v.rbegin(); it != v.rend(); ++it)
    {
    	cout << (*it)<<" ";         //这里注意两点，第一点逆序遍历提供的迭代器是reverse_iterator
    }                               // 最后使用的仍然是++it,因为为了使用方便人间内部已经维护好了
    cout << endl;
}
int main()
{
    test1();
    return 0;
}

void test2()
{
    //vector迭代器是随机访问迭代器，什么是随机访问迭代器？
    vector<int>v;
    vector<int>::iterator it = v.begin();
    it = it + 3;
    //支持这种写法的都是随机访问迭代器，随机访问就是可以通过迭代器（指针）的指向，随机的访问容器中的数据

}

并不是所有容器的迭代器都支持随机访问

deque容器：

deque通过中控器来管理内存，它是通过分段式的内存来存储数据的

#include<deque>
#include<iostream>
using namespace std;
void printfs(const deque<int>& p)
{
    //iterator普通迭代器   reverse_iterator逆序迭代器   const_iterator只读迭代器 
    for (deque<int>::const_iterator it = p.begin(); it != p.end(); ++it)   //这里设置为只读迭代器就不能够在内部对容器元素修改了
    {
    	cout << (*it) << " ";
    }
    cout << endl;
}
void test1()
{
    deque<int>v;
    v.push_back(10);
    v.push_back(20);
    v.push_back(30);
    v.push_front(50);
    v.push_front(40);
    v.push_front(60);
    v.pop_back();
    v.pop_back();
    v.pop_front();
    printfs(v);
    cout << v.back() << endl;
    cout << v.front() << endl;
    //cout << v.capacity << endl;    deque容器没有容量，无法查询容量大小啊
 }
int main()
{
    test1();
    return 0;
}

#include<deque>
#include<iostream>
#include<algorithm>
using namespace std;
void printfs(const deque<int>& p)
{
    //iterator普通迭代器   reverse_iterator逆序迭代器   const_iterator只读迭代器 
    for (deque<int>::const_iterator it = p.begin(); it != p.end(); ++it)   //这里设置为只读迭代器就不能够在内部对容器元素修改了
    {
    	cout << (*it) << " ";
    }
    cout << endl;
}
//要使用系统自带的算法就必须要包含头文件#include<algorithm>
void test2()
{
    deque<int>v;
    v.push_back(4);
    v.push_back(9);
    v.push_back(6);
    v.push_back(7);
    v.push_back(2);

    sort(v.begin(), v.end());         //只能进行从小到达的排序
    printfs(v);
}
int main()
{
    test2();
    return 0;
}

仿函数就是协助算法改变策略，例如sort要是使用从大到小排序，就要加入第三个参数，要么是回调函数，要么是仿函数

#include<deque>
#include<iostream>
#include<algorithm>
using namespace std;
void printfs(const deque<int>& p)
{
    //iterator普通迭代器   reverse_iterator逆序迭代器   const_iterator只读迭代器 
    for (deque<int>::const_iterator it = p.begin(); it != p.end(); ++it)   //这里设置为只读迭代器就不能够在内部对容器元素修改了
    {
    	cout << (*it) << " ";
    }
    cout << endl;
}
bool mycomparent(int a,int b)    //回调函数
{
    return a > b; 
}
void test2()
{
    deque<int>v;
    v.push_back(4);
    v.push_back(9);
    v.push_back(6);
    v.push_back(7);
    v.push_back(2);    
    sort(v.begin(), v.end());         //只能进行从小到达的排序
    printfs(v);
    sort(v.begin(), v.end(), mycomparent);
    printfs(v);
}
int main()
{
    test2();
    return 0;
}