线性表的顺序存储结构------顺序表（c语言附完整代码）
文章目录
- 前言
- 基础知识
-
- typedef的用法
- 引用&
- malloc函数
- free函数
- 一、定义
- 二、特点
- 三、基本运算
-
- 静态分配
- 动态分配
- 四、小结
- 完整代码
-
- 静态分配
- 动态分配
前言
线性表是最基本、最简单、也是最常用的一种数据结构。根据存储方式的不同可分为顺序表和链表，那么今天我就带大家学习一下线性表的顺序存储结构------顺序表,通过静态分配和动态分配两种不同的实现方式加深大家对顺序表的理解。（文章最后附有顺序表基本运算完整代码）
基础知识
对于一些刚接触到数据结构的同学，可能会对后面基本运算中的一些代码不太理解，故先给大家讲解一下这部分内容，以方便大家更容易理解后面的代码。
typedef的用法
为了编码方便，c语言允许为一个数据类型起一个别名。例如：
typedef int ElemType;//给int型数据起了一个别名ElemType
后面就可以直接用该别名定义变量，例如：
ElemType e;
等价于
int e;
同样的还可以给结构体类型定义别名，例如：
typedef struct
{
ElemType data[MaxSize]; //存放顺序表元素
int length; //存放顺序表的长度
} SqList;
上述代码为该种结构体类型起了一个别名SqList，后面可以直接用该别名定义变量，例如：
SqList *L;
上述代码定义了一个指向原结构体类型的指针L。
引用&
引用是c++对c语言的重要扩充。引用就是原变量的别名，引用变量本身没有自己的实际存储空间，对引用变量的操作，就是在操作原变量。在定义函数时使用引用的形参，就可以使实际参数发生改变。例如在后面代码中：
void InitList(SqList *&L)
{
L=(SqList *)malloc(sizeof(SqList)); //分配存放线性表的空间
L->length=0;//顺序表长度置0
}
初始化顺序表时，我们需要为顺序表申请一片空间，并且将length的值设置为0，为了使实参同时发生改变，这里使用了引用。
又如：
int ListLength(SqList *L)
{
return(L->length);//返回length的值
}
在求顺序表的长度时，我们只需要获取length的值，不需要改变实参，所以这里没有使用引用。
malloc函数
malloc动态内存分配函数，用于申请一块连续的指定大小的内存块区域以void*类型返回分配的内存区域地址
malloc函数的原型
extern void *malloc(unsigned int num_bytes);
malloc函数头文件
#include或
#includemalloc函数的返回的是无类型指针，所以在使用时一定要强制转换为所需要的类型。
L=(SqList *)malloc(sizeof(SqList)); //将指针返回值类型转换为SqList 型
在使用malloc开辟空间时，使用完成一定要释放空间，如果不释放会造内存泄漏。
free(L);//释放顺序表储存空间
free函数
free函数通常与malloc函数在一起使用，用于释放malloc函数分配的内存空间。
free 函数原型
void free(void *ptr);
free函数头文件
#include或
#include使用方法
free(L);//释放指针L所指储存空间
一、定义
顺序表-----用顺序存储的方式实现线性表顺序存储。
把逻辑上相邻的元素存储在物理位置上也相邻的存储单元中，元素之间的关系由存储单元的邻接关系来体现。
声明顺序表（静态分配）
typedef struct
{
ElemType data[MaxSize]; //存放顺序表元素
int length; //存放顺序表的长度
} SqList;
定义一个结构体，包含两个成员变量，分别用来存放数据元素和顺序表长度，并为该结构体起了一个别名SqList，可以直接用SqList定义一个结构体变量。
声明顺序表（动态分配）
typedef struct
{
ElemType *data; //指示动态分配数组的指针
int MaxSize; //顺序表最大容量
int length; //顺序表当前容量
}SeqList;
定义一个结构体，包含三个成员变量，分别用来存放数据元素，顺序表最大容量，顺序表长度，并给这个结构体起了一个别名SeqList 。
二、特点
1.随机访问，即在O（1）时间内找到第i个元素
2.存储密度高，每个节点只存储数据元素
3.拓展容量不方便（即便采用动态分配的方式实现，拓展长度的时间复杂度 也比较高）
4.插入和删除不方便，需要移动大量元素
5.元素的逻辑顺序与物理顺序相同
三、基本运算
静态分配
初始化顺序表
void InitList(SqList *&L)
{
L=(SqList *)malloc(sizeof(SqList)); //分配存放线性表的空间
L->length=0;//顺序表长度置0
}
使用malloc函数申请sizeof(SqList)大小的存储空间，并用指针L指向这片空间，将顺序表的长度初始化为0
本算法的时间复杂度为O（1）
销毁顺序表
void DestroyList(SqList *&L)
{
free(L);//释放顺序表储存空间
}
使用free函数释放指针L所指存储空间
本算法的时间复杂度为O（1）
判断顺序表是否为空表
bool ListEmpty(SqList *L)
{
return(L->length==0);//若表L的长度为0，返回1，否则返回0
}
该函数的返回值类型为布尔型，返回值为0或1，当L->length的值为0时，表示此时顺序表为空表，返回1；当 L->length的值不为0时，表示此时线性表非空，返回0
本算法的时间复杂度为O（1）
求顺序表的长度
int ListLength(SqList *L)
{
return(L->length);//返回length的值
}
直接返回length的值
本算法的时间复杂度为O（1）
输出顺序表
void DispList(SqList *L)
{
for (int i=0;i<L->length;i++)
printf("%d ",L->data[i]);//循环打印L->data[i]的值
printf("\n");
}
当 i小于线性表长度时，循环输出L->data[i]的值
本算法的时间复杂度为O（n）
求顺序表中某个位置元素的值
bool GetElem(SqList *L,int i,ElemType &e)
{
if (i<1 || i>L->length)//判断查找位置是否正确
return false;
e=L->data[i-1];
return true;
}
先判断所求位置是否合法，如果不合法则返回false，如果合法则将L-data[i]的值赋给e，并返回true。该运算可在O（1）时间复杂度内找到第i个数据元素，体现了顺序表的随机访问特性。
本算法的时间复杂度为O（1）
按元素的值查找
int LocateElem(SqList *L, ElemType e)
{
int i=0;
while (i<L->length && L->data[i]!=e)
i++;//当idata[i]的值不等于e时继续查找
if (i>=L->length)
return 0;//i大于等于顺序表的长度时表示未找到，返回0
else
return i+1;//返回在顺序表中的位置
}
定义变量i并初始化为0，当 i 小于线性表的长度而且data[ i ] 的值不等于e时，继续查找，当循环结束时有两种情况，如果 i >=L->length,则说明未找到值为e的元素，返回0。如果i
插入数据元素
bool ListInsert(SqList *&L,int i,ElemType e)
{
int j;
if (i<1 || i>L->length+1)//判断插入位置是否正确
return false;
i--; //将顺序表位序转化为elem下标
for (j=L->length;j>i;j--) //将data[i]及后面元素后移一个位置
L->data[j]=L->data[j-1];
L->data[i]=e;
L->length++; //顺序表长度增1
return true;
}
首先判断插入位置是否合法，然后将插入位置顺序表位序转化为数组位序，
从最后一个元素开始将data[ i ]及后面元素往后移一个位置，最后将e的值赋给data[ i ],将顺序表的长度加 1。
本算法的时间复杂度为O（n）
动画演示：
删除数据元素
bool ListDelete(SqList *&L,int i,ElemType &e)
{
int j;
if (i<1 || i>L->length)
return false;
i--; //将顺序表位序转化为elem下标
e=L->data[i];
for (j=i;j<L->length-1;j++) //将data[i]之后的元素前移一个位置
L->data[j]=L->data[j+1];
L->length--; //顺序表长度减1
return true;
}
首先判断删除元素的位置是否合法，然后将删除元素的顺序表位序转化为数组位序，将data[ i ]的值赋给e，从data[ i ]后面的元素开始将data[ i ]之后的元素前移一个位置，最后将顺序表的长度减 1。
本算法的时间复杂度为O（n）
动画演示：
动态分配
初始化顺序表
void InitList(SeqList &L)
{
L.data=(ElemType *)malloc(InitSize*sizeof(ElemType));//申请一片连续的空间
L.length=0; //当前长度为0
L.MaxSize=InitSize; //顺序表最大容量为MaxSize
}
申请一片连续的存储空间，并用L.data指向这片空间，将顺序表的最大容量设置为InitSize ，将顺序表的长度置0。
本算法的时间复杂度为O（1）
拓展顺序表的容量
void IncreaseSize(SeqList &L,int len)
{
ElemType *p=L.data;
L.data=(ElemType *)malloc((L.MaxSize+len)*sizeof(ElemType));//重新申请一块连续的空间
for(int i=0;i<L.length;i++)
L.data[i]=p[i];//将原存储空间的值复制到新的空间
L.MaxSize=L.MaxSize+len;//修改顺序表最大容量
free(p);//释放原存储空间
}
首先定义一个指针p 指向L.data所指存储空间，重新申请一片(L.MaxSize+len)*sizeof(ElemType)大小的存储空间，并用L .data指向它，
将原存储空间的数据元素复制到新的存储区域，然后修改顺序表的最大容量，最后释放原存储空间（即p所指存储空间）。
本算法的时间复杂度为O（n）
销毁顺序表
void DestroyList(SeqList &L)
{
free(L.data);//释放指针所指存储空间
L.data=NULL;
L.length=0;//顺序表当前长度置0
L.MaxSize=0;//顺序表最大容量置0
}
释放L.data所指存储空间，然后重置 L.data为NULL，在调用free函数之后，虽然归还了内存，但是L.data中仍然指向原来的地址，而这个地址在归还内存之后程序便无权进行访问，所以此时L.data就成了一个野指针，重置L.data为NULL就是为了防止发生野指针访问的情况，最后将顺序表的长度和最大容量置0。
本算法的时间复杂度为O（1）
判断顺序表是否为空表
bool ListEmpty(SeqList L)
{
return(L.length==0);//线性表长度为0即为空表，返回1，否则返回0
}
本算法的时间复杂度为O（1）
求顺序表的长度
int ListLength(SeqList L)
{
return(L.length);
}
本算法的时间复杂度为O（1）
输出顺序表
void DispList(SeqList L)
{
for (int i=0;i<L.length;i++)
printf("%d ",L.data[i]);
printf("\n");
}
本算法的时间复杂度为O（n）
求顺序表中某个位置元素的值
bool GetElem(SeqList L,int i,ElemType &e)
{
if (i<1 || i>L.length)//判断位置是否正确
return false;
e=L.data[i-1];
return true;
}
本算法的时间复杂度为O（1）
按元素的值查找
int LocateElem(SeqList L, ElemType e)
{
int i=0;
while (i<L.length && L.data[i]!=e) i++;
if (i>=L.length)
return 0;
else
return i+1;
}
本算法的时间复杂度为O（n）
插入数据元素
bool ListInsert(SeqList &L,int i,ElemType e)
{
int j;
if (i<1 || i>L.length+1)//判断插入位置是否合法
return false;
if(L.length>=L.MaxSize)
IncreaseSize(L,Len);
i--; //将顺序表位序转化为elem下标
for (j=L.length;j>i;j--) //将data[i]及后面元素后移一个位置
L.data[j]=L.data[j-1];
L.data[i]=e;
L.length++; //顺序表长度增1
return true;
}
与静态分配顺序表不同，动态分配顺序表在进行插入操作时需要先判断当前顺序表的长度是否达到最大容量，如果达到最大容量，可以调用IncreaseSize函数增加顺序表的最大容量。
本算法的时间复杂度为O（n）
删除数据元素
bool ListDelete(SeqList &L,int i,ElemType &e)
{
int j;
if (i<1 || i>L.length)
return false;
i--; //将顺序表位序转化为elem下标
e=L.data[i];
for (j=i;j<L.length-1;j++) //将data[i]之后的元素前移一个位置
L.data[j]=L.data[j+1];
L.length--; //顺序表长度减1
return true;
}
本算法的时间复杂度为O（n）
四、小结
完整代码
静态分配
#include 动态分配
#include参考资料:
谭浩强《c语言程序设计》
李春葆《数据结构教程》（第五版）
王道数据结构
csdn 博主Dream_飞翔