STL之不定长数组vector（C++）

1、vector - - - 不定长数组

（1）vector 的说明

它能够像容器一样存放各种类型的对象，简单地说，vector是一个能够存放任意类型的动态数组，能够增加和压缩数据。

vector在C++标准模板库中的部分内容，它是一个多功能的，能够操作多种数据结构和算法的模板类和函数库。

它在头文件#include <vector>里面，也在命名空间using namespace std里面，所以使用的时候需要引入头文件#include <vector>和using namespace std

（2）vector 的定义

#include <iostream>
#include <vector>

using namespace std;

int main(){
	vector <int> v1; //定义一个不定长数组 v1 ，定义时没有分配大小
	cout << v1.size(); //输出 v1 的大小， 此时应为 0； 
	return 0;
}

vector可以一开始不定义大小，之后用resize()方法定义大小，也可以在定义时就定义大小，之后还可以对它进行插入或删除元素改变大小。

无论在全局中定义还是在main()中定义，vector都直接将所有值初始化为0

	vector <int> v2(10); //直接定义长度为 10 的 int 数组，默认这 10 个元素值都为 0
	
	//或者
	vector <int> v3;
	v3.resize(10); //先定义 v2，然后将长度 resize 为 10 ，默认这 10 个元素值都是0
	
	//在定义的时候就可以对 vector 变量进行初始化
	vector <int> v4(20, 5); //把 20 长度的数组中所有的值都初始化为9

	//定义一个二维数组
	vector< vector<int> > array(4); //定义一个行数为 4 的 vector 
    for(int i=0;i<4;i++) {
        array[i].resize(5); //列数为 5 
    }
    //输出二维数组的行和列 
    cout << "Row:" << array.size() << "  Column:" << array[0].size() << endl;

2、vector 常用内置函数

a.size(); //返回a中元素的个数
a.resize(10); //将a的现有元素个数调整至10个，多则删，少则补，其值随机
a.resize(10,2); //将a的现有元素个数调整至10个，多则删，少则补，其值为2
a.push_back(); //在a的最后一个向量后插入一个元素
a.pop_back(); //删除a的最后一个元素
a[i]; //返回a的第i元素,当且仅当a存在

例如：

#include <iostream>
#include <vector>

using namespace std;

int main(){
	vector <int> a; //定义时，不指定vector大小 
	cout << a.size() << endl; //此时，a.size为0 
	
	for(int i=0; i<10; i++){
		a.push_back(i); //在 vector a 的末尾添加一个元素 i 
	}
	cout << a.size() << endl; //此时，a.size 为 10 
	
	a.pop_back(); //删除 vector a 的末尾元素 
	cout << a.size() << endl; //此时，a.size 为 9 
	
	vector <int> b(15); //定义时，指定 vector b 大小为 15 ，此时所有值为0 
	cout << b.size() << endl; //此时，b.size为 15 
	for(int i=0; i<b.size(); i++){
		b[i] = 14; // 将 vector b 的所有值初始化为 14 
	}
	for(int i=0; i<b.size(); i++){
		cout << b[i] << " "; //输出 vector b 
	}
	
	return 0;
} 

除以上常用代码，vector 还具有以下常用内置函数：

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[i]存在2013-12-07
a.clear(); //清空a中的元素
a.empty(); //判断a是否为空，空则返回ture,不空则返回false
a.erase(a.begin()+1,a.begin()+3); //删除a中第1个（从第0个算起）到第2个元素，也就是说删除的元素从a.begin()+1算起（包括它）一直到a.begin()+ 3（不包括它）
a.insert(a.begin()+1,5); //在a的第1个元素（从第0个算起）的位置插入数值5，如a为1,2,3,4，插入元素后为1,5,2,3,4
a.insert(a.begin()+1,3,5); //在a的第1个元素（从第0个算起）的位置插入3个数，其值都为5
a.insert(a.begin()+1,b+3,b+6); //b为数组，在a的第1个元素（从第0个算起）的位置插入b的第3个元素到第5个元素（不包括b+6），如b为1,2,3,4,5,9,8，插入元素后1,4,5,9,2,3,4,5,9,8
a.capacity(); //返回a在内存中总共可以容纳的元素个数
a.reserve(100); //将a的容量（capacity）扩充至100，也就是说现在测试a.capacity();的时候返回值是100.这种操作只有在需要给a添加大量数据的时候才显得有意义，因为这将避免内存多次容量扩充操作（当a的容量不足时电脑会自动扩容，当然这必然降低性能） 
a.swap(b); //b为向量，将a中的元素和b中的元素进行整体性交换
a==b; //b为向量，向量的比较操作还有!=,>=,<=,>,<

3、vector 的访问方式

（1）使用下标访问元素：

vector <int> b(10,2);
for(int i=0; i<b.size(); i++){
		cout << b[i] << " "; //输出 vector b 
	}

（2）使用迭代器访问元素：

vector <int> c(6,13);
	for(vector<int>::iterator  it = c.begin(); it != c.end(); it++){
		cout << *it << " ";
	}

c.begin() 是⼀个指针，指向容器的第⼀个元素， c.end() 指向容器的最后⼀个元素的后⼀个位置，所以迭代器指针 it 的for循环判断条件是 it != c.end()

访问元素的值要对 it 指针取值，要在前⾯加星号～所以是 cout << *it;

4、vector 添加元素的方式

（1）向向量a中添加元素

vector <int> a;
for(int i=0; i<15; i++)
	a.push_back(i);

（2）从数组中选择元素向向量中添加

int b[5] = {1,2,3,4,5};
vector <int> c;
for(int i=0; i<5; i++){
	c.push_back(b[i]);
}

（3）从现有vector中选择元素向vector中添加

int d[7] = {2,4,6,8,10,12,14};
vector <int> e;
vector <int> f(d, d+4);
for(vector <int> :: iterator it=f.begin(); it<f.end(); it++){
	e.push_back(*it);
}

（4）从文件中读取元素向向量中添加

ifstream in("data.txt");
vector <int> g;
for(int i; in>>i){
	g.push_back(i);
}

（5）常见错误赋值方式

vector<int> h;
for(int i=0; i<10; i++){
	h[i]=i;
}//下标只能用来获取已经存在的元素

5、vector 常用的算法

 #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);

6、vector 的应用

（1）、木块问题（The Blocks Problem，Uva 101）

题目描述
从左到右有n个木块，编号为0～n-1，要求模拟以下4种操作（下面的a和b都是木块编号）。
move a onto b：把a和b上方的木块全部归位，然后把a摞在b上面。
move a over b：把a上方的木块全部归位，然后把a放在b所在木块堆的顶部。
pile a onto b：把b上方的木块全部归位，然后把a及上面的木块整体摞在b上面。
pile a over b：把a及上面的木块整体摞在b所在木块堆的顶部。
遇到quit时终止一组数据。a和b在同一堆的指令是非法指令，应当忽略。

输入
输入以一行中的一个整数n开始，它本身表示块中的块数
世界。你可以假设0 < n < 25。块数后面是一系列块命令，每行一个命令。你的程序应该处理所有命令，直到遇到退出命令。您可以假设所有命令都是上面指定的形式。不会有句法上的不正确的命令。
输出
输出应该由积木世界的最终状态组成。每个原始块位置都有编号 i (0 ≤ i < n)，其中n是块数)应紧跟冒号后出现。如果有至少是一个块，冒号后面必须跟一个空格，后面跟一个出现的块列表堆叠在该位置，每个块号与其他块号相隔一个空格。不要将任何尾随空格放在一行上。每个块位置应该有一行输出(即n行输出，其中n是输入第一行的整数)。

样例输入
10
move 9 onto 1
move 8 over 1
move 7 over 1
move 6 over 1
pile 8 over 6
pile 8 over 5
move 2 over 1
move 4 over 9
quit

样例输出
0: 0
1: 1 9 2 4
2:
3: 3
4:
5: 5 8 7 6
6:
7:
8:
9:

代码

#include <iostream>
#include <string>
#include <vector>
#include <iostream>
#include <cstdio>

using namespace std;

const int maxn = 30;
int n;
vector<int> pile[maxn]; //每个 pile[i] 是一个 vector
 
//找木块 a 所在的 pile 和 height, 即木块 a 的位置以引用的形式返回调用者 
void find_block(int a, int& p, int& h){
	for(p = 0; p < n; p++)
		for(h = 0; h < pile[p].size(); h++)
			if(pile[p][h] == a) 
				return;
}

//把第 p 堆高度为 h 的木块上方的所有木块移回原位 
void clear_above(int p, int h){
	for(int i=h+1; i<pile[p].size(); i++){
		int b = pile[p][i];
		pile[b].push_back(b);
	}
	pile[p].resize(h+1);
}

//把第 p 堆高度为 h 及其上方的木块整体移动到 p2 堆的顶部
void pile_onto(int p, int h, int p2){
	for(int i=h; i<pile[p].size(); i++)
		pile[p2].push_back(pile[p][i]); // 把木块 b 放回原位 
	pile[p].resize(h); //pile 只应保留 0~h 的元素 
}

//输出结果
void print(){
	for(int i=0; i<n; i++){
		printf("%d:", i);
		for(int j=0; j<pile[i].size(); j++)
			printf(" %d", pile[i][j]);
		printf("\n");
	}
}

int main(){
	int a, b;
	cin >> n;
	string s1, s2;
	for(int i=0; i<n; i++) pile[i].push_back(i);
	
	while(cin >> s1 && s1 != "quit"){
		cin >> a >> s2 >> b;
		int pa, pb, ha, hb;
		find_block(a, pa, ha);
		find_block(b, pb, hb);
		
		if(pa == pb) continue; // 非法指令 ：即 a 和 b 不能在同一行 
		if(s2 == "onto") clear_above(pb, hb); // b 上方木块归位 
		if(s1 == "move") clear_above(pa, ha); // a 上方木块归位 
		pile_onto(pa, ha, pb); //  
	}
	
	print();
	return 0;
}

（2）、Ducci序列（Ducci Sequence, ACM/ICPC Seoul 2009, UVa1594）

Ducci Sequence

题目描述
对于一个n元组(a1, a2, …, an)，可以对于每个数求出它和下一个数的差的绝对值，得到一个新的n元组(|a1-a2|, |a2-a3|, …, |an-a1|)。重复这个过程，得到的序列称为Ducci序列，例如：
(8, 11, 2, 7) -> (3, 9, 5, 1) -> (6, 4, 4, 2) -> (2, 0, 2, 4) -> (2, 2, 2, 2) -> (0, 0, 0, 0).
也有的Ducci序列最终会循环。输入n元组（3≤n≤15），你的任务是判断它最终会变成0还是会循环。输入保证最多1000步就会变成0或者循环。

输入
你的程序是从标准输入中读取输入。输入由测试用例组成。号码在输入的第一行给出了测试用例。每个测试用例都以一行包含整数n (3 ≤ n ≤ 15)，表示Ducci序列中元组的大小。在下面行，给出n个整数，代表整数的n元组。整数的范围从0到1,000.你可以假设一个杜奇序列到达零元组的最大步数或者循环不超过1000次。

输出
你的程序是写标准输出。为每个测试用例打印一行。如果Ducci序列属于周期性循环，则打印“LOOP”，如果Ducci序列到达零元组，则打印“ZERO”。

样例输入
4
4
8 11 2 7
5
4 2 0 2 0
7
0 0 0 0 0 0 0
6
1 2 3 1 2 3

样例输出
ZERO
LOOP
ZERO
LOOP

代码

#include <iostream>
#include <vector>
#include <set>
#include <cmath>
#include <cstdio>

using namespace std;

int readint(){
    int x;
    cin >> x;
    return x;
}

int main(){
    int T = readint();

    vector<int> seq, zeroSeq; //seq:输入的元组;    seroSeq：“零”元组.
    set<vector<int> > seqs;   //seqs:  存放元组的每一次变化

    while(T--){
        int n = readint();
        seq.clear(), zeroSeq.resize(n);
        for(int i = 0; i < n; i++)
            seq.push_back(readint()); //输入元组

        seqs.clear(), seqs.insert(seq); //清空上一个Ducci序列，存入本次初始元组

        do{
            //判断是否为“零”元组；若是，则输出 ZERO。
            if(seq == zeroSeq){
                puts("ZERO");
                break;
            }

            //序列运算
            int a0 = seq[0];
            for(int i = 0; i < n; i++){
                if(i == n-1) seq[i] = abs(seq[i] - a0);
                else seq[i] = abs(seq[i] - seq[i+1]);
            }

            //判断新的元组在seqs记录的元组中已存在，若已存在，说明进入循环，输出LOOP。
            if(seqs.count(seq)){
                puts("LOOP");
                break;
            }
            seqs.insert(seq); //记录元组的每一次变化
        }while(true);

    }

    return 0;
}