文章目录
 
1. vector：
1.1 vector 说明
1.2 vector初始化：
1.3 vector对象的常用内置函数使用（举例说明）
   
   
2. 顺序访问vector的几种方式，举例说明
2.1. 对向量a添加元素的几种方式
2.2 从向量中读取元素
   
   
3.几个常用的算法
4. 写在最后
 

 
1. vector：
 
1.1 vector 说明
 
vector是向量类型，可以容纳许多类型的数据，因此也被称为容器
(可以理解为动态数组，是封装好了的类）
进行vector操作前应添加头文件#include <vector>
 
1.2 vector初始化：
 
方式1.
 
//定义具有10个整型元素的向量（尖括号为元素类型名，它可以是任何合法的数据类型），不具有初值，其值不确定
vector<int>a(10);
 
方式2.
 
//定义具有10个整型元素的向量，且给出的每个元素初值为1
vector<int>a(10,1);
 
方式3.
 
//用向量b给向量a赋值，a的值完全等价于b的值
vector<int>a(b);
 
方式4.
 
//将向量b中从0-2（共三个）的元素赋值给a，a的类型为int型
vector<int>a(b.begin(),b.begin+3);
 
方式5.
 
 //从数组中获得初值
int b[7]={1,2,3,4,5,6,7};
vector<int> a(b,b+7）;
 
1.3 vector对象的常用内置函数使用（举例说明）
 
#include<vector>
vector<int> a,b;
//b为向量，将b的0-2个元素赋值给向量a
a.assign(b.begin(),b.begin()+3);
//a含有4个值为2的元素
a.assign(4,2);
//返回a的最后一个元素
a.back();
//返回a的第一个元素
a.front();
//返回a的第i元素,当且仅当a存在
a[i];
//清空a中的元素
a.clear();
//判断a是否为空，空则返回true，非空则返回false
a.empty();
//删除a向量的最后一个元素
a.pop_back();
//删除a中第一个（从第0个算起）到第二个元素，也就是说删除的元素从a.begin()+1算起（包括它）一直到a.begin()+3（不包括它）结束
a.erase(a.begin()+1,a.begin()+3);
//在a的最后一个向量后插入一个元素，其值为5
a.push_back(5);
//在a的第一个元素（从第0个算起）位置插入数值5,
a.insert(a.begin()+1,5);
//在a的第一个元素（从第0个算起）位置插入3个数，其值都为5
a.insert(a.begin()+1,3,5);
//b为数组，在a的第一个元素（从第0个元素算起）的位置插入b的第三个元素到第5个元素（不包括b+6）
a.insert(a.begin()+1,b+3,b+6);
//返回a中元素的个数
a.size();
//返回a在内存中总共可以容纳的元素个数
a.capacity();
//将a的现有元素个数调整至10个，多则删，少则补，其值随机
a.resize(10);
//将a的现有元素个数调整至10个，多则删，少则补，其值为2
a.resize(10,2);
//将a的容量扩充至100，
a.reserve(100);
//b为向量，将a中的元素和b中的元素整体交换
a.swap(b);
//b为向量，向量的比较操作还有 != >= > <= <
a==b;
 
2. 顺序访问vector的几种方式，举例说明
 
2.1. 对向量a添加元素的几种方式
 
1.向向量a中添加元素
 
vector<int>a;
for(int i=0;i<10;++i){a.push_back(i);}
 
2.从数组中选择元素向向量中添加
 
int a[6]={1,2,3,4,5,6};
vector<int> b;
for(int i=0;i<=4;++i){b.push_back(a[i]);}
 
3.从现有向量中选择元素向向量中添加
 
int a[6]={1,2,3,4,5,6};
vector<int>b;
vector<int>c(a,a+4);
for(vector<int>::iterator it=c.begin();it<c.end();++it)
{
	b.push_back(*it);
}
 
4.从文件中读取元素向向量中添加
 
ifstream in("data.txt");
vector<int>a;
for(int i;in>>i){a.push_back(i);}
 
5.常见错误赋值方式
 
vector<int>a;
for(int i=0;i<10;++i){a[i]=i;}//下标只能用来获取已经存在的元素
 
2.2 从向量中读取元素
 
1.通过下标方式获取
 
int a[6]={1,2,3,4,5,6};
vector<int>b(a,a+4);
for(int i=0;i<=b.size()-1;++i){cout<<b[i]<<endl;}
 
2.通过迭代器方式读取
 
 int a[6]={1,2,3,4,5,6};
 vector<int>b(a,a+4);
 for(vector<int>::iterator it=b.begin();it!=b.end();it++){cout<<*it<<"  ";}
 
3.几个常用的算法
 
 #include<algorithm>
 //对a中的从a.begin()（包括它）到a.end()（不包括它）的元素进行从小到大排列
 sort(a.begin(),a.end());
 //对a中的从a.begin()（包括它）到a.end()（不包括它）的元素倒置，但不排列，如a中元素为1,3,2,4,倒置后为4,2,3,1
 reverse(a.begin(),a.end());
  //把a中的从a.begin()（包括它）到a.end()（不包括它）的元素复制到b中，从b.begin()+1的位置（包括它）开始复制，覆盖掉原有元素
 copy(a.begin(),a.end(),b.begin()+1);
 //在a中的从a.begin()（包括它）到a.end()（不包括它）的元素中查找10，若存在返回其在向量中的位置
  find(a.begin(),a.end(),10);
 
4. 写在最后
 
本人已经毕业半年有余，深刻感受到生活不易，之前更新博客的时候从没想到自己的博客会有这么多人喜欢，在这里感谢各位朋友的信任，同时也祝福各位同学前程似锦，学业进步!
 
同时，在这里出售全套的文字学习资料：
 
具体包括《C primer plus》原文、练习及源代码；C语言具体各部分详解书籍；
 
《C++ primer plus》原文、练习及源代码；各种C++相关书籍；
 
《数据结构 C++ 语言描述》《数据结构 C 语言描述》《数据结构》严蔚敏版；数据结构相关书籍；
 
《powershell 入门教程》；《剑指offer 第二版》原文及源代码；《深入了解计算机系统》中文版，布莱恩特著，等等书籍；
 
全套资料售价￥68.8，单套￥19.9

  
 
vector 的插入及基本要素
 
 
 
#include <stdio.h>
#include <iostream>//cin>> cout<< 必备
#include <vector>//vector 必备
using namespace std;
int main()
{
    int a[1000];
    vector<int> v;//定义一个容器数组
    vector<int> ::iterator it;//定义一个vector（容器数组）类型的迭代器指针，此指针具有指向vector容器数组的作用
   for(int i=0;i<10;i++)
   {
       cin>>a[i];//输入a[i]
      v.push_back(a[i]);//把a[i]输入v容器数组里
   }

   for(it=v.begin();it!=v.end();it++)//v.begin()是vector容器数组的初始下标；v.end()是vector容器数组的终止元素的下一位，为空；it指针从初始开始指向.....
   {
       if(*it==0)//当it指向0时；
       {
                  v.insert(it,3);//把3插入it（0）前 //也可写成 v.insert(v.begin()+i,a) 或者 v.insert(v.end()+i,a) 把a插到v.begin()+i前面
                  it++;//it要++，否则陷入死循环，因为*it==0下标始终右移一位；
       }
    }
   for(it=v.begin();it!=v.end();it++)
   {
      cout<<*it<<"\n";//逐个输出*it（vector容器数组的元素）；
   }

return 0;
}


 
2 （区间）删除
 
#include <stdio.h>
#include <iostream>
#include <vector>
using namespace std;
int main()
{
    int a[1000];
    vector<int> v;
    vector<int> ::iterator it;
   for(int i=0;i<10;i++)
   {
      v.push_back(i);
   }
    v.erase(v.begin(),v.end()-1);//区间删除
   for(it=v.begin();it!=v.end();it++)
   {
      cout<<*it<<"\n";
   }
return 0;
}


 

  
 
3 字符数组
 
​
#include <stdio.h>
#include <iostream>
#include <vector>
using namespace std;
int main()
{
    char a[1000];
    vector<char> v;
    vector<char> ::iterator it;
   for(int i=0;i<5;i++)
   {
      cin>>a[i];
      v.push_back(a[i]);
   }
   v.erase(v.begin()+1,v.begin()+3);
   v.insert(v.begin()+1,'0');
   for(it=v.begin();it!=v.end();it++)
   {
      cout<<*it<<"\n";
   }
return 0;
}



​
 
 
 
 
 

  

Vector
        Vector非常类似ArrayList，都继承自AbstractList并且都实现了List接口，但是Vector是同步的。由Vector创建的Iterator，虽然和ArrayList创建的Iterator是同一接口，但是，因为Vector是同步的，当一个Iterator被创建而且正在被使用，另一个线程改变了Vector的状态（例如，添加或删除了一些元素），这时调用Iterator的方法时将抛出ConcurrentModificationException，因此必须捕获该异常。

        Vector实现List接口，所以里面的元素是有序的。
 向Vector中加入的元素add（）方法是有序的，后加入的排列在最后。
我们也可以调用add（int index，E element）方法向指定位置加入元素。
vector.elements()方法返回一个枚举类型，我们可以用来遍历整个vector。
vector.iterator()方法返回一个迭代器，同样可以用来遍历整个vector
vector.contains(E element)方法，如果vector中存在指定元素则返回true，否则false。
vector.get(int index)方法，返回指定位置的元素，如果超过vector的capacity则报错。
初始化vector时，默认不带参数的话，vector的初始capacity大小为10。当当前空间不足以加入新元素时，capacity会加倍，即从10变成20，40，80......
当然我们也可以使用下面两种带参数的构造
1.Vector vector=new Vector(int  capacity);指定初始化大小，不允许负数大小的初始化。如果初始化大小为0，则加入数据时大小变为1，然后每次扩充遵循加倍原则。
2.Vector vector=new Vector(int capacity,int increasesize)指定初始化大小，并且以后每次容量不足时，大小每次增加increasesize。


import java.util.Enumeration;
import java.util.Iterator;
import java.util.Vector;

public class Test {
    public static void main(String[] args){
        Vector vector=new Vector(0);
        System.out.println("vector的初始大小： "+vector.capacity());
        vector.add("大家好"); //Appends the specified element to the end of this Vector.
        vector.add("111");  //add方法将新元素加到末尾
        vector.add("222");
        vector.add("你好");               //elements()返回这个向量内所有元素的枚举
        Enumeration e=vector.elements();//Returns an enumeration of the components of this vector.
        System.out.println(vector.capacity());
        while(e.hasMoreElements()){
            System.out.println(e.nextElement());
        }
        System.out.println("---------分界线----------------------");
        vector.add(2,"我在第三位"); //add（int index，E element）将新元素加入到指定位置
        Iterator iterator=vector.iterator(); //使用迭代器
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
        for(int i=0;i<100;i++) {
            vector.add(i);
            System.out.print(vector.capacity()+" ");
            if(i%10==0) System.out.println();
        }
        System.out.println(vector.capacity());
        System.out.println(vector.contains("你好"));
        System.out.println(vector.get(2));
    }
}


运行结果：
vector的初始大小： 10
10
大家好
111
222
你好
---------分界线----------------------
大家好
111
我在第三位
222
你好
10 
10 10 10 10 20 20 20 20 20 20 
20 20 20 20 40 40 40 40 40 40 
40 40 40 40 40 40 40 40 40 40 
40 40 40 40 80 80 80 80 80 80 
80 80 80 80 80 80 80 80 80 80 
80 80 80 80 80 80 80 80 80 80 
80 80 80 80 80 80 80 80 80 80 
80 80 80 80 160 160 160 160 160 160 
160 160 160 160 160 160 160 160 160 160 
160 160 160 160 160 160 160 160 160 160
true
我在第三位
初始化大小为0
vector的初始大小： 0
capacity：1
capacity：2
capacity：4
capacity：4
大家好
111
222
你好
8 8 8 8 16 16 16 16 16 16 
16 16 32 32 32 32 32 32 32 32 
32 32 32 32 32 32 32 32 64 64 
64 64 64 64 64 64 64 64 64 64 
64 64 64 64 64 64 64 64 64 64 
64 64 64 64 64 64 64 64 64 64 
128 128 128 128 128 128 128 128 128 128 
128 128 128 128 128 128 128 128 128 128 
128 128 128 128 128 128 128 128 128 128 
128 128 128 128 128 128 128 128 128 128 
128
true
222

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

int main()  
{  
    vector<int> v(3);  
    v[0]=2; //v[0]是第0个元素 
    v[1]=7;  
    v[2]=9;  
    v.insert(v.begin(),8);//在最前面插入新元素。  
    v.insert(v.begin()+2,1);//在迭代器中第二个元素前插入新元素  
    v.insert(v.end(),3);//在向量末尾追加新元素。  

	v.insert(v.end(),4,1);//在尾部插入4个1

	int a[] = {1,2,3,4};
	v.insert(v.end(),a[1],a[3]);//在尾部插入a[1]个a[3]

    vector<int>::iterator it;  
    for(it=v.begin(); it!=v.end();it++)  
    {  
        cout<<*it<<" ";  
    }  
    cout<<endl;

	return 0;
}  

//8 2 1 7 9 3 1 1 1 1 4 4
//请按任意键继续. . .