系列文章目录
第一章 线性表/顺序表-数组与vector
文章目录
- 系列文章目录
- 前言
- 一、数据结构主要研究的内容？
- 二、数据结构三要素
- 三、数组
- 1.C++中数组基本语法
- 1.1 数组的声明、初始化
- 1.2 vector的底层结构
- 2.数据结构之数组详解
- 2.1 数据结构之数组操作——增、删、改、查
- 2.2 数据结构之数组操作-时间、空间复杂度
- 总结
前言
在数据结构专栏（本专栏）中，我们将总结数据结构与算法的理论知识和结合LEETCODE相关题目的应用，旨在将零散的知识点按章节形成系统的知识库，并将知识应用于代码编写中。
一、数据结构主要研究的内容？
- 数据之间的逻辑关系，即数据的逻辑结构；
- 数据及其逻辑关系如何在计算机中存储实现，即数据的存储结构；
- 在某种存储模式下，对数据施加的操作是如何实现的即运算实现。
二、数据结构三要素
我们按照：数组-> 链表->哈希表->字符串->栈与队列->树->回湖->贪心->动态规划->图论 的顺序进行归纳总结。各章思维导图可参考：数据结构各知识点思维导图
三、数组
- 数组是存放在连续内存空间上的相同类型数据的集合。
- 数组可以方便的通过下标索引的方式获取到下标下对应的数据。
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。
- vector是标准库STL中常见的一种容器，使用起来非常方便，可以用来代替c++原本的数组。
- 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)。
总结
数组：
- 因为数组的在内存空间的地址是连续的，所以我们在删除或者增添元素的时候，就难免要移动其他元素的地址。
- 数组的元素是不能删的，只能覆盖。
vector:
- 支持随机访问：用户可以向使用数组的方式访问vector中的每一个元素，但vector不适宜做任意位置的插入和删除操作，因为要进行大量元素的搬移，比如插入。
数组相关参考：
- C++数组
vector相关参考：
- C++ vector用法详解
- vector的底层实现
- vector的函数库使用
