vector容器
目录
1.vector构造函数
先来说一说v.begin()和v1.end(),v.begin()是表示第一个元素,v.end()是表示末尾位置元素的下一个,这个位置是没有元素的
#include<vector>
#include<iostream>
using namespace std;
int main()
{
//vector的构造
vector<int>v1;//默认构造
for (int i = 0; i < 10; i++)
{
v1.push_back(i);
}
//通过区间的方式构造
vector<int>v2(v1.begin(), v1.end());//左闭右开的
//n个elem方式构造
vector<int>v3(10, 100);//第一个是个数,第二个是赋值
//拷贝构造
vector<int>v4(v3);//将v3拷贝给v4
//for (int i = 0; i < v1.size(); i++)//第一种方式打印
//{
// cout << v1[i] << " ";
//}
for (vector<int>::iterator it = v3.begin(); it != v3.end(); it++)
{
cout << *it << " ";
}
return 0;
}2.vector赋值操作
vector[i]=num这种写法是为了改变元素的值,能用vector[i]=num这种的前提:一开始vector容器里面索引位i上的元素是有值的,是有空间的
#include<iostream>
#include<vector>
using namespace std;
int main()
{
vector<int>v1;
for (int i = 0; i < 10; i++)
{
v1.push_back(i);
}
for (vector<int>::iterator it = v1.begin(); it != v1.end(); it++)
{
cout << *it << " ";
}
cout << endl;
//赋值操作
vector<int>v2;
v2 = v1;
for (vector<int>::iterator it = v2.begin(); it != v2.end(); it++)
{
cout << *it << " ";
}
cout << endl;
//assign
vector<int>v3;
v3.assign(v1.begin(), v1.end());
for (vector<int>::iterator it = v3.begin(); it != v3.end(); it++)
{
cout << *it << " ";
}
cout << endl;
//n个elem方式赋值
vector<int>v4;
v4.assign(10, 100);
for (vector<int>::iterator it = v4.begin(); it != v4.end(); it++)
{
cout << *it << " ";
}
return 0;
}3.vector容量和大小
empty() //判断容器是不是为空
capacity() //容器的容量
size() //返回容器中元素的个数
resize(int num) //重新指定容器的长度为num,若容器变长,则以默认值填充新位置,如果容器变短,则末尾超出容器长度的元素被删除
resize(int num,elem) //如果容器变长,则以elem值来填充
#include<iostream>
#include<vector>
using namespace std;
void printVector(vector <int> v)
{
for (vector<int>::iterator it = v.begin(); it < v.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
int main()
{
vector<int>v1;
for (int i = 0; i < 10; i++)
{
v1.push_back(i);
}
printVector(v1);
if (v1.empty())
{
cout << "v1为空" << endl;
}
else {
cout << "v1不为空" << endl;
cout << "v1的容量为: " << v1.capacity() << endl;
cout << "v1的大小: " << v1.size() << endl;
}
//v1.resize(15);以默认值0来填充
v1.resize(15, 100);
//v1.resize(5);如果重新指定的比原来短了,超出的部分会删除掉
printVector(v1);
return 0;
}4.插入和删除
#include<iostream>
#include<vector>
using namespace std;
void printVector(vector <int> v)
{
for (vector<int>::iterator it = v.begin(); it < v.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
int main()
{
vector<int>v1;
v1.push_back(0);
v1.push_back(10);
v1.push_back(20);
v1.push_back(30);
v1.push_back(40);
v1.push_back(50);
v1.push_back(60);
printVector(v1);
//尾删
v1.pop_back();
printVector(v1);
//插入//第一个参数是迭代器
v1.insert(v1.begin(), 100);//头部插入一个数据
//可以连续插入n个数据
v1.insert(v1.begin(), 2, 1000);
printVector(v1);
//删除//参数也是迭代器
v1.erase(v1.begin());
printVector(v1);
v1.erase(v1.begin(), v1.end());//第一个为开始数据,第二个为结束数据,左闭右开
v1.clear()//清空
return 0;
}需要注意的是:用insert如果只插入一个元素的话,第一个参数是一个迭代器,第二个参数是插入元素的值,如果插入多个一样的数,第一个参数是迭代器,第二个参数是几个这个数,第三个参数是插入元素的值。
5.互换容器
#include<iostream>
#include<vector>
using namespace std;
//vector容器 数据存取
void printVector(vector <int> v)
{
for (vector<int>::iterator it = v.begin(); it < v.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
int main()
{
vector<int>v1;
for (int i = 0; i < 10; i++)
{
v1.push_back(i);
}
//利用[]的方式来访问数组中的元素
for (int i = 0; i < v1.size(); i++)
{
cout << v1[i] << " ";
}
cout << endl;
//利用at方式来访问元素
for (int i = 0; i < v1.size(); i++)
{
cout << v1.at(i) << " ";
}
cout << endl;
//获取第一个元素
cout << "第一个元素为: " << v1.front() << endl;
//获取最后一个元素
cout << "最后一个元素为: " << v1.back() << endl;
return 0;
}6.vector互换容器
实现两个容器内元素进行互换
#include<iostream>
#include<vector>
using namespace std;
//vector容器互换
void printVector(vector <int> v)
{
for (vector<int>::iterator it = v.begin(); it < v.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void test02(vector<int>& v2)
{
vector<int>v1;
for (int i = 0; i < 10; i++)
{
v1.push_back(i);
}
printVector(v1);
cout << "v的容量为: " << v1.capacity() << endl;
cout << "v的大小为: " << v1.size() << endl;
v1.resize(3);
cout << "v的容量为: " << v1.capacity() << endl;
cout << "v的大小为: " << v1.size() << endl;
//巧用swap收缩内存//
vector<int>(v1).swap(v1);
cout << "v的容量为: " << v1.capacity() << endl;
cout << "v的大小为: " << v1.size() << endl;
}
int main()
{
vector<int>v1;
cout << "交换前: " << endl;
for (int i = 0; i < 10; i++)
{
v1.push_back(i);
}
printVector(v1);
vector <int>v2;
for (int i = 9; i >= 0; i--)
{
v2.push_back(i);
}
printVector(v2);
cout << "交换后: " << endl;
v1.swap(v2);
printVector(v1);
printVector(v2);
//实际用途
//巧用swap可以收缩空间
test02(v2);
return 0;
}deque容器
deque(双端数组,使用链表实现的)与vector的区别
vector对于头部的插入删除效率低,数据量越大,效率越低
deque相对而言,对头部的插入删除速度会比vector快
vector访问元素时的速度会比deque快,与二者实现有关
deque容器的迭代器也是支持随机访问的
1.deque的构造函数
#include<iostream>
#include<vector>
#include<deque>
using namespace std;
void printDeque(deque<int>& d)
{
for (deque<int>::iterator it = d.begin(); it != d.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
/*void printDeque(deque<int>& d)如果想要限定一个数组为只读,那就在前面加const
{
for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
//不要忘记将iterator改为const_iterator
{
cout << *it << " ";
}
cout << endl;
}*/
int main()
{
deque<int>d1;
for (int i = 0; i < 10; i++)
{
d1.push_back(i);
}
printDeque(d1);
//利用迭代器给v2赋值
deque<int>d2(d1.begin(), d1.end());
printDeque(d2);
//利用(n,elem)来给d3赋值
deque<int>d3(10, 100);
printDeque(d3);
//利用拷贝给v4赋值
deque<int>d4(d3);
printDeque(d4);
return 0;
}2.deque的赋值操作
#include<iostream>
#include<vector>
#include<deque>
using namespace std;
//deque容器的赋值操作
void printDeque(const deque<int>& d)
{
for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void test01()
{
deque<int>d1;
for (int i = 0; i < 10; i++)
{
d1.push_back(i);
}
printDeque(d1);
//operator = 赋值
deque<int>d2;
d2 = d1;
printDeque(d2);
//assgin赋值
deque<int>d3;
d3.assign(d1.begin(), d1.end());
printDeque(d3);
deque<int>d4;
d4.assign(10, 100);
printDeque(d4);
}
int main()
{
test01();
return 0;
}3.deque的大小操作
deque没有capacity容量这一说,因为deque的本身构造实现的原因,它可以无限制的在后面开辟空间
#include<iostream>
#include<vector>
#include<deque>
using namespace std;
//deque容器的赋值操作
void printDeque(const deque<int>& d)
{
for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void test01()
{
deque<int>d1;
for (int i = 0; i < 10; i++)
{
d1.push_back(i);
}
printDeque(d1);
if (d1.empty())
{
cout << "d1为空" << endl;
}
else
{
cout << "d1不为空" << endl;
cout << "d1的大小: " << d1.size() << endl;
//deque容器没有容器概念
}
//重新指定大小
d1.resize(15,1);//前面一个是扩展的数据,1是扩展的数据里面存放1
d1.resize(5);//将多余的数据删除
}
int main()
{
test01();
return 0;
}4.deque的插入和删除
函数原型:
//两端的插入和删除操作
push_back(elem); //在容器尾部添加一个数据
push_front(elem); //在容器头部插入一个数据
pop_back(); //删除容器最后一个数据
pop_front(); //删除容器第一个元素
//指定位置操作:
insert(pos,elem); //在pos位置上直接插入一elem元素的拷贝,返回新数据的位置
insert(pos,n,elem) //在pos位置上插入n个elem数据,无返回值insert(pos,beg,end) //在pos位置插入[beg,end)区间的数据,无返回值
clear(); //清空容器的所有数据
earse(beg,end); 删除[beg,end) 区间的数据,返回下一个数据的位置
earse(pos) //删除pos位置的数据,返回下一个数据的位置
#include<iostream>
#include<vector>
#include<deque>
using namespace std;
//deque容器的赋值操作
void printDeque(const deque<int>& d)
{
for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void test01()
{
deque<int>d1;
//尾插
d1.push_back(10);
d1.push_back(20);
//头插
d1.push_front(100);
d1.push_front(200);
printDeque(d1);
//尾删
d1.pop_back();
//头删
d1.pop_front();
printDeque(d1);
}
void test02()
{
deque<int>d1;
d1.push_back(10);
d1.push_back(20);
d1.push_front(100);
d1.push_front(200);
//insert插入
d1.insert(d1.begin(), 1000);
d1.insert(d1.begin(), 2, 1000);
//deque<int>::iterator it = d1.begin();//设置一个迭代器,相当于d1.begin()
//d1.insert(it + 1, 10000);
printDeque(d1);
//按照区间进行插入
deque<int>d2;
d2.push_back(1);
d2.push_back(2);
d2.push_back(3);
d1.insert(d1.begin(), d2.begin(), d2.end());
printDeque(d1);
//删除
deque<int>::iterator it = d1.begin();//设置一个迭代器,相当于d1.begin()
it++;
d1.erase(it);
printDeque(d1);
//按照区间方式删除
d1.erase(it, d1.end());
printDeque(d1);
}
int main()
{
test02();
return 0;
}5.sort排序
#include<iostream>
#include<vector>
#include<deque>
#include<algorithm>
using namespace std;
//deque容器的赋值操作
void printDeque(const deque<int>& d)
{
for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void test01()
{
deque<int>d1;
d1.push_back(10);
d1.push_back(20);
d1.push_front(100);
d1.push_front(200);
printDeque(d1);
sort(d1.begin(), d1.end());
printDeque(d1);
}
int main()
{
test01();
return 0;
}stack容器
概念:stack是一种先进先出的数据结构,只有一个出口,其实就是我们数据结构和算法说的栈
栈中只有顶端的元素才可以被外界使用,因此栈不允许有遍历行为
#include<iostream>
#include<vector>
#include<deque>
#include<algorithm>
#include<stack>
using namespace std;
//stack栈容器的常用接口
void test01()
{
//特点:先进后出的数据结构
stack<int>s1;
//入栈
s1.push(10);
s1.push(20);
s1.push(30);
s1.push(40);
s1.push(50);
cout << "栈的大小: " << s1.size() << endl;
//只要栈不为空,我们就查看栈顶,并且执行出栈操作
while (!s1.empty())
{
//查看栈顶元素
cout << "栈顶元素为:" << s1.top() << endl;
//出栈
s1.pop();
}
cout << "栈的大小: " << s1.size() << endl;
}
int main()
{
test01();
return 0;
}queue容器
概念:Queue是一种先进先出的数据结构,有两个出口
#include<iostream>
#include<vector>
#include<deque>
#include<algorithm>
#include<stack>
#include<queue>
using namespace std;
void test01()
{
//创建一个容器
queue<int>q;
//入队
q.push(10);
q.push(20);
q.push(30);
q.push(40);
//判断只要队列不为空,查看对头和队尾,出队
while (!q.empty())
{
//查看对头
cout << "对头 : " << q.front() << endl;
//查看队尾
cout << "队尾 : " << q.back() << endl;
q.pop();
}
cout << "队列的大小为" << q.size() << endl;
}
int main()
{
test01();
system("pause");
return 0;
}list链表
1.构造函数
#include<iostream>
#include<vector>
#include<deque>
#include<algorithm>
#include<stack>
#include<queue>
#include<list>
using namespace std;
//list容器构造函数
void printList(const list<int>& L)
{
for (list<int>::const_iterator it = L.begin(); it != L.end(); it++)
{
cout << *it << endl;
}
}
void test01()
{
//创建list容器
list<int>L1;//默认构造
L1.push_back(10);
L1.push_back(20);
L1.push_back(30);
L1.push_back(40);
L1.push_back(50);
//遍历容器
printList(L1);
//区间方式构造
list<int>L2(L1.begin(), L1.end());
printList(L2);
//拷贝构造
list<int>L3(L2);
printList(L3);
//n个elem
list<int>L4(10, 1000);
printList(L4);
}
int main()
{
test01();
return 0;
}list构造方式和其他几个都是一样的
2.list赋值和交换
#include<iostream>
#include<vector>
#include<deque>
#include<algorithm>
#include<stack>
#include<queue>
#include<list>
using namespace std;
//list容器构造函数
void printList(const list<int>& L)
{
for (list<int>::const_iterator it = L.begin(); it != L.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void test01()
{
//创建list容器
list<int>L1;//默认构造
L1.push_back(10);
L1.push_back(20);
L1.push_back(30);
L1.push_back(40);
L1.push_back(50);
printList(L1);
//operator=数值
list<int>L2;
L2 = L1;
printList(L2);
list<int>L3;
L3.assign(L2.begin(), L2.end());
printList(L3);
list<int>L4;
L4.assign(10, 100);
printList(L4);
}
//交换
void test02()
{
list<int>L1;
L1.push_back(10);
L1.push_back(20);
L1.push_back(30);
L1.push_back(40);
L1.push_back(50);
list<int>L2;
L2.assign(10, 100);
cout << "交换前: " << endl;
printList(L1);
printList(L2);
//交换
L1.swap(L2);
cout << "交换后: " << endl;
printList(L1);
printList(L2);
}
int main()
{
test02();
return 0;
}3.list大小操作
#include<iostream>
#include<vector>
#include<deque>
#include<algorithm>
#include<stack>
#include<queue>
#include<list>
using namespace std;
//list容器构造函数
void printList(const list<int>& L)
{
for (list<int>::const_iterator it = L.begin(); it != L.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void test01()
{
//创建list容器
list<int>L1;//默认构造
L1.push_back(10);
L1.push_back(20);
L1.push_back(30);
L1.push_back(40);
L1.push_back(50);
printList(L1);
if (L1.empty())//判断链表是否为空
{
cout << "L1为空" << endl;
}
else {
cout << "L1不为空" << endl;
cout << "L1的元素个数为:" << L1.size() << endl;//输出列表的个数
}
//重新指定大小
L1.resize(10);//默认为0;如果原链表不够,那么会拓展原链表,增加的空间填充0
printList(L1);
L1.resize(2);//如果原链表大于resize的空间,那就将后面的舍去
printList(L1);
}
int main()
{
test01();
return 0;
}4.list插入和删除操作
函数原型：
· push _ back ( elem );/／在容器尾部加入一个元素
. pop _ back ():/／删除容器中最后一个元素
· push _ front ( elem ):/／在容器开头插入一个元素
· pop . front ():/／从容器开头移除第一个元素
insert ( pos , elem );/／在 pos 位置(用迭代器去找到)插入 elem 元素的拷贝，返回新数据的位置.insert ( pos , n , elem );/／在 pos 位置(用迭代器找到)插入 n 个 elem 数据，无返回值。
· insert ( pos , beg , end );/／在 pos 位置(用迭代器)插入［ beg , end ）区间的数据，无返回值。
· clear ();/／移除容器的所有数据
· erase ( beg , end ):/／删除（ beg , end ）区间的数据，返回下一个数据的位置。· erase ( pos );/／删除 pos 位置(用迭代器)的数据，返回下一个数据的位置。
· remove ( elem）; //删除容器中所有与 elem 值匹配的元素。
#include<iostream>
#include<vector>
#include<deque>
#include<algorithm>
#include<stack>
#include<queue>
#include<list>
using namespace std;
//list容器构造函数
void printList(const list<int>& L)
{
for (list<int>::const_iterator it = L.begin(); it != L.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void test01()
{
//创建list容器
list<int>L1;//默认构造
//尾插
L1.push_back(10);
L1.push_back(20);
//头插
L1.push_front(30);
L1.push_front(40);
L1.push_front(50);
printList(L1);
//尾删
L1.pop_back();
printList(L1);
//头删
L1.pop_front();
printList(L1);
//insert插入
//L1.insert(L1.begin(), 1000);
list<int>::iterator it = L1.begin();//只能++
L1.insert(++it, 1000);
printList(L1);
//删除
it = L1.begin();
L1.erase(++it);//it只能++操作
printList(L1);
//移除
L1.push_back(10000);
printList(L1);
L1.remove(10000);//将所有等于10000的元素都删了
printList(L1);
}
int main()
{
test01();
return 0;
}5.数据的存取
特别注意:list中的元素不能跳跃式的访问
#include<iostream>
#include<vector>
#include<deque>
#include<algorithm>
#include<stack>
#include<queue>
#include<list>
using namespace std;
//list容器构造函数
void printList(const list<int>& L)
{
for (list<int>::const_iterator it = L.begin(); it != L.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void test01()
{
//创建list容器
list<int>L1;//默认构造
//尾插
L1.push_back(10);
L1.push_back(20);
//头插
L1.push_front(30);
L1.push_front(40);
L1.push_front(50);
printList(L1);
cout << "第一个元素为: " << L1.front() << endl;
cout << "最后一个元素为: " << L1.back() << endl;
//验证迭代器是不支持随机访问的
list<int>::iterator it = L1.begin();
//it = it + 1;这是错误的,+2/+3多是错的❌
it++;//✔因为可以++和--所以是支持双向操作的
it--;//✔
}
int main()
{
test01();
return 0;
}L1[0]是不能直接访问的list容器中的元素
还有L1.at(0)也不行的
这种直接用迭代器+2或者加别的数,都会报错,迭代器只能++或者--
原因是list本质是一个链表,不能用连续线性空间存储数据
6.list的反转和排序
#include<iostream>
#include<vector>
#include<deque>
#include<algorithm>
#include<stack>
#include<queue>
#include<list>
using namespace std;
//list容器构造函数
void printList(const list<int>& L)
{
for (list<int>::const_iterator it = L.begin(); it != L.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
bool myCompare(int v1,int v2)//返回值是一个bool类型的
{
//降序,就让第一个数>第二个数
return v1 > v2;
}
void test01()
{
//创建list容器
list<int>L1;//默认构造
//尾插
L1.push_back(10);
L1.push_back(20);
//头插
L1.push_front(30);
L1.push_front(40);
L1.push_front(50);
cout << "反转前的: " << endl;
printList(L1);
L1.reverse();
cout << "反转后: " << endl;
printList(L1);
//排序
cout << "排序前: " << endl;
printList(L1);
//所以不支持随机访问迭代器的容器,不支持标准算法
//不支持随机访问迭代器的容器,内部会提供对一些算法
//sort(L1.begin(),L1.end());❌
L1.sort();//✔//默认排序规则,从小到大,升序
printList(L1);
//想要进行降序排序,就要先去定义一个降序函数,就按照这样写就行
L1.sort(myCompare);
printList(L1);
}
int main()
{
test01();
return 0;
}
1907
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
