数组Array

1.C++数组

• 数组的定义：在连续的内存空间中，存储一组相同类型的元素
• 数组的访问: 通过索引访问元素，数组下标(索引)从0开始。内存空间是连续的，增删需要移动后面的元素
• 数组的搜索：找到这个元素对应的索引

1.1复杂度

• 访问Access:Ｏ(1)
  通过下标(索引)可以得到地址位置，从而进行访问
• 搜索search:O(N)
  需要对数组进行遍历
• 插入insert: O(N)
  需要将后面的元素往后移动
  如果内存不够，需要开辟一块新空间，将数组移进去
• 删除delete: O(N)
  需要将后面元素往前移

1.2特点

• 适合读
• 不适合频繁做增删操作
• 适用场景：读多写少

Array 是固定大小的，不能额外增加元素
当我们想定义不固定大小的字符时,可以使用 vector(向量) 标准库。

实例

#include 
#include 
using namespace std;
 
int main() {
   // 创建向量用于存储整型数据
   vector<int> vec; 
   int i;

   // 显示 vec 初始大小
   cout << "vector size = " << vec.size() << endl;

   // 向 向量 vec 追加 5 个整数值
   for(i = 0; i < 5; i++){
      vec.push_back(i);
      //push_back() 在Vector最后添加一个元素（参数为要插入的值）
   }

   // 显示追加后 vec 的大小
   cout << "extended vector size = " << vec.size() << endl;

   return 0;
}

vector 的大小随着 for 循环的输入而增大。
执行以上代码，输出结果：

vector size = 0
extended vector size = 5

2.Vector

2.1 vector说明

• vector是向量类型，可以容纳许多类型的数据，因此也被称为容器
• (可以理解为动态数组，是封装好了的类）
• 进行vector操作前应添加头文件#include

2.1.1 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）;

2.1.2 举例说明vector对象的常用内置函数使用

#include
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.2 举例说明顺序访问vector的几种方式

2.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.从文件中读取元素向向量中添加

析取器(>>)

从流中输入数据。比如说系统有一个默认的标准输入流(cin)，一般情况下就是指的键盘，所以，cin>>x;就表示从标准输入流中读取一个指定类型的数据。

在C++中，对文件的操作是通过stream的子类fstream(file stream)来实现的，所以，要用这种方式操作文件，就必须加入头文件fstream.h

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

5.几个常用的算法

#include
 //对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);

2.2.2 C++ #include

标准模板库：算法
头文件定义了一组专门设计用于元素范围的函数集合。

范围是可以通过迭代器或指针访问的任何对象序列，例如数组或某些STL容器的实例。 但是请注意，算法通过迭代器直接对值进行操作，而不以任何方式影响任何可能容器的结构（它从不影响容器的大小或存储分配）

具体包括 1、非修改序列操作 2、修改序列的操作 3、分区操作 4、排序操作 5、二分查找操作 6、合并操作 7、堆操作 8、最大最小值操作 9、其它操作

这里列举几个常见操作：
1、reverse()

// reverse algorithm example
#include      // std::cout
#include     // std::reverse
#include        // std::vector
 
int main () {
  std::vector<int> myvector;
 
  // set some values:
  for (int i=1; i<10; ++i) myvector.push_back(i);   // 1 2 3 4 5 6 7 8 9
 
  std::reverse(myvector.begin(),myvector.end());    // 9 8 7 6 5 4 3 2 1
 
  // print out content:
  std::cout << "myvector contains:";
for (std::vector<int>::iterator it=myvector.begin(); it!=myvector.end(); ++it)
    std::cout << ' ' << *it;
    std::cout << '\n';
 
  return 0;
}

输出结果：

myvector contains: 9 8 7 6 5 4 3 2 1

2、next_permutation()，返回大于等于当前序列的全排列

#include 
#include 
using namespace std;
int main(){
    int a[3]={1, 2, 3};
    printf("%d %d %d\n",a[0],a[1],a[2]);
    while(next_permutation(a,a+3)){
        printf("%d %d %d\n",a[0],a[1],a[2]);
    }
    return 0;
}

输出结果：

1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1

如果将输入序列变成，3，1， 2 ，那么最后全排列的结果就发生了变化

3 1 2
3 2 1

3、sort()

// sort algorithm example
#include      // std::cout
#include     // std::sort
#include        // std::vector
 
bool myfunction (int i,int j) { return (i<j); }
 
struct myclass {
  bool operator() (int i,int j) { return (i<j);}
} myobject;
 
int main () {
  int myints[] = {32,71,12,45,26,80,53,33};
  std::vector<int> myvector (myints, myints+8);               
  // 32 71 12 45 26 80 53 33
 
  // using default comparison (operator <):
  std::sort (myvector.begin(), myvector.begin()+4);           
  //(12 32 45 71)26 80 53 33
 
  // using function as comp
  std::sort (myvector.begin()+4, myvector.end(), myfunction); 
  // 12 32 45 71(26 33 53 80)
 
  // using object as comp
  std::sort (myvector.begin(), myvector.end(), myobject);     
  //(12 26 32 33 45 53 71 80)
 
  // print out content:
  std::cout << "myvector contains:";
  for (std::vector<int>::iterator it=myvector.begin(); it!=myvector.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';
 
  return 0;
}

输出结果如下：

myvector contains: 12 26 32 33 45 53 71 80

sort实例：
为了展示sort的实际应用场景，这里再加一个案例。

设计一个英雄的结构体，包括成员姓名，年龄，性别;创建结构体数组，数组中存放5名英雄。

通过冒泡排序的算法，将数组中的英雄按照年龄进行升序排序，最终打印排序后的结果。
五名英雄信息如下：

	{"刘备",23,"男"},
	{"关羽",22,"男"},
	{"张飞",20,"男"},
	{"赵云",21,"男"},
	{"貂蝉",19,"女"},

首先定义Hero.h

#pragma once
#ifndef HERO_TYPE_01_
#define HERO_TYPE_01_
#include 
#include 
struct Hero
{
	std::string name;
	int age;
	bool sex;
};
 
void sort_hero(Hero heros[], int len);
void print_hero_list(Hero heros[], int len);
 
#endif

然后是Hero.cpp关于Hero.h的实现

#include "hero.h"
#include 
#include 
bool myfunc(Hero HA, Hero HB)
{
	return HA.age > HB.age;
}
 
void sort_hero(Hero heros[], int len)
{
// 定义一个vector向量，将结构体的数据放入到vector,
//在algorithm的参数里面要求为Random-access iterators
	std::vector<Hero>vec_heros(heros, heros + len);
	// 通过内置算法进行排序
	std::sort(vec_heros.begin(), vec_heros.end(), myfunc);
	// 将排序的vector结果拷贝给heros数组
	for (size_t i = 0; i < len; i++)
	{
		heros[i] = vec_heros[i];
	}
}
 
void print_hero_list(Hero heros[], int len)
{
	for (size_t i = 0; i < len; i++)
	{
		std::cout << "name=" << heros[i].name << " age=" << heros[i].age << " sex=" << heros[i].sex << std::endl;
	}
}

主函数

#include 
#include "hero.h"
using namespace std;
 
int main()
{
	struct Hero heros[5] = {
		{ "刘备",23,"男" },
		{ "关羽",22,"男" },
		{ "张飞",20,"男" },
		{ "赵云",21,"男" },
		{ "貂蝉",19,"女" },
	};
 
	int len = sizeof(heros) / sizeof(Hero); //获取数组元素个数
 
	sort_hero(heros, len); //排序
 
	print_hero_list(heros, len); //打印
 
	system("pause");
	return 0;
}

输出结果：

name=刘备 age=23 sex=1
name=关羽 age=22 sex=1
name=张飞 age=20 sex=1
name=赵云 age=21 sex=1
name=貂蝉 age=19 sex=1

3. vector容器中添加和删除元素

添加元素：
方法一：

insert() 插入元素到Vector中

iterator insert( iterator loc, const TYPE &val ); //在指定位置loc前插入值为val的元素,返回指向这个元素的迭代器

void insert( iterator loc, size_type num, const TYPE &val ); //在指定位置loc前插入num个值为val的元素

void insert( iterator loc, input_iterator start, input_iterator end ); //在指定位置loc前插入区间[start, end)的所有元素

方法二：

push_back() 在Vector最后添加一个元素（参数为要插入的值）

删除元素：
方法一：

clear() 清空所有元素
empty() 判断Vector是否为空（返回true时为空）

方法二：

erase() 删除指定元素 (可以用指针来代替迭代器)

iterator erase( iterator loc ); //要删除元素的迭代器
iterator erase( iterator start, iterator end ); //要删除的第一个元素的迭代器，要删除的第二个元素的迭代器

方法三：

pop_back() 移除最后一个元素

方法四：

可以采用通用算法remove()来删除vector容器中的元素， 不同的是，采用 remove 一般情况下不会改变容器的大小，而pop_back()与erase()等成员函数会改变容器的大小。