数据结构初阶--顺序表（讲解+C++类模板实现）
顺序的概念与结构
顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。
一般分为两种：静态顺序表和动态顺序表
静态顺序表
#define N 100
typedef int SLDataType;//以便可以存储不同类型的数据
typedef struct SeqList
{
SLDataType a[N];
int size;
}SL;
顺序表最大的缺点就是存储空间大小被固定了，空间有限。所以实际上我们不怎么会用这种静态的，所以我们这里不做实现。只实现下面的动态顺序表。
动态顺序表
typedef int SLDataType;//以便可以存储不同类型的数据
typedef struct SeqList
{
SLDataType* a;
int size;
int capacity;
}SL;
动态顺序表的函数接口
//无参构造，初始化顺序表
MyList();
//有参构造，初始化线性表
MyList(int length);
//销毁线性表
~MyList();
void MyListPushFront(const ElementType& e);//头插
void MyListPopFront();//头删
void MyListPushBack(const ElementType& e);//尾插
void MyListPopBack();//尾删
//插入操作，在pos位置插入元素e，并且返回线性表
MyList<ElementType>& Insert(int pos,const ElementType& e);
//删除操作，删除第pos个元素，并保存在在e中，返回删除后的线性表
MyList<ElementType>& DeleteByIndex(int pos, ElementType& e);
//判断线性表是否是空表
bool isEmpty()const;
//返回线性表的长度
int GetSize() const;
//返回pos位置的元素
bool GetElement(int pos, ElementType& e);
//修改pos位置的元素
bool ModifyData(int pos, const ElementType& e);
//返回元素e的位置
int Find(const ElementType& e);
//打印顺序表
void PrintMyList();
动态顺序表（C++实现）
顺序表的小框架
#define InitSize 10 //初始化时候顺序表的大小
class MyList
{
//全局函数作为友元
friend ostream& operator<<(ostream& os, MyList<ElementType>& L);
private:
ElementType* data;//数据
int capacity;//最大的容量
int size;//当前的大小
public:
};
初始化顺序表
//无参构造，初始化顺序表
MyList()
{
this->data = new ElementType[InitSize];
this->capacity = 10;
this->size = 0;
}
//有参构造，初始化线性表
MyList(int size) {
this->data = new ElementType[size];
this->capacity = 10;
this->size = size;
}
首先我们要对顺序表进行初始化，为了后面的增删查改做准备。
打印顺序表
//打印顺序表
void PrintMyList()
{
int i = 0;
for (i = 0; i < this->size; i++)
{
cout << this->data[i];
cout << endl;
}
}
销毁顺序表
为了防止内存泄漏，我们需要手动释放空间，我们用析构函数销毁线性表。
//销毁线性表
~MyList()
{
//销毁指针
delete[] this->data;
this->capacity = 0;
this->size = 0;
this->data = nullptr;
}
尾插
尾插当然就是在顺序表的尾部进行插入数据，插入数据的同时我们需要考虑到扩容，否则会导致空间不够，当capacity的大小和size的大小相同时，就说明顺序表容量已经满了，所以我们要对顺序表进行扩容操作，考虑到后面的头插也要可能扩容，所以封装一个函数CheckCapacity来检查顺序表容量，并且看是否需要扩容。实现如下：
//检查是否需要扩容
void CheckCapacity()
{
if (this->size == this->capacity)
{
this->capacity = this->capacity == 0 ? 4 : 2 * this->capacity;
ElementType* tmp = NULL;
tmp = (ElementType*)realloc(this->data, this->capacity * sizeof(ElementType));
if (tmp == NULL)
{
printf("realloc fail\n");
exit(-1);
}
this->data = tmp;
}
}
实现这个之后，我们就可以对顺序表进行尾插了，尾插唯一一个要注意的就是要检查顺序表容量，否则会导致程序崩溃。
尾插实现如下：
//尾插
void MyListPushBack(const ElementType& e)
{
//检查是否需要扩容
CheckCapacity();
data[size++] = e;
}
尾删
尾删要注意的一点：当顺序表中没有数据时，我们不应该再对顺序表进行删除了，为了保证程序不崩溃
//尾删
void MyListPopBack()
{
if (isEmpty())
{
return;
}
else
{
size--;
}
}
头插
头插值得我们考虑的点就是要对顺序表进行扩容，上面我们也提到了CheckCapacity这个函数，所以这里我们也要用到他，用他来检查顺序表容量。
void MyListPushFront(const ElementType& e)
{
//检查是否需要扩容
CheckCapacity();
for (int i = size; i > 0; i--)
{
data[i] = data[i - 1];
}
data[0] = e;
size++;
}
头删
头删也要注意顺序表中是否还有数据，如果没有就不进行删除操作，否则会导致程序崩溃。
//头删
void MyListPopFront()
{
//所有元素前移
for (int i = 1; i < this->size; i++)
{
data[i - 1] = data[i];
}
this->size--;
}
顺序表查找
//返回元素e的位置
int Find(const ElementType& e)
{
for (int i = 0; i < this->size; i++)
{
if (this->data[i] == e)
return i + 1;
}
cout << "未找到！" << endl;
return 0;
}
任意位置插入
看到插入两个字，我们就要考虑是否需要扩容。这一点很重要。还有我们要多pos这个参数进行判断，看是否在顺序表指定的范围中，因为顺序表是连续的，我们任意位置插入要合理，所以要对参数进行合理性判断
//插入操作，在pos位置插入元素e，并且返回线性表
MyList<ElementType>& Insert(int pos,const ElementType& e) {
//后移元素
if (pos<1 || pos>capacity + 1)
{
cout << "位置错误！" << endl;
return *this;
}
//检查是否需要扩容
CheckCapacity();
for (int j = this->size; j >= pos; j--)
this->data[j] = this->data[j - 1];
this->data[pos - 1] = e;
this->size++;
return *this;
}
任意位置删除
首先要对参数进行判断，顺序表不能为空，pos的位置要合理
//删除操作，删除第pos个元素，并保存在在e中，返回删除后的线性表
MyList<ElementType>& DeleteByIndex(int pos, ElementType& e)
{
if (pos<1 || pos>size) {
cout << "位置非法" << endl;
return *this;
}
e = data[pos - 1];
for (pos; pos < this->size; pos++)
{
this->data[pos - 1] = this->data[pos];
}
this->size--;
return *this;
}
修改任意位置的值
//修改pos位置的元素
//int tmp = 10; const int& ref = tmp;栈区的临时变量
bool ModifyData(int pos, const ElementType& e)
{
if (pos<1 || pos>this->size)
return false;
this->data[pos - 1] = e;
return true;
}
返回任意位置的元素
//返回pos位置的元素
bool GetElement(int pos, ElementType& e)
{
if (pos<1 || pos>this->size)
return false;
e = this->data[pos - 1];
return true;
}
零碎的操作
//判断线性表是否是空表
bool isEmpty()const
{
return this->size == 0;
}
//返回线性表的长度
int GetSize() const
{
return this->size;
}
完整的代码以及测试代码
#define _CRT_SECURE_NO_WARNINGS
#include<iostream> //引入头文件
#include<string>//C++中的字符串
using namespace std; //标准命名空间
#define InitSize 10 //初始化时候顺序表的大小
template<class ElementType>
class MyList
{
//全局函数作为友元
friend ostream& operator<<(ostream& os, MyList<ElementType>& L);
private:
ElementType* data;//数据
int capacity;//最大的容量
int size;//当前的大小
public:
/*
MyList();//无参构造
MyList(int size);//有参构造
~MyList();//析构函数
void MyListPushFront(const ElementType& e);//头插
void MyListPopFront();//头删
void MyListPopFront();
void MyListPushBack(const ElementType& e);//尾插
void MyListPopBack();//尾删
MyList<ElementType>& Insert(int pos, ElementType& e);//pos位置插入
MyList<ElementType>& DeleteByIndex(int pos, ElementType& e);//删除pos位置的元素
bool isEmpty()const;//判断是否是空表
int GetSize() const;//线性表的长度
bool GetElement(int pos, ElementType& e);//返回pos位置的元素
bool ModifyData(int pos, ElementType& e);//修改pos位置的元素
int Find(ElementType& e);//返回元素e的位置
void PrintMyList();//打印顺序表
*/
//无参构造，初始化顺序表
MyList()
{
this->data = new ElementType[InitSize];
this->capacity = 10;
this->size = 0;
}
//有参构造，初始化线性表
MyList(int size) {
this->data = new ElementType[size];
this->capacity = 10;
this->size = size;
}
//销毁线性表
~MyList()
{
//销毁指针
delete[] this->data;
this->capacity = 0;
this->size = 0;
this->data = nullptr;
}
//检查是否需要扩容
void CheckCapacity()
{
if (this->size == this->capacity)
{
this->capacity = this->capacity == 0 ? 4 : 2 * this->capacity;
ElementType* tmp = NULL;
tmp = (ElementType*)realloc(this->data, this->capacity * sizeof(ElementType));
if (tmp == NULL)
{
printf("realloc fail\n");
exit(-1);
}
this->data = tmp;
}
}
//头插
void MyListPushFront(const ElementType& e)
{
//检查是否需要扩容
CheckCapacity();
for (int i = size; i > 0; i--)
{
data[i] = data[i - 1];
}
data[0] = e;
size++;
}
//头删
void MyListPopFront()
{
//所有元素前移
for (int i = 1; i < this->size; i++)
{
data[i - 1] = data[i];
}
this->size--;
}
//尾插
void MyListPushBack(const ElementType& e)
{
//检查是否需要扩容
CheckCapacity();
data[size++] = e;
}
//尾删
void MyListPopBack()
{
if (isEmpty())
{
return;
}
else
{
size--;
}
}
//插入操作，在pos位置插入元素e，并且返回线性表
MyList<ElementType>& Insert(int pos,const ElementType& e) {
//后移元素
if (pos<1 || pos>capacity + 1)
{
cout << "位置错误！" << endl;
return *this;
}
//检查是否需要扩容
CheckCapacity();
for (int j = this->size; j >= pos; j--)
this->data[j] = this->data[j - 1];
this->data[pos - 1] = e;
this->size++;
return *this;
}
//删除操作，删除第pos个元素，并保存在在e中，返回删除后的线性表
MyList<ElementType>& DeleteByIndex(int pos, ElementType& e)
{
if (pos<1 || pos>size) {
cout << "位置非法" << endl;
return *this;
}
e = data[pos - 1];
for (pos; pos < this->size; pos++)
{
this->data[pos - 1] = this->data[pos];
}
this->size--;
return *this;
}
//判断线性表是否是空表
bool isEmpty()const
{
return this->size == 0;
}
//返回线性表的长度
int GetSize() const
{
return this->size;
}
//返回pos位置的元素
bool GetElement(int pos, ElementType& e)
{
if (pos<1 || pos>this->size)
return false;
e = this->data[pos - 1];
return true;
}
//修改pos位置的元素
//int tmp = 10; const int& ref = tmp;栈区的临时变量
bool ModifyData(int pos, const ElementType& e)
{
if (pos<1 || pos>this->size)
return false;
this->data[pos - 1] = e;
return true;
}
//返回元素e的位置
int Find(const ElementType& e)
{
for (int i = 0; i < this->size; i++)
{
if (this->data[i] == e)
return i + 1;
}
cout << "未找到！" << endl;
return 0;
}
//打印顺序表
void PrintMyList()
{
int i = 0;
for (i = 0; i < this->size; i++)
{
cout << this->data[i];
cout << endl;
}
}
};
template<class ElementType>
ostream& operator<<(ostream& os, MyList<ElementType>& L)
{
for (int i = 0; i < L.GetSize(); i++)
os << L.data[i] << "\t";
os << endl;
return os;
}
/*
MyList();//无参构造
MyList(int size);//有参构造
~MyList();//析构函数
void MyListPushFront(const ElementType& e);//头插
void MyListPopFront();//头删
void MyListPopFront();
void MyListPushBack(const ElementType& e);//尾插
void MyListPopBack();//尾删
MyList<ElementType>& Insert(int pos, ElementType& e);//pos位置插入
MyList<ElementType>& DeleteByIndex(int pos, ElementType& e);//删除pos位置的元素
bool isEmpty()const;//判断是否是空表
int GetSize() const;//线性表的长度
bool GetElement(int pos, ElementType& e);//返回pos位置的元素
bool ModifyData(int pos, ElementType& e);//修改pos位置的元素
int Find(ElementType& e);//返回元素e的位置
void PrintMyList();//打印顺序表
*/
int main()
{
MyList<int> list;
//测试头插
list.MyListPushFront(1);
list.MyListPushFront(2);
list.MyListPushFront(3);
list.PrintMyList();
cout << list.GetSize() << endl;
cout << "====================" << endl;
//测试头删
list.MyListPopFront();
list.MyListPopFront();
list.PrintMyList();
cout << list.GetSize() << endl;
cout << "====================" << endl;
//测试尾插
list.MyListPushBack(2);
list.MyListPushBack(3);
list.MyListPushBack(4);
list.PrintMyList();
cout << list.GetSize() << endl;
cout << "====================" << endl;
//测试尾删
list.MyListPopBack();
list.MyListPopBack();
list.PrintMyList();
cout << list.GetSize() << endl;
cout << "====================" << endl;
//测试任意位置删除
list.MyListPushFront(1);
list.MyListPushFront(2);
list.MyListPushFront(3);
list.PrintMyList();
int b = 0;
list.DeleteByIndex(2,b);
cout << b << endl;
list.PrintMyList();
cout << "====================" << endl;
//测试任意位置插入
list.Insert(1,10);
list.PrintMyList();
cout << "====================" << endl;
//返回Pos位置的元素
int c = 0;
list.GetElement(1, c);
cout << c << endl;
cout << "====================" << endl;
//修改pos位置的元素
list.ModifyData(1, 30);
list.PrintMyList();
cout << "====================" << endl;
//返回元素e的位置
cout << list.Find(30) << endl;
system("pause");
return EXIT_SUCCESS;
}
初学的小伙伴可以自己动手写一写以及优化以下~
顺序表的问题及思考
- 中间/头部的插入删除，时间复杂度为O(N)
- 增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。
- 增容一般是呈2倍的增长，势必会有一定的空间浪费，不能完全实现按需所取。
数据结构初阶--顺序表（讲解+C++类模板实现）的更多相关文章
- 五种编程语言解释数据结构与算法——顺序表3（JavaScript与Python语言实现）
7.JavaScript语言实现 7.1.用ES6语法编写顺序表类 //1.创建类 class MyList { //1. initList(&L):初始化表.构造一个空的线性表.放回值应该是 ...
- 五种编程语言解释数据结构与算法——顺序表2（java与C++语言实现）
5.java实现方式: 5.1.顺序表的抽象结构 package com.xgp.顺序表; public interface MyList<T> { //1. initList(& ...
- C++ 数据结构学习一(顺序表)
//SequentialList.h 顺序表模板类 #ifndef SEQUENTIAL_LIST_HXX#define SEQUENTIAL_LIST_HXX using std::cout; us ...
- C++数据结构学习之顺序表
顺序表是数据结构中最基本也是应用相当广泛的一种数据结构类型.它通常包含三个私有成分,即指向数据数组的头指针.当前表长以及表的实际容量.表的头指针通常指向数据数组的基地址,通过数组的形式进行访问数据数组 ...
- 数据结构 单链表&顺序表
顺序表: 一般使用数组(C语言中的数组采用顺序存储方式.即连续地址存储)来描述. 优点:在于随机访问元素, 缺点:插入和和删除的时候,需要移动大量的元素. 链表: 优点:插入或删除元素时很方便,使用灵 ...
- 数据结构——Java实现顺序表
一.分析 什么是顺序表?顺序表是指用一组地址连续的存储单元依次存储各个元素,使得在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中的线性表.一个标准的顺序表需要实现以下基本操作: 1.初始化顺序表 ...
- 数据结构之线性顺序表ArrayList（Java实现）
一.ListMe接口: import java.util.ArrayList; //实现线性表(顺序表和链表)的接口://提供add get isEmpty size 功能public interfa ...
- 【c++版数据结构】之顺序表的实现
SeqList.h #ifndef SEQLIST_H #define SEQLIST_H #include<iostream> using namespace std; typedef ...
- 【数据结构】之顺序表（Java语言描述）
之前总结过使用C语言描述的顺序表数据结构.在C语言类库中没有为我们提供顺序表的数据结构,因此我们需要自己手写,详细的有关顺序表的数据结构描述和C语言代码请见[我的这篇文章]. 在Java语言的JDK中 ...
- 【数据结构】之顺序表（C语言描述）
顺序表是线性表的一种,它将元素存储在一段连续的内存空间中,表中的任意元素都可以通过下标快速的获取到,因此,顺序表适合查询操作频繁的场景,而不适合增删操作频繁的场景. 下面是使用 C语言 编写的顺序表的 ...
随机推荐
- 新增一个Redis 从节点为什么与主节点的key数量不一样呢？
在日常的 Redis 运维过程中,经常会发生重载 RDB 文件操作,主要情形有: 主从架构如果主库宕机做高可用切换,原从库会挂载新主库重新获取数据 主库 QPS 超过10万,需要做读写分离,重新添加从 ...
- Flink基础概念入门
Flink 概述 什么是 Flink Apache Apache Flink 是一个开源的流处理框架,应用于分布式.高性能.高可用的数据流应用程序.可以处理有限数据流和无限数据,即能够处理有边界和无边 ...
- 使用Vite快速构建Vue3+ts+pinia脚手架
一.前言 vue3的快速更新,很多IT发展快的地区在22开始都已经提上日程,小编所在的青岛好像最近才有点风波.vue3的人才在青岛还是比较稀缺的哈,纯属小编自己的看法,可能小编是个井底之蛙!! vue ...
- es，logstash各版本对应要求的JDK版本,操作系统对应示意图
官网地址:https://www.elastic.co/cn/support/matrix
- 安装ceph (快速) 步骤二：存储集群
用 ceph-deploy 从管理节点建立一个 Ceph 存储集群,该集群包含三个节点,以此探索 Ceph 的功能. 创建一个 Ceph 存储集群,它有一个 Monitor 和两个 OSD 守护进程. ...
- 移除worker节点
1.在准备移除的 worker 节点上执行 kubeadm reset -f 2.在 master 节点上执行 kubectl get nodes -o wide 3.删除worker节点,在 mas ...
- 3.使用nexus3配置maven私有仓库
配置之前,我们先来看看系统默认创建的都有哪些 其中圈起来的都是系统原有的,用不到,就全删掉,重新创建. 1,创建blob存储 2,创建hosted类型的maven 点击 Repository下面的 R ...
- HDU2586 How far away ？ （树链剖分求LCA）
用树链剖分求LCA的模板: 1 #include<iostream> 2 #include<algorithm> 3 using namespace std; 4 const ...
- SSM整合以及相关补充
SSM整合以及相关补充 我们在前面已经学习了Maven基本入门,Spring,SpringMVC,MyBatis三件套 现在我们来通过一些简单的案例,将我们最常用的开发三件套整合起来,进行一次完整的项 ...
- IDEA上关于 jstl导包的问题
IDEA上关于 jstl的问题 在 IDEA上使用 maven创建 web骨架项目,在 pom文件中添加 jstl依赖 <dependency> <groupId>jstl&l ...