顺序表中的基本操作(详细代码图解+注释+算法步骤)
目录
线性表中的顺序表基本操作的函数名类型定义：
1.创建一个长度为n的顺序表L：
创建一个长度为n顺序表L的核心代码块：
创建一个长度为n顺序表的完整代码如下：
运行结果：
2.顺序表L的插入:
顺序表L的插入的核心代码：
顺序表L的插入的完整代码如下：
运行结果：
3.顺序表L的删除：
顺序表L的删除的核心代码：
顺序表L的删除的完整代码实现如下：
运行结果:
4.顺序表L的查找：
顺序表的查找(按值查找) 核心代码：
顺序表的查找(按值查找) 完整代码如下：
运行结果：
顺序表的查找(按位置查找) 核心代码：
顺序表的查找(按位置查找) 完整代码如下：
运行结果：
5.顺序表L的倒置：
顺序表L的倒置的核心代码：
顺序表L的倒置的完整代码如下：
运行结果：
下面是线性表中的顺序表基本操作的函数名类型定义：
- CreateList(SqList &L,int n) ：创建长度为n的顺序表L—— 时间复杂度：O(n)
- InitList(SqList &L) ：初始化顺序表L——时间复杂度:O(1)
- InsertList(SqList &L,int i,ElemType e) ：在位置i处插入元素e ——时间复杂度:O(n)
- ListDelete(SqList &L,int i)：删除位置i处元素——时间复杂度:O(n)
- LocateElem(SqList L,ElemType e) ：返回顺序表L中第一个等于e的元素的位置——时间复杂度:O(n)
- GetElem(SqList L, int i, ElemType &e)：根据指定的位置序号i，获取顺序表L中第i个数据元素的值——时间复杂度:O(1)
- Reverse(SqList &L) ： 将原顺序表L直接倒置。
- PrintList(SqList L)：遍历顺序表L，并输出。
1.创建一个长度为n的顺序表L：
创建一个长度为n顺序表L的核心代码：
//------顺序表初始化前n个数据------//
bool CreateList(SqList &L,int n)
{
if(n<0||n>MAXSIZE) return false; //n值不合法
for(int i=0; i创建一个长度为n顺序表的完整代码如下：
//******************************创建一个长度为n的顺序表L******************************//
#include
#define OK 1
#define ERROR 0
typedef int ElemType;
typedef int Status;
//------顺序表的存储结构------//
#define MAXSIZE 100 //顺序表可能达到的最大长度
typedef struct
{
ElemType *elem; //或ElemType elem[MAXSIZE] 存储空间的基地址
int length; //当前长度
}SqList; //顺序表的结构类型为SqList
//------顺序表的初始化------//
//-----【算法步骤】 -----//
//1.为顺序表 L动态分配一个预定义大小的数组空间，使elem指向这段空间的基地址。
//2.将表的当前长度设为0。
bool InitList(SqList &L)
{
//构造一个空的顺序表L
L.elem=new int[MAXSIZE]; //为顺序表分配一个大小为MAXSIZE的数组空间
if(!L.elem) return false; //存储分配失败退出
L.length=0; //空表长度为0
return true;
}
//------顺序表初始化前n个数据------//
bool CreateList(SqList &L,int n)
{
if(n<0||n>MAXSIZE) return false; //n值不合法
for(int i=0; i 运行结果：
2.顺序表L的插入:
顺序表L的插入的核心代码：
//------顺序表的插入------//
//-----【算法步骤】 -----//
//1.判断插入位置i是否合法(i值的合法范围是1<=i<=n+1),若不合法则返回ERROR。
//2.判断顺序表的存储空间是否已满，若满则返回ERROR。
//3.将第n个至第i个位置的元素依次向后移动一个位置，空出第i个位置(i=n+1时无需移动)。
//4.将要插入的新元素e放入到第i个位置。
//5.表长加1。
Status ListInsert(SqList &L, int i, int e)
{
//在顺序表L中第i个位置插入新的元素e，i值的合法范围是1<=i<=L.length+1
if(i<1||(i>L.length+1)) return ERROR; //i值不合法
if(L.length==MAXSIZE) return ERROR; //当前存储空间已满
for(int j=L.length-1; j>=i-1; j--)
L.elem[j+1]=L.elem[j]; //插入位置及之后的元素后移
L.elem[i-1]=e; //将新元素e放入第i个位置
++L.length; //表长加1
return OK;
}顺序表L的插入的完整代码如下：
//******************************先创建一个长度为n的顺序表L，然后对顺序表L进行元素插入******************************//
#include
#define OK 1
#define ERROR 0
typedef int ElemType;
typedef int Status;
//------顺序表的存储结构------//
#define MAXSIZE 100 //顺序表可能达到的最大长度
typedef struct
{
ElemType *elem; //或ElemType elem[MAXSIZE] 存储空间的基地址
int length; //当前长度
}SqList; //顺序表的结构类型为SqList
//------顺序表的初始化------//
//-----【算法步骤】 -----//
//1.为顺序表 L动态分配一个预定义大小的数组空间，使elem指向这段空间的基地址。
//2.将表的当前长度设为0。
bool InitList(SqList &L)
{
//构造一个空的顺序表L
L.elem=new int[MAXSIZE]; //为顺序表分配一个大小为MAXSIZE的数组空间
if(!L.elem) return false; //存储分配失败退出
L.length=0; //空表长度为0
return true;
}
//------顺序表初始化前n个数据------//
bool CreateList(SqList &L,int n)
{
if(n<0||n>MAXSIZE) return false; //n值不合法
for(int i=0; iL.length+1)) return ERROR; //i值不合法
if(L.length==MAXSIZE) return ERROR; //当前存储空间已满
for(int j=L.length-1; j>=i-1; j--)
L.elem[j+1]=L.elem[j]; //插入位置及之后的元素后移
L.elem[i-1]=e; //将新元素e放入第i个位置
++L.length; //表长加1
return OK;
}
//------输出打印顺序表 按位置从小到大输出顺序表所有元素------//
void PrintList(SqList L)
{
printf("当前顺序表中所有元素为：");
for(int i=0; i 运行结果：
3.顺序表L的删除：
顺序表L的删除的核心代码：
//------顺序表的删除------//
//-----【算法步骤】 -----//
//1.判断删除位置i是否合法(i值的合法范围是1<=i<=n),若不合法则返回ERROR。
//2.将第i+1个至第n个的元素依次向前移动一个位置(i=n时无需移动)。
//3.表长减1。
Status ListDelete(SqList &L,int i)
{
//在顺序表L中删除第i个元素，i值的合法范围是1<=i<=L.length
if(i<1||(i>L.length)) return ERROR; //i值不合法
for(int j=i; j<=L.length-1; j++)
L.elem[j-1]=L.elem[j]; //被删除元素之后的元素前移
--L.length; //表长减1
return OK;
}
顺序表L的删除的完整代码实现如下：
//******************************先创建一个长度为n的顺序表L，然后对顺序表L中的元素进行删除******************************//
#include
#define OK 1
#define ERROR 0
typedef int ElemType;
typedef int Status;
//------顺序表的存储结构------//
#define MAXSIZE 100 //顺序表可能达到的最大长度
typedef struct
{
ElemType *elem; //或ElemType elem[MAXSIZE] 存储空间的基地址
int length; //当前长度
}SqList; //顺序表的结构类型为SqList
//------顺序表的初始化------//
//-----【算法步骤】 -----//
//1.为顺序表 L动态分配一个预定义大小的数组空间，使elem指向这段空间的基地址。
//2.将表的当前长度设为0。
bool InitList(SqList &L)
{
//构造一个空的顺序表L
L.elem=new int[MAXSIZE]; //为顺序表分配一个大小为MAXSIZE的数组空间
if(!L.elem) return false; //存储分配失败退出
L.length=0; //空表长度为0
return true;
}
//------顺序表初始化前n个数据------//
bool CreateList(SqList &L,int n)
{
if(n<0||n>MAXSIZE) return false; //n值不合法
for(int i=0; iL.length)) return ERROR; //i值不合法
for(int j=i; j<=L.length-1; j++)
L.elem[j-1]=L.elem[j]; //被删除元素之后的元素前移
--L.length; //表长减1
return OK;
}
//------输出打印顺序表 按位置从小到大输出顺序表所有元素------//
void PrintList(SqList L)
{
printf("当前顺序表中所有元素为：");
for(int i=0; i 运行结果:
4.顺序表L的查找：
顺序表的查找(按值查找) 核心代码：
//------顺序表的查找(按值查找)------//
//-----【算法步骤】 -----//
//1.从第一个元素起，依次和e相比较，若找到与e相等的元素L.elem[i],则查找成功，返回该元素的序号i+1。
//2.若查遍整个顺序表都没有找到，则查找失败，返回0。
int LocateElem(SqList L, int e)
{
//在顺序表L中查找值为e的数据元素，返回其序号。
for(int i=0; i顺序表的查找(按值查找) 完整代码如下：
//************先创建一个长度为n的顺序表L，然后对顺序表L中的元素进行按值查找*************//
#include
#define OK 1
#define ERROR 0
typedef int ElemType;
typedef int Status;
//------顺序表的存储结构------//
#define MAXSIZE 100 //顺序表可能达到的最大长度
typedef struct
{
ElemType *elem; //或ElemType elem[MAXSIZE] 存储空间的基地址
int length; //当前长度
}SqList; //顺序表的结构类型为SqList
//------顺序表的初始化------//
//-----【算法步骤】 -----//
//1.为顺序表 L动态分配一个预定义大小的数组空间，使elem指向这段空间的基地址。
//2.将表的当前长度设为0。
bool InitList(SqList &L)
{
//构造一个空的顺序表L
L.elem=new int[MAXSIZE]; //为顺序表分配一个大小为MAXSIZE的数组空间
if(!L.elem) return false; //存储分配失败退出
L.length=0; //空表长度为0
return true;
}
//------顺序表初始化前n个数据------//
bool CreateList(SqList &L,int n)
{
if(n<0||n>MAXSIZE) return false; //n值不合法
for(int i=0; i 运行结果：
顺序表的查找(按位置查找) 核心代码：
//------顺序表的查找(按位置查找)------//
//-----【算法步骤】 -----//
//1.判断指定的位置序号i值是否合理(1<=i<=L.length)，若不合理，则返回ERROR。
//2.若i值合理，则将第i个数据元素L.length[i-1]赋值给参数e，通过e返回第i个数据元素的传值。
Status GetElem(SqList L, int i, int &e)
{
if(i<1||i>L.length) return ERROR; //判断i值是否合理
e=L.elem[i-1]; //elem[i-1]单元存储第i个数据元素
return OK;
} 顺序表的查找(按位置查找) 完整代码如下：
//****************先创建一个长度为n的顺序表L，然后对顺序表L中的元素进行按位置查找****************//
#include
#define OK 1
#define ERROR 0
typedef int ElemType;
typedef int Status;
//------顺序表的存储结构------//
#define MAXSIZE 100 //顺序表可能达到的最大长度
typedef struct
{
ElemType *elem; //或ElemType elem[MAXSIZE] 存储空间的基地址
int length; //当前长度
}SqList; //顺序表的结构类型为SqList
//------顺序表的初始化------//
//-----【算法步骤】 -----//
//1.为顺序表 L动态分配一个预定义大小的数组空间，使elem指向这段空间的基地址。
//2.将表的当前长度设为0。
bool InitList(SqList &L)
{
//构造一个空的顺序表L
L.elem=new int[MAXSIZE]; //为顺序表分配一个大小为MAXSIZE的数组空间
if(!L.elem) return false; //存储分配失败退出
L.length=0; //空表长度为0
return true;
}
//------顺序表初始化前n个数据------//
bool CreateList(SqList &L,int n)
{
if(n<0||n>MAXSIZE) return false; //n值不合法
for(int i=0; iL.length) return ERROR; //判断i值是否合理
e=L.elem[i-1]; //elem[i-1]单元存储第i个数据元素
return OK;
}
//------输出打印顺序表 按位置从小到大输出顺序表所有元素------//
void PrintList(SqList L)
{
printf("当前顺序表中所有元素为：");
for(int i=0; i 运行结果：
5.顺序表L的倒置：
顺序表L的倒置的核心代码：
//------顺序表L的倒置------//
void ReverseList(SqList &L)
{
//顺序表L的逆置
for(int i=0;i顺序表L的倒置的完整代码如下：
//******************************先创建一个长度为n的顺序表L，然后对顺序表L中的元素进行倒置******************************//
#include
#define OK 1
#define ERROR 0
typedef int ElemType;
typedef int Status;
//------顺序表的存储结构------//
#define MAXSIZE 100 //顺序表可能达到的最大长度
typedef struct
{
ElemType *elem; //或ElemType elem[MAXSIZE] 存储空间的基地址
int length; //当前长度
}SqList; //顺序表的结构类型为SqList
//------顺序表的初始化------//
//-----【算法步骤】 -----//
//1.为顺序表 L动态分配一个预定义大小的数组空间，使elem指向这段空间的基地址。
//2.将表的当前长度设为0。
bool InitList(SqList &L)
{
//构造一个空的顺序表L
L.elem=new int[MAXSIZE]; //为顺序表分配一个大小为MAXSIZE的数组空间
if(!L.elem) return false; //存储分配失败退出
L.length=0; //空表长度为0
return true;
}
//------顺序表初始化前n个数据------//
bool CreateList(SqList &L,int n)
{
if(n<0||n>MAXSIZE) return false; //n值不合法
for(int i=0; i 运行结果：
