【数据结构C++】线性表/顺序表-数组与vector

系列文章目录

第一章 线性表/顺序表-数组与vector

---

---

前言

在数据结构专栏（本专栏）中，我们将总结数据结构与算法的理论知识和结合LEETCODE相关题目的应用，旨在将零散的知识点按章节形成系统的知识库，并将知识应用于代码编写中。

---

一、数据结构主要研究的内容？

1. 数据之间的逻辑关系，即数据的逻辑结构；
2. 数据及其逻辑关系如何在计算机中存储实现，即数据的存储结构；
3. 在某种存储模式下，对数据施加的操作是如何实现的即运算实现。

二、数据结构三要素

我们按照：数组-> 链表->哈希表->字符串->栈与队列->树->回湖->贪心->动态规划->图论 的顺序进行归纳总结。各章思维导图可参考：数据结构各知识点思维导图

三、数组

1. 数组是存放在连续内存空间上的相同类型数据的集合。
2. 数组可以方便的通过下标索引的方式获取到下标下对应的数据。

1.C++中数组基本语法

1.1 数组的声明、初始化

// 一维数组定义的三种方式
	//1. 数据类型 数组名[数组长度];
	//定义数组时，若未给定数组元素的初始值，则必须指定初始数组长度，否则提示错误：“不允许使用不完整的类型”。
	 dataType nums[n];

	//2. 数据类型 数组名[ 数组长度 ] = { 值1，值2 ...};
	//数组初始化时，若大括号{ }内的元素个数小于定义的数组长度，则剩余数组元素默认使用 0 填充。
	 dataType nums[5]={1,4};	//[1,4,0,0,0]

	//3. 数据类型 数组名[ ] = { 值1，值2 ...};
	//定义数组元素初始值时，数组可以不指定初始数组长度。
	 dataType nums[ ]={1,4};	//[1,4], size=2

//二维数组定义的四种方式
	//1. 数据类型 数组名[ 行数 ][ 列数 ];
	  dataType nums[2][1];
	//2. 数据类型 数组名[ 行数 ][ 列数 ] = { {数据1，数据2} ，{数据3，数据4} };
	//最直观，可提高代码的可读性
	  dataType nums[2][1]={{3},{4}};	//两行一列的二维数组
	//3. 数据类型 数组名[ 行数 ][ 列数 ] = { 数据1，数据2，数据3，数据4};
	  dataType nums[2][4]={1,2,3,4,5,6,7,8};
	//4. 数据类型 数组名[ ][ 列数 ] = { 数据1，数据2，数据3，数据4};
	//定义二维数组时，若已初始化数据，则可以省略行数。
	  dataType nums[][3]={1，2，3，4，5，6};

具体学习可参考：C++数组

1.2 vector的底层结构

从数组的初始化方式可以看出，我们必须知道数组的长度或数组中包含的元素才能成功创建数组，但是在很多未知情况下，创建数组不方便。于是我们来学习动态类型顺序表——vector。

1. vector是标准库STL中常见的一种容器，使用起来非常方便，可以用来代替c++原本的数组。
2. vector底层实际是一段连续的空间。它以数组的形式储存，所以它的内存空间是连续的。实际在底层使用三个指针指向该段连续空间的，如下：

start指向空间的起始位置，finish指向最后一个元素的下一个位置，end_of_storage指向空间的末尾。其中，start和finish表示左闭右开区间，finish位置没有存储有效元素。
3. vector的头文件为 #include<vector>。

常用的初始化vector方法：

1.vector<int>a                   //创建一个动态数组a，a的默认初值为0

2.vector<int >b(a)               //将a中的元素复制到b中

3.vetcor<int>a(100)              //将数组a的元素定义为100个，默认初始值为0

4.vector<int>a(100,6)            //定义100个值为6的元素

5.vector<string>a(10,"null")     //定义10个值为null的元素

6.vector<string>a(10,"hello")    //定义10个值为hello的元素

7.vector<string>b(a.begin(),a.end())  //将动态数组a的元素值复制到b中

常用的函数：

push_back( ) 成员函数在向量的末尾插入值，如果有必要会扩展向量的大小。
size( ) 函数显示向量的大小。
begin( ) 函数返回一个指向向量开头的迭代器。
end( ) 函数返回一个指向向量末尾的迭代器。

实例化：

#include <iostream>
#include <vector>
using namespace std;
 
int main()
{
   // 创建一个向量存储 int
   vector<int> vec; 
   int i;
 
   // 显示 vec 的原始大小
   cout << "vector size = " << vec.size() << endl;
 
   // 推入 5 个值到向量中
   for(i = 0; i < 5; i++){
      vec.push_back(i);
   }
 
   // 显示 vec 扩展后的大小
   cout << "extended vector size = " << vec.size() << endl;
 
   // 访问向量中的 5 个值
   for(i = 0; i < 5; i++){
      cout << "value of vec [" << i << "] = " << vec[i] << endl;
   }
 
   // 使用迭代器 iterator 访问值
   vector<int>::iterator v = vec.begin();
   while( v != vec.end()) {
      cout << "value of v = " << *v << endl;
      v++;
   }
 
   return 0;
}

2.数据结构之数组详解

逻辑结构：线性表
存储结构：使用一组连续的内存空间。

2.1 数据结构之数组操作——增、删、改、查

#include <iostream>
using namespace std;
#define MAXSIZE 50
//对象实现数组的CRUD

class numArr{
	public:
		int len;	//数组长度 
		char a[MAXSIZE];	//char数组 
		numArr(){}
		numArr(char a[], int len){
			this->len = len;
			for(int i=0; i<len; i++){
				this->a[i] = a[i];
			}
		}
		
		int findElement(char key);	//查找元素返回下标 
		void deleteIndex(int index);	//根据下标删除元素 
		void printArray();	//打印 
		void deleteElement(char key);	//删除元素 
		void insert(int index,char key);	//插入元素 下标 
		void insert2(int pos, char key); //插入元素 位置 
};  
	//查找元素返回下标 
	int numArr::findElement(char key){
		for(int i=0; i<this->len; i++){
			if(this->a[i] == key){
				return i;
			}
		}
		return -1;
	}
	//打印 
	void numArr::printArray(){
		for(int i=0; i<this->len; i++){
			cout<<this->a[i]<<"  ";
		}
		cout<<endl;
	}
	//根据下标删除元素 
	void numArr::deleteIndex(int index){
		for(int i=index; i<this->len; i++){
			this->a[i] = this->a[i+1];
		}
		this->len--;
	}
	//删除元素 
	void numArr::deleteElement(char key){
		for(int i=0; i<this->len; i++){
			int temp = findElement(key);
			if(temp != -1){
				deleteIndex(temp);
			}
		}
	}
	//插入元素  下标index后面的元素分别向后一位，腾空一个位置 
	void numArr::insert(int index, char key){
		for(int i=this->len; i>=index; i--){
			this->a[i] = this->a[i-1];
//			this->a[i+1] = this->a[i];
		}
		this->a[index] = key;
		this->len++;
	}
	//插入元素 位置
	void  numArr::insert2(int pos, char key){
		for(int i=this->len-1; i>=pos-1; i--){
			this->a[i+1] = this->a[i];
		}
		this->a[pos-1] = key;
		this->len++;
	}
	

int main(){

	char a[] = {'a','a','b','c','a'};
	int n = sizeof(a)/sizeof(a[0]);
	numArr numArr(a,n);
	
	cout<<"---------printArray--------------\n";
	numArr.printArray();
	
	cout<<"---------findElement--------------\n";
	int t = numArr.findElement('a');
	cout<<t<<endl;
	
	cout<<"---------deleteIndex--------------\n";
	numArr.deleteIndex(1);
	numArr.printArray();
	
	cout<<"---------deleteElement--------------\n";
	numArr.deleteElement('a');
	numArr.printArray();
	
	cout<<"---------insert--------------\n";
	numArr.insert(0,'w');
	numArr.printArray();
	
	cout<<"---------insert2--------------\n";
	numArr.insert(1,'W');
	numArr.printArray();
	
	return 0;
}

2.2 数据结构之数组操作-时间、空间复杂度

总结：数组的最大特点的支持随机访问。改变元素的时间复杂度为 O(1)，在尾部插入、删除元素的时间复杂度也是 O(1)，普通情况下插入、删除元素的时间复杂度为 O(n)。

---

总结

数组：

1. 因为数组的在内存空间的地址是连续的，所以我们在删除或者增添元素的时候，就难免要移动其他元素的地址。
2. 数组的元素是不能删的，只能覆盖。

vector:

1. 支持随机访问：用户可以向使用数组的方式访问vector中的每一个元素，但vector不适宜做任意位置的插入和删除操作，因为要进行大量元素的搬移，比如插入。

数组相关参考：

1. C++数组

vector相关参考：

1. C++ vector用法详解
2. vector的底层实现
3. vector的函数库使用