顺序表基本功能实现完整版

最新推荐文章于 2023-08-01 18:24:58 发布
最新推荐文章于 2023-08-01 18:24:58 发布
阅读量355 收藏 3
点赞数 1
分类专栏： 中国大学MOOC-陈越、何钦铭-数据结构-起步能力自测题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43862765/article/details/115438887
版权
一、视频讲解
  • 抽象数据类型：https://www.bilibili.com/video/BV19V411m7MB
  • 顺序存储及定义：https://www.bilibili.com/video/BV1t54y1k729
  • 顺序存储实现·上：https://www.bilibili.com/video/BV1FK4y1h7rZ
  • 顺序存储实现·下：https://www.bilibili.com/video/BV1cV411278T
二、对应博客（勿记笔记）
  • 系列博客：http://www.nowamagic.net/librarys/veda/detail/2198
  • 和视频配套，疑似一人所做
三、抽象数据类型线性表的基本操作

  • 初始化线性表InitList(&L)

    构造一个空的线性表L

    (1)为线性表申请内存空间
(2)length成员设置为0
void InitList(SqList* &list){
    list = (sqList *)malloc(sizeof(SqList));
    list->length = 0;
}

    # include <stdio.h>
# include <stdlib.h>

typedef int ElemType;
# define MaxSize 100

typedef struct{
	ElemType datas[MaxSize];
	int length;
}SqList;

void InitList(SqList* &L);
int main() {
	// 初始化结构体
	SqList *p;
	// 初始化线性表
	InitList(p);
    // 输出测试
	printf("%d",p->length); 
	return 0;
} 

// 初始化线性表
/*指针的引用：int *&a = p;其中p本身就是指针，所以a和p其实是指向同一块地址的*/ 
void InitList(SqList* &L) {
	// 动态分配
	L = (SqList *)malloc(sizeof(SqList)); 
	L->length = 0;
}

  • 顺序表的创建CreateList

    运算的结果是构造一个含有n个数据元素的线性表

    (1)为线性表申请内存空间
(2)逐个将数组中的元素读取到线性表的data数组成员中
(3)设置线性表的长度,length成员赋值

    # include <stdio.h>
# include <stdlib.h>

typedef int ElemType;
# define MaxSize 100
 
typedef struct {
	ElemType datas[MaxSize];
	int length;
} SqList;

// 函数的声明 
void InitList(SqList *L);
void CreateList(SqList *L,ElemType a[],int n);

int main() {
	// 初始化结构体
	SqList L;
	InitList(&L);
	// 需要初始化数组
	int a[] = {3,4,7,8,1,2,5,6,0};
	// 计算数组的长度
	int n = sizeof(a) / sizeof(a[0]);
	CreateList(&L,a,n);
	printf("线性表的长度为:%d",L.length);
	return 0;
} 

// 线性表的初始化 
void InitList(SqList *L){
	L = (SqList *)malloc(sizeof(SqList));
	L->length = 0;
}

// 顺序表的创建
void CreateList(SqList *L,ElemType a[],int n){
	int i;
	// 因为在InitList中已经申请了内存空间了，所以这步可以省去
	for(i = 0;i < n && i < MaxSize;i++){
		L->datas[i] = a[i];
		L->length += 1;
	} 
}

    注意：CreateList内部循环条件的判断同样要求要小于线性表初始化时数组的长度

  • 判断线性表是否为空表ListEmpty(L)

    若为空表length == 0，则返回真，否则返回假

    # include <stdio.h>
# include <stdlib.h>

typedef int ElemType;
# define MaxSize 100
 
typedef struct {
	ElemType datas[MaxSize];
	int length;
} SqList;

// 函数的声明 
void InitList(SqList *L);
void CreateList(SqList *L,ElemType a[],int n);
bool ListEmpty(SqList *L);

int main() {
	// 初始化结构体
	SqList L;
	InitList(&L);
	// 需要初始化数组
	int a[] = {3,4,7,8,1,2,5,6,0};
	// 计算数组的长度
	int n = sizeof(a) / sizeof(a[0]);
	CreateList(&L,a,n);
	printf("线性表是否是空表:%d",ListEmpty(&L));
	return 0;
} 

// 线性表的初始化 
void InitList(SqList *L){
	L = (SqList *)malloc(sizeof(SqList));
	L->length = 0;
}

// 顺序表的创建
void CreateList(SqList *L,ElemType a[],int n){
	int i;
	// 因为在InitList中已经申请了内存空间了，所以这步可以省去
	for(i = 0;i < n && i < MaxSize;i++){
		L->datas[i] = a[i];
		L->length += 1;
	} 
} 

// 线性表的判空
bool ListEmpty(SqList *L){
	// length == 0则返回真，否则返回假 
	return (L->length == 0);
}

  • 求线性表的长度ListLength(L)

    返回L中元素的个数n

    # include <stdio.h>
# include <stdlib.h>

typedef int ElemType;
# define MaxSize 100
 
typedef struct {
	ElemType datas[MaxSize];
	int length;
} SqList;

// 函数的声明 
void InitList(SqList *L);
void CreateList(SqList *L,ElemType a[],int n);
bool ListEmpty(SqList *L);
void DispList(SqList *L);
int ListLength(SqList *L);

int main() {
	// 初始化结构体
	SqList L;
	InitList(&L);
	// 需要初始化数组
	int a[] = {3,4,7,8,1,2,5,6,0};
	// 计算数组的长度
	int n = sizeof(a) / sizeof(a[0]);
	CreateList(&L,a,n);
	DispList(&L);
	printf("%d",ListLength(&L));
	return 0;
} 

// 线性表的初始化 
void InitList(SqList *L){
	L = (SqList *)malloc(sizeof(SqList));
	L->length = 0;
}

// 顺序表的创建
void CreateList(SqList *L,ElemType a[],int n){
	int i;
	// 因为在InitList中已经申请了内存空间了，所以这步可以省去
	for(i = 0;i < n && i < MaxSize;i++){
		L->datas[i] = a[i];
		L->length += 1;
	} 
} 

// 线性表的判空
bool ListEmpty(SqList *L){
	// length == 0则返回真，否则返回假 
	return (L->length == 0);
} 

// 输出线性表
void DispList(SqList *L){
	int i;
	// 当线性表是空时，不输出显示 
	if (ListEmpty(L)) return;
	else{
		for(i = 0;i < L->length;i++) {
			printf("%d\t",L->datas[i]);
		}
		printf("\n");
	}
} 

// 返回线性表的表长
int ListLength(SqList *L){
	return L->length;
}

  • 输出线性表DispList(L)

    线性表L不为空时，顺序显示各结点的值

    # include <stdio.h>
# include <stdlib.h>

typedef int ElemType;
# define MaxSize 100
 
typedef struct {
	ElemType datas[MaxSize];
	int length;
} SqList;

// 函数的声明 
void InitList(SqList *L);
void CreateList(SqList *L,ElemType a[],int n);
bool ListEmpty(SqList *L);
void DispList(SqList *L);

int main() {
	// 初始化结构体
	SqList L;
	InitList(&L);
	// 需要初始化数组
	int a[] = {3,4,7,8,1,2,5,6,0};
	// 计算数组的长度
	int n = sizeof(a) / sizeof(a[0]);
	CreateList(&L,a,n);
	DispList(&L);
	return 0;
} 

// 线性表的初始化 
void InitList(SqList *L){
	L = (SqList *)malloc(sizeof(SqList));
	L->length = 0;
}

// 顺序表的创建
void CreateList(SqList *L,ElemType a[],int n){
	int i;
	// 因为在InitList中已经申请了内存空间了，所以这步可以省去
	for(i = 0;i < n && i < MaxSize;i++){
		L->datas[i] = a[i];
		L->length += 1;
	} 
} 

// 线性表的判空
bool ListEmpty(SqList *L){
	// length == 0则返回真，否则返回假 
	return (L->length == 0);
} 

// 输出线性表
void DispList(SqList *L){
	int i;
	// 当线性表是空时，不输出显示 
	if (ListEmpty(L)) return;
	else{
		for(i = 0;i < L->length;i++) {
			printf("%d\t",L->datas[i]);
		}
		printf("\n");
	}
}

  • 求线性表L中指定位置的某个数据元素GetElem(L,i,&e)

    用e返回L中第i(1≤i≤n)个元素的值

    (1)操作成功的话值为true，否则为false
(2)长度为0或者超出最大的范围(大于length)，返回false

    # include <stdio.h>
# include <stdlib.h>

typedef int ElemType;
# define MaxSize 100
 
typedef struct {
	ElemType datas[MaxSize];
	int length;
} SqList;

// 函数的声明 
void InitList(SqList *L);
void CreateList(SqList *L,ElemType a[],int n);
bool ListEmpty(SqList *L);
void DispList(SqList *L);
int ListLength(SqList *L);
bool  GetElem(SqList *L,int i,ElemType &e);

int main() {
	// 初始化结构体
	SqList L;
	InitList(&L);
	// 需要初始化数组
	int a[] = {3,4,7,8,1,2,5,6,0};
	// 计算数组的长度
	int n = sizeof(a) / sizeof(a[0]);
	CreateList(&L,a,n);
	DispList(&L);
	// 操作成功则输出获取的元素的值
	ElemType m;
	int i = 2;
	if(GetElem(&L,i,m)){
		printf("获取到的第%d个元素是:%d",i,m);
	} 
	return 0;
} 

// 线性表的初始化 
void InitList(SqList *L){
	L = (SqList *)malloc(sizeof(SqList));
	L->length = 0;
}

// 顺序表的创建
void CreateList(SqList *L,ElemType a[],int n){
	int i;
	// 因为在InitList中已经申请了内存空间了，所以这步可以省去
	for(i = 0;i < n && i < MaxSize;i++){
		L->datas[i] = a[i];
		L->length += 1;
	} 
} 

// 线性表的判空
bool ListEmpty(SqList *L){
	// length == 0则返回真，否则返回假 
	return (L->length == 0);
} 

// 输出线性表
void DispList(SqList *L){
	int i;
	// 当线性表是空时，不输出显示 
	if (ListEmpty(L)) return;
	else{
		for(i = 0;i < L->length;i++) {
			printf("%d\t",L->datas[i]);
		}
		printf("\n");
	}
} 

// 返回线性表的表长
int ListLength(SqList *L){
	return L->length;
} 

// 获取线性表某位置的元素
bool  GetElem(SqList *L,int i,ElemType &e){
	if(i < 1 || i > L->length) return false;
	else{
		e = L->datas[i-1];
		return true;
	}
}

  • 定位查找LocateElem(L,e)

    返回L中第一个值与e相等的逻辑位序，若这样的元素不存在则返回值0

    算法步骤:
(1)循环变量i初始化为0
(2)比较下标i所指向的数据是否与e相等，如果相等则找到了，返回i+1,否则循环变量自增1
(3)判断是否扫描完所有的数据元素，若没有则返回(2)，否则到下一步
(4)返回0

    # include <stdio.h>
# include <stdlib.h>

typedef int ElemType;
# define MaxSize 100
 
typedef struct {
	ElemType datas[MaxSize];
	int length;
} SqList;

// 函数的声明 
void InitList(SqList *L);
void CreateList(SqList *L,ElemType a[],int n);
bool ListEmpty(SqList *L);
void DispList(SqList *L);
int ListLength(SqList *L);
bool  GetElem(SqList *L,int i,ElemType &e);
int LocateElem(SqList *L,ElemType e);

int main() {
	// 初始化结构体
	SqList L;
	InitList(&L);
	// 需要初始化数组
	int a[] = {3,4,7,8,1,2,5,6,0};
	// 计算数组的长度
	int n = sizeof(a) / sizeof(a[0]);
	CreateList(&L,a,n);
	DispList(&L);
	// 操作成功则输出获取的元素的值
	ElemType m;
	int i = 2;
	if(GetElem(&L,i,m)){
		printf("获取到的第%d个元素是:%d\n",i,m);
	} 
	// 寻找6在线性表中是第几个元素 
	int find_value = 6;
	if(LocateElem(&L,find_value)){
		printf("%d在线性表中是第%d个元素\n",find_value,LocateElem(&L,find_value));
	}
	return 0;
} 

// 线性表的初始化 
void InitList(SqList *L){
	L = (SqList *)malloc(sizeof(SqList));
	L->length = 0;
}

// 顺序表的创建
void CreateList(SqList *L,ElemType a[],int n){
	int i;
	// 因为在InitList中已经申请了内存空间了，所以这步可以省去
	for(i = 0;i < n && i < MaxSize;i++){
		L->datas[i] = a[i];
		L->length += 1;
	} 
} 

// 线性表的判空
bool ListEmpty(SqList *L){
	// length == 0则返回真，否则返回假 
	return (L->length == 0);
} 

// 输出线性表
void DispList(SqList *L){
	int i;
	// 当线性表是空时，不输出显示 
	if (ListEmpty(L)) return;
	else{
		for(i = 0;i < L->length;i++) {
			printf("%d\t",L->datas[i]);
		}
		printf("\n");
	}
} 

// 返回线性表的表长
int ListLength(SqList *L){
	return L->length;
} 

// 获取线性表某位置的元素
bool  GetElem(SqList *L,int i,ElemType &e){
	if(i < 1 || i > L->length) return false;
	else{
		e = L->datas[i-1];
		return true;
	}
}

// 定位某个值在线性表中的位置
int LocateElem(SqList *L,ElemType e){
	int i;
	for(i = 0;i < L->length;i++){
		if(L->datas[i] == e){
			return (i + 1);
		}
	}
	// 没有找到就返回0 
	return 0;
}

  • 插入一个数据元素ListInsert(&L,i,e)

    在L的第i(1≤i≤n)个元素之前插入新的元素e，L的长度增1

    算法步骤：
(1)判断插入的位置i是否合法，不合法则返回false，合法则到下一步
(2)判断顺序表的存储空间是否已满，满了则返回false，否则进入下一步
(3)将从最后一个到第i个元素依次向后移动一个位置，空出第i个位置
(4)将e赋值为下标为i的数据项
(5)线性表的长度+1
(6)插入成功返回true

时间复杂度:
元素移动和表长L->length=n有关，也与插入位置i有关
- 当i = n + 1时，移动次数为0，算法最好时间复杂度为O(1)
- 当i = 1时，移动次数为n，达到最大值，苏纳法最坏时间复杂度为O(n)

    # include <stdio.h>
# include <stdlib.h>

typedef int ElemType;
# define MaxSize 100
 
typedef struct {
	ElemType datas[MaxSize];
	int length;
} SqList;

// 函数的声明 
void InitList(SqList *L);
void CreateList(SqList *L,ElemType a[],int n);
bool ListEmpty(SqList *L);
void DispList(SqList *L);
int ListLength(SqList *L);
bool  GetElem(SqList *L,int i,ElemType &e);
int LocateElem(SqList *L,ElemType e);
bool ListInsert(SqList *L,int i,ElemType e);

int main() {
	// 初始化结构体
	SqList L;
	InitList(&L);
	// 需要初始化数组
	int a[] = {3,4,7,8,1,2,5,6,0};
	// 计算数组的长度
	int n = sizeof(a) / sizeof(a[0]);
	CreateList(&L,a,n);
	DispList(&L);
	// 操作成功则输出获取的元素的值
	ElemType m;
	int i = 2;
	if(GetElem(&L,i,m)){
		printf("获取到的第%d个元素是:%d\n",i,m);
	} 
	// 寻找6在线性表中是第几个元素 
	int find_value = 6;
	if(LocateElem(&L,find_value)){
		printf("%d在线性表中是第%d个元素\n",find_value,LocateElem(&L,find_value));
	}
	// 开始插入元素
	int insert_value = 10;
	int insert_location = 3;
	if(ListInsert(&L,insert_location,insert_value)){
		// 输出线性表进行对比
		printf("向第%d个位置插入元素%d后：\n",insert_location,insert_value);
		DispList(&L); 
	} 
	return 0;
} 

// 线性表的初始化 
void InitList(SqList *L){
	L = (SqList *)malloc(sizeof(SqList));
	L->length = 0;
}

// 顺序表的创建
void CreateList(SqList *L,ElemType a[],int n){
	int i;
	// 因为在InitList中已经申请了内存空间了，所以这步可以省去
	for(i = 0;i < n && i < MaxSize;i++){
		L->datas[i] = a[i];
		L->length += 1;
	} 
} 

// 线性表的判空
bool ListEmpty(SqList *L){
	// length == 0则返回真，否则返回假 
	return (L->length == 0);
} 

// 输出线性表
void DispList(SqList *L){
	int i;
	// 当线性表是空时，不输出显示 
	if (ListEmpty(L)) return;
	else{
		for(i = 0;i < L->length;i++) {
			printf("%d\t",L->datas[i]);
		}
		printf("\n");
	}
} 

// 返回线性表的表长
int ListLength(SqList *L){
	return L->length;
} 

// 获取线性表某位置的元素
bool  GetElem(SqList *L,int i,ElemType &e){
	if(i < 1 || i > L->length) return false;
	else{
		e = L->datas[i-1];
		return true;
	}
}

// 定位某个值在线性表中的位置
int LocateElem(SqList *L,ElemType e){
	int i;
	for(i = 0;i < L->length;i++){
		if(L->datas[i] == e){
			return (i + 1);
		}
	}
	// 没有找到就返回0 
	return 0;
}

// 向线性表某位置插入元素
bool ListInsert(SqList *L,int i,ElemType e){
	if(i > L->length + 1 || i < 1) return false;
	else{
		// 逻辑位序转换为物理位序
		i -= 1;
		int j;
		for(j = L->length;j > i;j--) {
			// 依次向后移
			L->datas[j] = L->datas[j-1]; 
		} 
		L->datas[i] = e;
		L->length += 1;
	}
	return true;
}

  • 线性表元素删除操作ListDelete(&L,i,&e)

    删除线性表的某个元素

    算法步骤：
(1)判断删除位置i是否合法，不合法则返回false，合法则到下一步
(2)将要删除的元素保存到输出参数e中
(3)从第i+1个元素到最后一个元素，顺序前移一个位置
(4)线性表长度减1
(5)删除成功，返回true

时间复杂度情况和插入几乎一致

    # include <stdio.h>
# include <stdlib.h>

typedef int ElemType;
# define MaxSize 100
 
typedef struct {
	ElemType datas[MaxSize];
	int length;
} SqList;

// 函数的声明 
void InitList(SqList *L);
void CreateList(SqList *L,ElemType a[],int n);
bool ListEmpty(SqList *L);
void DispList(SqList *L);
int ListLength(SqList *L);
bool  GetElem(SqList *L,int i,ElemType &e);
int LocateElem(SqList *L,ElemType e);
bool ListInsert(SqList *L,int i,ElemType e);
bool ListDelete(SqList *L,int i,ElemType &e);

int main() {
	// 初始化结构体
	SqList L;
	InitList(&L);
	// 需要初始化数组
	int a[] = {3,4,7,8,1,2,5,6,0};
	// 计算数组的长度
	int n = sizeof(a) / sizeof(a[0]);
	CreateList(&L,a,n);
	DispList(&L);
	// 操作成功则输出获取的元素的值
	ElemType m;
	int i = 2;
	if(GetElem(&L,i,m)){
		printf("获取到的第%d个元素是:%d\n",i,m);
	} 
	// 寻找6在线性表中是第几个元素 
	int find_value = 6;
	if(LocateElem(&L,find_value)){
		printf("%d在线性表中是第%d个元素\n",find_value,LocateElem(&L,find_value));
	}
	// 开始插入元素
	int insert_value = 10;
	int insert_location = 3;
	if(ListInsert(&L,insert_location,insert_value)){
		// 输出线性表进行对比
		printf("向第%d个位置插入元素%d后：\n",insert_location,insert_value);
		DispList(&L); 
	} 
	// 开始删除元素
	int delete_location =  4;
	if(ListDelete(&L,delete_location,m)){
		// 确实操作成功了，直接显示线性表
		printf("删除第%d号元素%d后：\n",delete_location,m);
		DispList(&L);
	}
	return 0;
} 

// 线性表的初始化 
void InitList(SqList *L){
	L = (SqList *)malloc(sizeof(SqList));
	L->length = 0;
}

// 顺序表的创建
void CreateList(SqList *L,ElemType a[],int n){
	int i;
	// 因为在InitList中已经申请了内存空间了，所以这步可以省去
	for(i = 0;i < n && i < MaxSize;i++){
		L->datas[i] = a[i];
		L->length += 1;
	} 
} 

// 线性表的判空
bool ListEmpty(SqList *L){
	// length == 0则返回真，否则返回假 
	return (L->length == 0);
} 

// 输出线性表
void DispList(SqList *L){
	int i;
	// 当线性表是空时，不输出显示 
	if (ListEmpty(L)) return;
	else{
		for(i = 0;i < L->length;i++) {
			printf("%d\t",L->datas[i]);
		}
		printf("\n");
	}
} 

// 返回线性表的表长
int ListLength(SqList *L){
	return L->length;
} 

// 获取线性表某位置的元素
bool  GetElem(SqList *L,int i,ElemType &e){
	if(i < 1 || i > L->length) return false;
	else{
		e = L->datas[i-1];
		return true;
	}
}

// 定位某个值在线性表中的位置
int LocateElem(SqList *L,ElemType e){
	int i;
	for(i = 0;i < L->length;i++){
		if(L->datas[i] == e){
			return (i + 1);
		}
	}
	// 没有找到就返回0 
	return 0;
}

// 向线性表某位置插入元素
bool ListInsert(SqList *L,int i,ElemType e){
	if(i > L->length + 1 || i < 1) return false;
	else{
		// 逻辑位序转换为物理位序
		i -= 1;
		int j;
		for(j = L->length;j > i;j--) {
			// 依次向后移
			L->datas[j] = L->datas[j-1]; 
		} 
		L->datas[i] = e;
		L->length += 1;
	}
	return true;
}

// 删除线性表中第i个位置的元素
bool ListDelete(SqList *L,int i,ElemType &e){
	if(i < 1 || i > L->length) return false;
	else{
		// 逻辑位序转化为物理位序
		i -= 1;
		int j;
		e = L->datas[i];
		for(j = i;j < L->length;j++){
			// 依次往前推
			L->datas[i] = L->datas[i+1];
		} 
		L->length -= 1;
		return true;
	}
}

在这里插入图片描述

  • 线性表的销毁DestroyList(& L)

    释放线性表占用的内存空间，仅执行释放线性表所占内存空间的操作

    # include <stdio.h>
# include <stdlib.h>

typedef int ElemType;
# define MaxSize 100
 
typedef struct {
	ElemType datas[MaxSize];
	int length;
} SqList;

// 函数的声明 
void InitList(SqList *L);
void CreateList(SqList *L,ElemType a[],int n);
bool ListEmpty(SqList *L);
void DispList(SqList *L);
int ListLength(SqList *L);
bool  GetElem(SqList *L,int i,ElemType &e);
int LocateElem(SqList *L,ElemType e);
bool ListInsert(SqList *L,int i,ElemType e);
bool ListDelete(SqList *L,int i,ElemType &e);
void DestroyList(SqList *L);

int main() {
	// 初始化结构体
	SqList L;
	InitList(&L);
	// 需要初始化数组
	int a[] = {3,4,7,8,1,2,5,6,0};
	// 计算数组的长度
	int n = sizeof(a) / sizeof(a[0]);
	CreateList(&L,a,n);
	DispList(&L);
	// 操作成功则输出获取的元素的值
	ElemType m;
	int i = 2;
	if(GetElem(&L,i,m)){
		printf("获取到的第%d个元素是:%d\n",i,m);
	} 
	// 寻找6在线性表中是第几个元素 
	int find_value = 6;
	if(LocateElem(&L,find_value)){
		printf("%d在线性表中是第%d个元素\n",find_value,LocateElem(&L,find_value));
	}
	// 开始插入元素
	int insert_value = 10;
	int insert_location = 3;
	if(ListInsert(&L,insert_location,insert_value)){
		// 输出线性表进行对比
		printf("向第%d个位置插入元素%d后：\n",insert_location,insert_value);
		DispList(&L); 
	} 
	// 开始删除元素
	int delete_location =  4;
	if(ListDelete(&L,delete_location,m)){
		// 确实操作成功了，直接显示线性表
		printf("删除第%d号元素%d后：\n",delete_location,m);
		DispList(&L);
	}
	// 销毁线性表
	DestroyList(&L);
	return 0;
} 

// 线性表的初始化 
void InitList(SqList *L){
	L = (SqList *)malloc(sizeof(SqList));
	L->length = 0;
}

// 顺序表的创建
void CreateList(SqList *L,ElemType a[],int n){
	int i;
	// 因为在InitList中已经申请了内存空间了，所以这步可以省去
	for(i = 0;i < n && i < MaxSize;i++){
		L->datas[i] = a[i];
		L->length += 1;
	} 
} 

// 线性表的判空
bool ListEmpty(SqList *L){
	// length == 0则返回真，否则返回假 
	return (L->length == 0);
} 

// 输出线性表
void DispList(SqList *L){
	int i;
	// 当线性表是空时，不输出显示 
	if (ListEmpty(L)) return;
	else{
		for(i = 0;i < L->length;i++) {
			printf("%d\t",L->datas[i]);
		}
		printf("\n");
	}
} 

// 返回线性表的表长
int ListLength(SqList *L){
	return L->length;
} 

// 获取线性表某位置的元素
bool  GetElem(SqList *L,int i,ElemType &e){
	if(i < 1 || i > L->length) return false;
	else{
		e = L->datas[i-1];
		return true;
	}
}

// 定位某个值在线性表中的位置
int LocateElem(SqList *L,ElemType e){
	int i;
	for(i = 0;i < L->length;i++){
		if(L->datas[i] == e){
			return (i + 1);
		}
	}
	// 没有找到就返回0 
	return 0;
}

// 向线性表某位置插入元素
bool ListInsert(SqList *L,int i,ElemType e){
	if(i > L->length + 1 || i < 1) return false;
	else{
		// 逻辑位序转换为物理位序
		i -= 1;
		int j;
		for(j = L->length;j > i;j--) {
			// 依次向后移
			L->datas[j] = L->datas[j-1]; 
		} 
		L->datas[i] = e;
		L->length += 1;
	}
	return true;
}

// 删除线性表中第i个位置的元素
bool ListDelete(SqList *L,int i,ElemType &e){
	if(i < 1 || i > L->length) return false;
	else{
		// 逻辑位序转化为物理位序
		i -= 1;
		int j;
		e = L->datas[i];
		for(j = i;j < L->length;j++){
			// 依次往前推
			L->datas[i] = L->datas[i+1];
		} 
		L->length -= 1;
		return true;
	}
}

// 销毁线性表
void DestroyList(SqList *L){
	free(L);
	L = NULL;
}
lucky lures
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
顺序表操作（数据结构C语言版）
07-05
顺序表操作（数据结构C语言版），完整的程序可以下载运行，并附有菜单可以选择要实现的功能
常用Jquery插件整理大全
weixin_30906185的博客
05-25 76
常用Jquery插件整理大全 做项目的时候总是少不了要用到Jquery插件，但是Jquery插件有太多，每次都要花费一些时间，因此本人就抽时间整理了一些Jquery插件，每个插件都有Demo或者是使用文档供大家下载。整理了一晚上才整理这么多，先分享给大家，下边还有后续………整理这些东西真的不容易，希望大家转载的时候注明出处，尊重一下我的劳动成果，不过大家有什么好用的插件，多多推荐，大家一起学习，...
【数据结构】顺序表的实现——超级无敌详细
qq_59702185的博客
08-07 1978
在当我们每想插入一个数据的时候，我们都要对顺序表进行判断，容量 capacity 是否和 size 相等，如果相等的话，那么，顺序表的空间就不够我们进行插入数据了。当然我们不能需要插入一个数据就开辟一个数据的大小，这样的话，付出的代价很大，我们可以每次增容 2 倍的capacity大小的容量，或者4倍，2倍是比较好的了。在我们想把顺表表最后一个数据删除时，不能直接赋为0，第一，我们不知道SLDataType到底是什么数据类型，第二，顺序表的最后一个数据有可能就是0，没有意义。遍历一遍顺序表，打印顺序表。..
【数据结构】顺序表实现超详解（保姆级教程）
~
10-15 2121
目录 ​ 前言 顺序表 接口实现 各项功能 接口详解 顺序表初始化 顺序表释放 顺序表展示 顺序表容量检查 顺序表数据尾插 顺序表数据头插 顺序表数据前删 顺序表数据尾删 顺序表数据查找 顺序表指定位置插入数据 顺序表指定位置删除数据 前言 本章主要讲解： 顺序表以及顺序表的接口实现 注：保姆级教程，相信你一定会的~ 顺序表 顺序表是线性标的一种 概念： 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储...
详解顺序表功能
最新发布
2301_76986069的博客
08-01 535
动态顺序表只是在判断是否已满的地方多加一个扩容的函数，其他的代码和静态一模一样，思路也一模一样，我们把静态中的数组换为相应的指针，可以通过动态开辟的方式来进行增容。我们的增容是对结构体中的指针进行增容，而非对结构体本身进行增容。大家可以对比一下静态和动态的区别，动态只是在静态的基础上稍稍的进行一下改进，增加一个扩容的函数，其他的一模一样，我们下一个将会用一个小项目来加深我们顺序表印象，这是我们的第一个数据结构，我们还要用它和后面的链表进行对比。学习每个结构的优缺点，是我们在不同问题上选择最优的方案。
数据结构 —— 顺序表的结构、功能（增删查改）。
wihkum
07-08 507
数据结构 —— 顺序表
[详细完整版]数据结构实验.doc
07-11
掌握顺序表基本操作的算法实现。 3．了解顺序表的应用。 三、实验内容 1．建立顺序表。 2．在顺序表上实现插入、删除和查找操作（验证性内容）。 3．删除有序顺序表中的重复元素（设计性内容）。 4．完成一个简单...
数据结构实验报告-实现二叉树的基本操作-用顺序存储和链式存储结构
11-06
要求选用顺序存储结构和二叉链表存储结构实现抽象数据类型二叉树的基本操作。有个亮点是利用字符在dos界面显示二叉树的结构形态。 里面包含了完整的源程序和实验报告文档。 实验报告包含了完整的步骤包括： 一.抽象...
Excel 2007数据透视表完全剖析 3/7
04-01
完整清晰版 PDF ，有目录。共 100MB，分为7个分卷 Excel 2007 数据透视表完全剖析 OFFICE2007 作者:（美）杰莱（Jelen，B.），（美）亚历山大（Alexander，M.）　著，潘洪涛，解巧云　译 出版社：人民邮电出版社 ...
Excel 2007数据透视表完全剖析 1/7
04-01
完整清晰版 PDF ，有目录。共 100MB，分为7个分卷 Excel 2007 数据透视表完全剖析 OFFICE2007 作者:（美）杰莱（Jelen，B.），（美）亚历山大（Alexander，M.）　著，潘洪涛，解巧云　译 出版社：人民邮电出版社 ...
顺序表的构造及功能
qq_56627079的博客
02-27 750
顺序表的创建方式与功能
数据结构--＞顺序表各种功能的实现
m0_57037805的博客
08-09 502
数据结构中的顺序表，实现数据添加，删除，查询，移动，摧毁等操作，可以快速帮助学者提升对顺序表的了解
c语言顺序表完整操作
weixin_45684903的博客
01-28 374
` #include<stdio.h> #include<stdlib.h> #define MAXSIZE 100 #define ERROR 0 #define OK 1 typedef int ElemType; typedef int Status; typedef struct { ElemType elem[MAXSIZE]; int length; }SqList; Status InitList(SqList *L) { L->length = 0; retur
用C语言编写顺序表的增删查
esflexible的博客
09-25 225
顺序表的增删查，基于王道数据结构： #include <stdio.h> #include <stdlib.h> #define MaxSize 50 typedef int ElemType; //静态分配 typedef struct{ ElemType data[MaxSize]; int length; }SqList; //动态分配 #define InitSize 100 typedef struct{ ElemType *da...
顺序表的实现及操作【C语言最详细版】
一同进步，一同追梦
09-28 5324
数据结构 线性表中顺序表的实现和测试，让你理解顺序表底层物理逻辑，和实现相应功能的创建。
顺序表的实现（全代码）
m0_57662538的博客
03-19 4323
先给大家看看我们将会编写的函数，不喜勿喷，在有些细节方面，可以自行修改。程序完整代码我放在最后，大家可以自行下载 seqlist_t *create_seqlist(void); //创建一个空表 void clear_seqlist(seqlist_t *L); //为啥这里传递饿是指针 int is_empty_seqlist(seqlist_t *L); //判断表是否为空 int is_full_seqlist(seqlist_t *L); //判断表
顺序表的实现
qq_57827896的博客
07-30 988
顺序表
数据结构-顺序表基本功能的实现
qq_61167424的博客
03-23 2612
详细的基本功能实现（顺序表其实一点也不难）
需求确认表excel版
07-17
通过Excel，我们可以使用其提供的丰富的功能来创建一个完整而灵活的需求确认表。 在Excel中创建需求确认表时，我们可以首先定义表格的列和行，以便清晰地组织和展示需求信息。列可以包括需求编号、需求描述、优先级...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值