线性表的顺序存储基本函数实现(C语言)

最新推荐文章于 2022-09-10 16:09:08 发布
最新推荐文章于 2022-09-10 16:09:08 发布
阅读量1.1k 收藏 10
点赞数 2
分类专栏： 数据结构 文章标签： 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DYSunStar/article/details/109686030
版权
本文详细介绍了线性表的顺序存储结构，包括动态分配、初始化、构建、销毁、置空、判断空表、获取长度、取值、查找、插入、删除及遍历等基本操作。通过示例代码展示了如何在C语言中实现这些操作，并提供了测试用例进行验证。
摘要由CSDN通过智能技术生成

线性表的顺序存储结构的基本操作

头文件及宏定义

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

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define OVERFLOW -1
#define LIST_INIT_SIZE 100  //顺序表存储空间的初始分配量
#define LIST_INCREMENT 10 	//顺序表存储空间的分配增量
#define MAXSIZE 100			//数组容量

typedef int Status;
typedef int ElemType;
typedef int Array[MAXSIZE];

线性表的动态分配顺序存储结构

/*
	完整的顺序存储表三要素:基址，长度，分配的存储容量
*/
typedef struct{
	ElemType* elem;		//存储空间基址
	int length;			//当前长度
	int listsize;		//当前分配的存储容量
}SqList;

构造一个空的顺序表

为顺序表分配存储空间

Status InitList(SqList* L){
	//动态内存分配
	L = (ElemType* )malloc(sizeof(ElemType) * LIST_INIT_SIZE);
	if(L == NULL){
		return(OVERFLOW);	//存储空间分配失败
	}
	
	L -> length = 0;		//空表长度为0
	L -> listsize = LIST_INIT_SIZE;		//初始存储空间
}

初始化数组

初始化一个具有n个元素的数组

Status InitArray(Array A,int n){
	if(A == NULL || n == 0){		
		return ERROR;
	}
	
	int i = 0;
	A[i++] = 0;		//索引为0位置存放数组长度 
	while(i <= n){
		int temp;
		scanf("%d",&temp);
		A[i++] = temp;
		A[0]++; 	//长度加1 
	}
	
	return OK;
}

构建一个顺序表

将数组中的数据依次填入顺序表
前提条件：数组不为空
注：数组中数据A[0]储存元素长度，填入数据从A[I]开始

Status InitializeList(SqList* L, Array A){
	if(A == NULL){
		return ERROR;
	}
	int i = 0; 		//索引
	
	while(i < A[0]){
		L -> elem[i] = A[i + 1];
		L -> length++;		//顺序表长度加1 
		i++;
	}
	
	return OK;
}

销毁顺序表L

释放顺序表L所占的内存空间
前提条件:顺序表L已存在

Status DestoryList(SqList* L){
	if(L == NULL || L -> elem == NULL){
		return ERROR;
	}
	
	free(L -> elem);	//释放顺序表所占空间
	/*
		free(L -> elem)释放分配给指针L -> elem的动态空间，
		但L -> elem不会自动变成空指针，需要手动置空
	*/
	L -> elem = NULL;	//置空
	
	L -> length = 0;	//元素长度归0
	L -> listsize = 0;	//存储容量归0

	return OK;
}

置空顺序表

只是清除线性表中的数据，顺序表所占空间不释放
前提条件: 顺序表L已存在

Status ClearList(SqList* L){
	if(L == NULL || L -> elem == NULL){
		return ERROR;
	}
	
	L -> length = 0;

	return OK;
}

判空

如果顺序表L不为空返回TRUE,否则返回FALSE
前提条件：顺序表L已存在

Status ListEmpty(SqList L){
	if(L.elem == NULL){
		return ERROR;
	}
	return L.length == 0 ? FALSE : TRUE;
}

顺序表长度

返回顺序表长度，即数据元素个数
前提条件:顺序表L已存在

int ListLength(SqList L){
	if(L.elem == NULL){
		return ERROR;
	}
	return L -> length ;
}

取值

获得顺序表中索引为 i 的元素的取值，用e返回
前提条件:

  1. 顺序表L已存在
  2. 0 <= i <= ListLength(L) - 1
Status GetElem(SqList L, int i, ElemType* e){
	if(L.elem == NULL){
		return ERROR;
	}
	if(i < 0 || i > L.length - 1){
		return ERROR;
	}
	*e = L.elem[i];
	
	return OK;
}

查找

返回顺序表L中第1个与e满足相等关系的数据元素的索引，若不存在，则返回0
前提条件:顺序表L已存在

int LocatElem(SqList L, ElemType e){
	if(L.elem == NULL){
		return ERROR;
	}
	int i = 0;			//i为索引，从0开始
	ElemType* p = L.elem;
	
	for(i <= L.length - 1 && *p++ != e)){
		++i;
	}

	if(i <= L.length - 1){
		return i;
	}else{
		return 0;
	}
}

查找元素前驱

获取数据元素cur_e(不是第一个数据元素)的前驱将其储存在pre_e中
前提条件:线性表L已存在且至少包含2个数据元素

Status PrioElem(SqList L, ElemType cur_e, ElemType* pre_e){
	if(L.elem == NULL){
		return ERROR;
	}
	if(L.length < 2){
		return ERROR;
	}
	
	int i = 0;		//i为索引，从0开始
	while(i <= L.length - 1 && L.elem[i] != cur_e){
		++i;
	}
	//cur_e是首个数据元素或者没有找到cur_e
	if(i == 0 || i > L.length - 1){
		return ERROR;
	}
	*pre_e = L.elem[i - 1];
	
	return OK;
}

查找元素后继

获取数据元素cur_e(不是最后一个数据与元素)的后继将其存储在next_e中
前提条件:线性表L已存在且至少包含2个数据元素

Status NextElem(SqList L, ElemType cur_e, ElemType* next_e){
	if(L.elem == NULL || L.length < 2){
		return ERROR;
	}
	
	int i = 0;
	
	while(i <= L.length - 1 && L.elem[i] != cur_e){
		++i;
	}
	
	//cur_e是最后一个数据元素或者没有找到cur_e
	if(i == L.length - 1 || i >= L.length){
		return ERROR;
	} 
	
	*next_e = L.elem[i + 1];
	
	return OK; 
}

插入

向线性表索引为i的位置插入e
前提条件:

  1. 线性表L已存在
  2. 0 <= i <= L.length - 1
Status ListInsert(SqList* L, int i, ElemType e){
	if(L == NULL || L -> elem == NULL){
		return ERROR;
	}
	//i是否合理 
	if(i < 0 || i > L -> length - 1){
		return ERROR;
	}
	ElemType* newbase;		
	ElemType* p, * q; 
	
	//初始存储空间已满,增加分配
	if(L -> length >= L -> listsize){
		newbase = (ElemType* )realloc(L -> elem, (L -> listsize + LISTINCREMENT) * sizeof(ElemType));
		if(newbase == NULL){
			exit(OVERFLOW);
		}
		
		L -> elem = newbase;				//新基址
		L -> listsize += LISTINCREMENT;		//增加后的存储容量 
	} 
	
	q =  &(L -> elem[i]);		//q为插入位置
	
	//插入位置及之后的元素后移
	for(p = &(L -> elem[L -> length -1]); p >= q ; --p ){
		*(p + 1) = *p;
	}
	
	//元素e插入
	*q = e;
	
	//表长加1
	L -> length++;
	
	return OK; 
}

删除

删除线性表索引为i位置的数据元素并用e返回其值
前提条件:

  1. 线性表L已存在
  2. 0 <= i <= L.length - 1
Status ListDelete(SqList* L, int i, ElemType* e){
	if(L == NULL || L -> elem == NULL){
		return ERROR;
	}
	
	//i是否合理
	if(i < 0 || i > (L -> length -1)){
		return ERROR;
	}
	
	ElemType* p,* q; 
	
	//用e返回其值 
	*e = L -> elem[i];
	
	//q为删除位置
	q = &(L -> elem[i]);
	
	for(p = &(L -> elem[L -> length - 1]); q <= p; q++){
		*q = *(q + 1);
	}
	
	//表长减1
	L -> length--;
	
	return OK; 
}

打印线性表元素

前提条件:线性表已存在

Status ListTraverse(SqList L){
	if(L.elem == NULL){
		return ERROR;
	}
	
	int i; 	//索引
	for(i = 0; i < L.length; i++){
		printf("L.elem[%d] = %d ", i, L.elem[i]);
	}
	
	return OK;
}

测试代码

int main(void){
	SqList L;
	Array A;
	int length, n;		//n为数组元素个数 
	ElemType e, temp;
	int i = 0;		//索引
 	
 	printf("Number of input array elements n :");
	scanf("%d", &n);
	//初始化数组
	printf("Please enter n values :"); 
	InitArray(A,n); 
	
	//构造一个空的顺序表
	InitList_Sq(&L);
	
	//构建顺序表
	InitializeList(&L, A);
	
	//遍历构建后的顺序表
	printf("\n"); 
	ListTraverse(L);
	printf("\n");
	
	//判空 
	if(ListEmpty(L)){
		printf("L is empty\n");
	}else{
		printf("L is not empty\n");
	}
	
	//返回元素长度
	length = ListLength(L);
	printf("The length of L is %d\n", length);
	
	//取值(此处的3是索引，对应顺序表第四个位置) 
	if(GetElem(L, 3, &e)){
		printf("The data element with index 3 in L is %d\n", e);
	}else{
		printf("No results found!\n");
	}
	
	//定位
	i = LocateElem(L,6);
	if(i != 0){
		printf("The data element of index equal to 6 in L is %d\n", i);
	}else{
		printf("There is no data element equal to 6 in L!\n");
	}
	
	//前驱
	temp = L.elem[2];
	if(PriorElem(L,temp, &e)){
		printf("The precursor of temp(L.elem[2]) is %d\n", e);
	}else{
		printf("No results fount!\n");
	}
	
	//后继
	temp = L.elem[3];
	if(NextElem(L, temp, &e)){
		printf("The next of temp(L.elem[3]) is %d\n", e);
	}else{
		printf("No results fount!\n");
	}
	
	//插入
	temp = 100;
	ListInsert(&L,2,temp);
	printf("Traversal results after inserting element:\n");
	ListTraverse(L); 
	printf("\n");
	
	//插入后查找L.elem[3]的后继
	temp = L.elem[3];
	if(NextElem(L, temp, &e)){
		printf("The next of temp(L.elem[3]) is %d\n", e);
	}else{
		printf("No results fount!\n");
	}
	
	//删除
	ListDelete(&L, 3, &e);
	printf("Traversal results after deleteing element:\n");
	ListTraverse(L);
	printf("\n");
	printf("The deleted element data is %d",e); 
	 
	return 0;
}

测试结果
在这里插入图片描述

Shu_Stars
关注
专栏目录
数据结构C语言实现线性表（顺序实现）的初始化与基本操作
hiliushuo的博客
05-07 3419
#include #include #define LIST_INIT_SIZE 10 /*存储空间初始分配量*/ #define LISTINCREMENT 10 /*存储空间分配增量*/ typedef struct sqlist{ int *elem; /*首地址*/ int length; /*当前长度*/ int listsize; /*存储容量*/ }sqlist; void init
线性表顺序存储（C语言实现）每行都有注释-----考研数据结构必备
07-15
总结来说，这个资源是针对考研数据结构学习者的，它提供了线性表顺序存储的C语言实现，通过每行的注释帮助学习者理解和掌握数据结构的基本概念、操作以及C语言编程技巧。通过实际编写和调试代码，不仅可以加深理论...
线性表 顺序存储 C语言实现
zhuzi_zhuzi_的博客
08-19 533
分公司归属感
线性表的顺序存储
阿牛哥的博客
03-17 496
线性表的顺序存储 你好！ 这是我第一次使用博客记录我学习的生活，废话不多说，在你基本了解C语言和或者对数组，指针，结构体有比较好的一个掌握的话，那么你学习第一章后，理解一下顺序表概念，就从阿牛理解的角度阐述和操作这个顺序表（静态）。 下面展示我的 相关代码片。 1、顺序表类型的定义 #include <stdio.h> #include <stdlib.h> #define SIZE 100 typedef int DataType; typedef struct { DataT
C语言线性表（实现线性表里面的函数）
qq_37805832的博客
05-13 1342
#include <stdio.h> #include <stdlib.h> #define KSIZE 10//定义常量:线性表的长度 #define FALSE 0 #define TRUE 1 /************************************************************************/ /* 线性表（linear list） 线性表是一个相当灵活的数据结构，它的长度可以根据需要增长和缩短，即对线性表的数据元素不仅可以进
线性表基本功能的c语言实现
gongdileidechouzhu的博客
02-23 4769
#include<stdio.h> #define false 0 #define ok 1 #define maxsize 10//定义了线性表的结构 typedef struct { int list1[maxsize]; int length; }sqlist;//初始化线性表 int initlist(sqlist *l) { l->length = 0; r
C语言线性表顺序存储结构实例详解
08-30
本资源为C语言线性表顺序存储结构实例详解，涵盖了顺序存储结构的定义、线性表的顺序存储结构的实现、顺序表的初始化操作、获取元素操作、插入操作和删除元素操作等方面，为学习C语言线性表顺序存储结构的朋友提供了...
线性表的顺序存储结构c语言实现
07-01
总结，这个C语言实现的线性表顺序存储结构提供了创建、销毁、插入、删除、访问、更新等基本操作，适用于教学和实际项目中对线性表的简单操作。理解并掌握这些操作的实现，有助于深入理解和应用数据结构，为更复杂的...
数据结构：线性表的顺序表示以及实现(C语言编写)
12-03
线性表是计算机科学中数据结构的基本类型之一，它由有限个相同类型元素构成的序列。在本资源中，我们关注的是线性表的顺序表示和...通过学习和实践这个实现，可以加深对C语言编程、数据结构以及线性表顺序表示的理解。
线性表顺序存储运算的算法实现
09-03
线性表是一种基础且...总结，线性表的顺序存储在C语言中的实现涉及数据结构的基本操作，这些操作的理解和实践对于掌握数据结构和算法至关重要。通过熟练运用这些知识，可以为更复杂的算法和数据结构打下坚实的基础。
数据结构复习<1> 线性表的顺序存储结构及其实现
郑皓云的博客
07-08 628
由于线性表的数据元素类型不确定，所以采用C++的模板机制。 在写模板时，由于长时间未写过C++了，对其模板机制的概念非常模糊，如以下代码存在基础语法错误或者丑陋的代码，请指出来，我将虚心改错，感谢。 顺序表——线性表的顺序存储结构 一、顺序表的定义 顺序表是用一段地址连续的存储单元依次存储线性表的数据元素。 二、顺序表的存储 通常用一维数组来实现顺序表，使用时要注意区分数组的下标与...
线性表的 顺序存储 结构
ZhY_Rening的博客
02-13 294
顺序存储结构
线性表的顺序存储方式的实现（C语言实现）
weixin_46272577的博客
11-30 806
线性表的顺序存储方式的实现 #include <stdio.h> #define OVERFLOW -1 #define MAX_SIZE 10 typedef struct List{ int data[MAX_SIZE]; int length; }SqList; //构造函数 void Init_List(SqList *L) { L->length = 0;//元素个数 } //插入函数 void Insert_List(SqList *L, int i, in.
顺序表的算法实现
m0_63932157的博客
09-10 186
顺序表的算法实现
c语言有定义好的线性表和函数,基于线性表的功能函数大全
weixin_34020067的博客
05-24 317
顺序表一：线性表的存储结构顺序表的顺序存储是指一组地址连续的存储单元依次存储线性表中的各个元素，使得线性表中在逻辑结构中相邻的元素存储在连续的物理存储单元中。采用顺序存储结构存储的线性表通常简称顺序表，可将顺序表归纳为：关系线性化，结点顺序存。 用C语言定义线性表的顺序存储表示#define MAXSIZE 100Typedef struct{ElemType elem[MAXSIZE];int ...
线性表的顺序存储格式基本操作：初始化、插入、删除、查找、打印
wangtiankuo的博客
03-13 3206
/* 线性表的基本操作 '&'表示C++中的引用。如果传入的变量是指针型变量，且在函数体内要对传入的指针进行改变，则将用到指针变量引用型 */ #include using namespace std; #define MaxSize 50 struct SqList{ int data[MaxSize];//顺序表的元素 int length;//顺序表的当前长度 }; boo
数据结构——线性顺序表的初始化，创建，打印
qq_40634072的博客
07-24 2430
线性顺序表的初始化，创建，打印。 数据结构 #include&lt;stdlib.h&gt; #include&lt;stdio.h&gt; #include&lt;malloc.h&gt; #define MAXNUM 100 #define OVERFLOW 0 typedef int elemtype; typedef struct Sqlist{ elemtype *ele...
数据结构的顺序线性表的一些函数
qq_41852344的博客
03-16 200
第一次发表博客，先发表一个数据结构里面的顺序线性表的一个CPP文件吧。#include&lt;stdio.h&gt;#include&lt;malloc.h&gt;#include&lt;stdlib.h&gt;#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW ...
线性表的顺序存储设计和实现 - API函数实现
yofer张耀琦的专栏
07-11 1204
基本概念 设计与实现 插入元素算法 判断线性表是否合法 判断插入位置是否合法 把最后一个元素到插入位置的元素后移一个位置 将新元素插入 线性表长度加1 获取元素操作 判断线性表是否合法 判断位置是否合法 直接通过数组下标的方式获取元素 删除元素算法 判断线性表是否合法 判断删除位置是否合法 将元素取出
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值