数据结构——线性表（顺序表的增、删、查）

-------顺序表介绍-------
线性表的顺序存储又称顺序表; 用一组地址连续的存储单元（数组)依次存储线性表中的数据元素，从而使得逻辑上相邻的两个元素在物理位置上也相邻。一维数组可以静态分配，也可以动态分配。关于静态分配，数组的大小空间事先固定，空间占满，加入新数据就会溢出。动态分配，存储空间通过执行程序中的动态分配存储语句实现，一旦数据空间占满，就另外开辟一块更大的存储空间，用来替换原来的存储空间，从而达到扩充存储的目的。
特点： 增删操作需移动大量数据元素; 支持随机存取。
-----------定义----------
【静态分配】
#define MaxSize 100 //线性表最大长度
typedf struct SqList{
Elemtype data[MaxSize]; //数据域
int length; //顺序表的长度
}SqList;
【动态分配】
#define InitSize 100 //表长度初始定义
typedf struct SqList{
Elemtype *data //指示动态分配数组的指针
int MaxSize,length; //数组的最大容量和长度
}SeqList;
-------基本操作-------
InitSqList(&L); //初始化
InsertList(&L,int i,ElemType e); //在位序为i的位置插入元素e
DeleteList(&L,int i,&e); //删除位序i处的数据元素，并用e记录被删的元素值
GetElement(L,i); //查找位序i处的数据元素值
LocateElement(L,e); //查找数据元素值为e所在的位置
Length(L); //顺序表长度
PrintList(L); //输出操作
--------实现---------
【静态分配】

//顺序表——静态分配
#include <stdio.h>
#define MaxSize 100
typedef struct {
int data[MaxSize];
int length;
} SqList;
bool InitSqList(SqList &L) {
for(int i=0; i<L.length; i++) {
L.data[i]=0;
}
L.length=0;
return true;
}
bool InsertList(SqList &L) {
int i;
//创建也属于插入操作这里请从位序1处开始插入
printf("请输入要插入元素的位序：n");
scanf("%d",&i);
while(i!=9999) {
if(L.length==MaxSize) return false;
if(i<1||i>L.length+1) {
printf("待插入位置违法！！！nn");
return false;
}
int e;
printf("请输入要插入的元素值：n");
scanf("%d",&e);
//插入位置的往后元素均后移
for(int j=L.length; j>=i; j--) {
L.data[j]=L.data[j-1];
}
L.data[i-1]=e;
L.length++;
printf("请输入要插入元素的位序：n");
scanf("%d",&i);
}
return true;
}
bool DeleteList(SqList &L,int &e) {
if(L.length==0) return false;
int i;
printf("请输入要删除元素的位序：n");
scanf("%d",&i);
if(i<1||i>L.length) {
printf("待删除位置违法！！！nn");
return false;
}
//待删除元素的往后元素前移
e=L.data[i-1];
for(int j=i; j<=L.length; j++) {
L.data[j-1]=L.data[j];
}
L.length--;
return true;
}
bool GetElement(SqList L) {
if(L.length!=0) {
int i;
printf("请输入要查找元素的位序: ");
scanf("%d",&i);
if(i<1||i>L.length) {
printf("待查找位置违法！！！nn");
return false;
}
printf("要查找的元素为：%4dn",L.data[i-1]);
return true;
}
return false;
}
int LocateElement(SqList L){
if(L.length!=0) {
int e;
printf("请输入要查找的元素值： ");
scanf("%d",&e);
int i=1;
while(L.data[i-1]!=e) i++;
printf("要查找的元素值位序是：%4dnn",i);
return i;
}
return 0;
}
int Length(SqList L) {
printf("顺序表的长度是: %4dnn",L.length);
return L.length;
}
SqList PrintList(SqList L) {
printf("顺序表:n");
for(int i=0; i<L.length; i++)
printf(" %4d",L.data[i]);
return L;
};
int main() {
SqList L;//声明一个顺序表
InitSqList(L);//顺序表初始化
InsertList(L);
int e=-1;
DeleteList(L,e);
GetElement(L);
LocateElement(L);
Length(L);
PrintList(L);
return 0;
}

【动态分配】

//顺序表——动态分配
#include <stdio.h>
#include <malloc.h>
//线性表——顺序表——动态分配
#define InitSize 10

typedef struct {
int *data;
int length;
int MaxSize;
} SeqList;
//初始化操作
bool InitList(SeqList &L) {
L.data=(int *)malloc(InitSize*sizeof(int));//在内存中开辟一整片的连续存储空间
L.length=0;
L.MaxSize=InitSize;
return true;
}
//创建表操作。
bool CreateList(SeqList &L,int n) {
if(n>L.MaxSize||n<=0)
return false;
printf("n请输入表中元素值：n");
for(int i=0; i<n; i++)
scanf("%d", &L.data[i]);
L.length=n;
return true;
}
//求表长。返回线性表L的长度
int Length(SeqList L) {
return L.length;
}
//输出操作。 按前后顺序输入线性表L的所有元素值
void PrintList(SeqList &L) {
printf("n顺序表中的元素为：n");
for(int i=0; i<L.length; i++)
printf("%4d",L.data[i]);
printf("nn");
}
//插入操作。在表L的第i个位置插入指定元素e。
bool InsertList(SeqList &L,int i,int e) {
if(i<1||i>L.length+1) //判断i的合法性
return false;
if(L.length>L.MaxSize) //线性表已满不能插入。
return false;
for(int j=L.length; j>=i; j-- ) //每插入一个元素，该位置之后元素后移一位 ，且从最后一个位置开始后移动。
L.data[j]=L.data[j-1];//注意位序与数组下标的关系 位序=数组下标+1。
L.data[i-1]=e;
L.length++;
return true;
}
//删除操作。删除表L中第i个位置元素，并用e返回删除值。
bool
DeleteList(SeqList &L,int i,int &e) {
if(i<1||i>L.length) //判断i的合法性。
return false;
e=L.data[i-1];
for(int j=i; j<L.length; j++ ) //删除位置i元素，该位置之后所有元素前移一位 ，且从最近一个元素位置开始向前移动。
L.data[j-1]=L.data[j];//注意位序与数组下标的关系 位序=数组下标+1。
L.length--;
printf("n删除的元素值为：%dn",e);
return true;
}
//按值查找操作。在表L中查找具有给定关键字的元素 。
boolLocateElem(SeqList L,int e) {
for (int j=0; j<L.length; j++)
if(L.data[j]==e) {
return j+1;
}
return false;
}
//按位查找操作。获取表L中第i个位置的值 。
int GetElem(SeqList L,int i) {
return L.data[i-1];
}
//动态增加数组长度
void IncreaseSize(SeqList L,int len) {
int *p=L.data;
L.data=(int *)malloc((L.MaxSize+len)*sizeof(int)); //开辟一片新的存储空间，其最大容量为 L.MaxSize+len
for(int j=0; j<L.length+len; j++) { //将新数据复制到新区域
L.data[j]=p[j];
}
L.MaxSize=L.MaxSize+len;
free(p);
}
int main() {
int n;
int e=-1;//用于带回被删除的值
//声明
SeqList L;
//初始化操作
InitList(L);
//创建操作
printf("n请输入要存入的数据元素个数：n");
scanf("%d", &n);
CreateList(L,n) ;
//求表长操作
printf("n顺序表的当前长度为：%dn",Length(L));
//输出操作
PrintList(L);
//插入操作
InsertList(L,1,1);
printf("n第一个位置插入元素值1后：n");
PrintList(L);
//删除操作
DeleteList(L,2,e);
printf("n删除第二个位置元素值后：n");
PrintList(L);
//按位查找操作
printf("n按位查找第三个元素,返回其值：%dn",GetElem(L,3));
//按值查找操作
printf("n按值查找元素3,返回其位序：%dn",LocateElem(L,3));
//动态增加数组长度操作
IncreaseSize(L,5);
return 0;
}

最后

以上就是谨慎柠檬为你收集整理的数据结构——线性表（顺序表的增、删、查）的全部内容，希望文章能够帮你解决数据结构——线性表（顺序表的增、删、查）所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。