STL-vector

Ⅰ.简述

vector容器被称为向量容器，是一种序列式容器。vector容器和数组非常相似，但比数组优越，vector实现的是一个动态数组，在进行元素的插入和删除的过程中，vector会动态调整所占用的内存空间。在容器头部或者中部插入或删除元素，时间复杂度为，在尾部插入或删除元素，时间复杂度为。

vector容器在创建之前，要包含如下内容

#include<vector>
using namespace std;

 

Ⅱ.具体操作

一.创建容器及赋予初值

vector<数据类型> 名称

创建的空vector容器内没有元素，所以没有为其分配空间，当添加第一个元素时，vector会自动分配内存。

	vector<int> v(10);
	//定义具有10个整型元素的向量（尖括号为元素类型名，它可以是任何合法的数据类型），不具有初值，其值不确定


	vector<int> v(10,1);
	//定义具有10个整型元素的向量，且给出的每个元素初值为1


    int num=20;
    double value =1.0;
    vector<double> values(num, value);
    //圆括号 () 中的 2 个参数，既可以是常量，也可以用变量来表示，


	vector<char>value1(5, 'c');
    vector<char>value2(value1);
	//用向量v1给向量v赋值，v的值完全等价于v1的值


    int b[7]={1,2,3,4,5,6,7};
    vector<int> a(b,b+7）;
    //从数组中获得初值

 

二.常用成员函数

#include<vector>

vector<int> a,b;

a.assign(b.begin(),b.begin()+3);
//b为向量，将b的0-2个元素赋值给向量a



a.assign(4,2);
//a含有4个值为2的元素



a.back();
//返回a的最后一个元素



a.front();
//返回a的第一个元素



a[i];
//返回a的第i元素,当且仅当a存在



a.clear();
//清空a中的元素



a.empty();
//判断a是否为空，空则返回true，非空则返回false，时间复杂度为O(1)



a.pop_back();
//删除a向量的最后一个元素



a.erase(a.begin()+1,a.begin()+3);
//删除a中第一个（从第0个算起）到第二个元素，也就是说删除的元素从a.begin()+1算起（包括它）一直到a.begin()+3（不包括它）结束



a.push_back(5);
//在a的最后一个向量后插入一个元素，其值为5



a.insert(a.begin()+1,5);
//在a的第一个元素（从第0个算起）位置插入数值5,



a.insert(a.begin()+1,3,5);
//在a的第一个元素（从第0个算起）位置插入3个数，其值都为5



a.insert(a.begin()+1,b+3,b+6);
//b为数组，在a的第一个元素（从第0个元素算起）的位置插入b的第三个元素到第5个元素（不包括b+6）



a.size();
//返回a中元素的个数，时间复杂度为O(1)


a.capacity();
//返回a在内存中总共可以容纳的元素个数



a.resize(10);
//将a的现有元素个数调整至10个，多则删，少则补，其值随机



a.resize(10,2);
//将a的现有元素个数调整至10个，多则删，少则补，其值为2



a.reserve(100);
//将a的容量扩充至100，



a.swap(b);
//b为向量，将a中的元素和b中的元素整体交换



a==b;
//b为向量，向量的比较操作还有 != >= > <= <

创建二维数组

#include <string.h>　
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;


int main()
{
    int N=5, M=6; 
    vector<vector<int> > obj(N, vector<int>(M)); //定义二维动态数组5行6列 

    for(int i=0; i< obj.size(); i++)//输出二维动态数组 
    {
        for(int j=0;j<obj[i].size();j++)
        {
            cout<<obj[i][j]<<" ";
        }
        cout<<"\n";
    }
    return 0;
}
输出：
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0

三.几个常用算法

 

 #include<algorithm>

 reverse(a.begin(),a.end());
//对a中的从a.begin()（包括它）到a.end()（不包括它）的元素倒置，但不排列，如a中元素为1,3,2,4,倒置后为4,2,3,1

  

 copy(a.begin(),a.end(),b.begin()+1);
//把a中的从a.begin()（包括它）到a.end()（不包括它）的元素复制到b中，从b.begin()+1的位置（包括它）开始复制，覆盖掉原有元素

sort的用法

#include<iostream>  
#include<vector>  
#include<algorithm>  
using namespace std;  
bool compare1(int a,int b){//升序 ，不能用void类型 
	return a<b;
}
bool compare2(int a,int b){//降序 ，同上 
	return a>b;
}
bool compare3(int a,int b){//降序 ，同上 
	return b<a;
}
bool compare4(int a,int b){//升序 ，同上 
	return b>a;
}


bool compare5(int b,int a){//降序 ，同上 
	return a<b;
}
bool compare6(int b,int a){//升序 ，同上 
	return a>b;
}
bool compare7(int b,int a){//升序 ，同上 
	return b<a;
}
bool compare8(int b,int a){//降序 ，同上 
	return b>a;
}



vector<int> a;  
int main(){
	a.push_back(9); 
	a.push_back(5);
	a.push_back(10);
	a.push_back(3);
	a.push_back(8);
	a.push_back(2);
	sort(a.begin(),a.end(),compare1);
	for(int i=0;i<a.size();i++)
	cout<<a[i]<<' ';
	cout<<endl<<endl;
	
	sort(a.begin(),a.end(),compare2);
	for(int i=0;i<a.size();i++)
	cout<<a[i]<<' ';
	cout<<endl<<endl;
	
	sort(a.begin(),a.end(),compare3);
	for(int i=0;i<a.size();i++)
	cout<<a[i]<<' ';
	cout<<endl<<endl;
	
	sort(a.begin(),a.end(),compare4);
	for(int i=0;i<a.size();i++)
	cout<<a[i]<<' ';
	cout<<endl<<endl;
	
	sort(a.begin(),a.end(),compare5);
	for(int i=0;i<a.size();i++)
	cout<<a[i]<<' ';
	cout<<endl<<endl;
	
	sort(a.begin(),a.end(),compare6);
	for(int i=0;i<a.size();i++)
	cout<<a[i]<<' ';
	cout<<endl<<endl;
	
	sort(a.begin(),a.end(),compare7);
	for(int i=0;i<a.size();i++)
	cout<<a[i]<<' ';
	cout<<endl<<endl;
	
	sort(a.begin(),a.end(),compare8);
	for(int i=0;i<a.size();i++)
	cout<<a[i]<<' ';
	cout<<endl<<endl;
	
    return 0;  
}  

find的使用

#include <vector>
#include <algorithm>
#include <iostream>

int main( )
{
    using namespace std;

    vector<int> L;
    L.push_back( 1 );
    L.push_back( 2 );
    L.push_back( 3 );
    L.push_back( 4 );
    L.push_back( 5 );
    vector<int>::iterator it = find( L.begin( ), L.end( ), 3 ); //查找3
    int pos = find( L.begin(), L.end(), 3 )-L.begin();//用于返回查找到的3的位置
    if ( it == L.end( ) ) //没找到
        cout << "No" << endl;
    else{
    	cout << "Yes" << endl;
    	cout << *it   << endl;//返回it=3的数值 
		cout << pos   << endl;//不能直接用it，必须重新定义
	} 

}

lower_bound()的用法

与find()的几乎相同，求的是区间里第一个大于或等于查找值的位置（大小）