顺序表的实现

最新推荐文章于 2020-10-19 16:14:03 发布
最新推荐文章于 2020-10-19 16:14:03 发布
阅读量656 收藏 7
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43604517/article/details/103219280
版权

顺序表存储结构
在这里插入图片描述
结构体List用来管理动态分配的内存空间。
顺序表的初始分配空间大小为LIST_INIT_SIZE，当空间满时，再重新分配多增加LIST_INCREMENT的空间，listsize为当前最大的容量，length为使用的容量；基地址为base，相当于数组的名称。

#define LIST_INIT_SIZE 10	// 线性表存储空间的初始分配量
#define LIST_INCREMENT 2	// 线性表存储空间的分配增量

typedef int ElemType;	//顺序表元素类型

struct List {
	ElemType* base;		 // 存储空间基址
	int length;			 // 当前长度
	int listsize;	 // 当前分配的存储容量(以sizeof(ElemType)为单位)
};

注意：
动态分配的内存，数组是从下标是从0开始的，所以第i个数据元素是L.base[i-1]。

基本操作

1.初始化
在这里插入图片描述
分配初始大小的内存空间，base指向分配的内存空间基地址，长度为0，容量为LIST_INIT_SIZE。

void InitList(List& L) {
	L.base = (ElemType*)malloc(sizeof(ElemType) * LIST_INIT_SIZE);
	if (!L.base)	exit(-1);	// 存储分配失败
	L.length = 0; // 空表长度为0
	L.listsize = LIST_INIT_SIZE;// 初始存储容量
}

2.销毁
在这里插入图片描述
释放分配的存储空间，长度和容量都为0，基地址为空。

void DestroyList(List& L) {
	free(L.base);
	L.base = NULL;
	L.length = 0;
	L.listsize = 0;
}

3.清空
长度为0，不用释放空间。

void ClearList(List& L) {
	L.length = 0;
}

4.为空

bool ListEmpty(List L) {
	if (L.length == 0)
		return true;
	else
		return false;
}

5.长度

int ListLength(List L) {
	return L.length;
}

6.获取元素
第i个元素数组下标为i-1。

bool GetElem(List L, int i, ElemType& e) {
	if (i<1 || i>L.length)
		return false;
	e = L.base[i-1];	
	return true;
}

7.定位元素
compare()是数据元素判定函数(满足为1，否则为0)，返回L中第1个与e满足关系compare()的数据元素的位序。p指针为指向第i个元素。

int LocateElem(List L, ElemType e, bool (*compare)(ElemType, ElemType)) {
	ElemType* p=L.base;
	int i = 1;
	while (i <= L.length && !compare(*p++, e))
		++i;
	if (i <= L.length)
		return i;
	else
		return 0;
}

int LocateElem(List L, ElemType e,bool cmp(ElemType,ElemType)) {
	int i = 1;
	while (i <= L.length) {
		if ( cmp(e,L.base[i-1]) )
			return i;
		++i;
	}
	return 0;
}

8.前驱

前驱只能从第二个元素开始找，第一个元素没有前驱。

ElemType PriorElem(List L, ElemType cur_e, ElemType& pre_e)
{ 
	int i = 2;
	ElemType* p = L.base + 1;
	while (i <= L.length && *p != cur_e)
	{
		p++;
		i++;
	}
	if (i > L.length)
		return false; // 操作失败
	else
	{
		pre_e = *--p;
		return true;
	}
}

bool PriorElem(List L, ElemType cur_e, ElemType &pre_e) {
	int i = 2;
	while (i <= L.length) {
		if (cur_e == L.base[i-1]) {
			pre_e = L.base[i-2];
			return true;
		}
		++i;
	}
	return false;
}

9.后继

最后一个元素没有后继，找到倒数第二个元素。

ElemType NextElem(List L, ElemType cur_e, ElemType& next_e)
{ 
	int i = 1;
	ElemType* p = L.base;
	while (i < L.length && *p != cur_e)
	{
		i++;
		p++;
	}
	if (i == L.length)
		return false; // 操作失败
	else
	{
		next_e = *++p;
		return true;
	}
}

bool PriorElem(List L, ElemType cur_e, ElemType &pre_e) {
	int i = 2;
	while (i <= L.length) {
		if (cur_e == L.base[i-1]) {
			pre_e = L.base[i-2];
			return true;
		}
		++i;
	}
	return false;
}

10.插入

在第i个元素之前插入新的数据元素val，长度加一。注意插入位置i的范围，1<=i<=length+1，length+1是因为可以在最后一个元素之后插入，即在最后一个元素的下一个元素之前插入。空间满时，要增加内存分配。
在这里插入图片描述

bool ListInsert(List& L, int i, int val) {
	ElemType* newbase, * p, * q;
	if (i<1 || i>L.length+1)	return false;	// i值不合法
	if (L.length >= L.listsize) {	//当前存储空间已满，增加空间分配
		newbase = (ElemType*)realloc(L.base, L.listsize + LIST_INCREMENT);
		if (!newbase)	exit(-1);
		L.base = newbase;	//新基址
		L.listsize +=LIST_INCREMENT;	//增加存储容量
	}
	q=L.base+i-1;	//q为插入位置
	for (p=L.base+L.length-1; p >=q; --p) {	//插入位置及之后的位置右移
		*(p+1) = *p;
	}
	*q = val;	//插入
	++L.length;		//表长加一
	return true;
}

bool ListInsert(List& L, int i, ElemType e) {
	if (i<1 || i>L.length+1)	
		return false;
	if (L.length >= L.listsize) {	// 当前存储空间已满,增加分配
		ElemType* newbase = (ElemType*)realloc(L.base,sizeof(ElemType) * (L.listsize+LIST_INCREMENT));
		if (!newbase)	exit(-1);
		L.base = newbase;
		L.listsize += LIST_INCREMENT;
	}
	for (int j = L.length; j >= i; j--)	 // 插入位置及之后的元素右移
		L.base[j] = L.base[j-1];
	L.base[i-1] = e;	// 插入e
	++L.length;	// 表长增1
	return true;
}

11.删除

删除第i个位置的元素，并用返回其值val，长度减1。注意删除位置i的范围，1<=i<=length。第i个元素的下标为i-1。
在这里插入图片描述

bool ListDelete(List& L, int i, int& val) {
	if (i<1 || i>L.length)	return false;	// i值不合法
	val = L.base[i - 1];	//被删除元素的赋值
	for (int j = i; j < L.length; j++) {	//被删除元素之后的元素左移
		L.base[j-1] = L.base[j];
	}
	--L.length;		// 表长减1
	return true;
}

bool ListDelete(List& L, int i, ElemType& e) {
	if (i<1 || i>L.length)	 // i值不合法
		return false;
	e = L.base[i-1];	 // 被删除元素的值赋给e
	for (int j = i; j <= L.length; j++)	 // 被删除元素之后的元素左移
		L.base[j - 1] = L.base[j];
	--L.length;	 // 表长减1
	return true;
}

12.遍历

void ListTraverse(List L, void(*vi)(ElemType)) {
	int i = 1;
	while (i <= L.length) {
		vi(L.base[i - 1]);
		++i;
	}
	printf("\n");
}

测试函数

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
//判断相等，用于元素定位LocateElem
bool equal(ElemType c1, ElemType c2) {
	if (c1 == c2)
		return true;
	else
		return false;
}
//元素访问，用于元素遍历ListTraverse
void visit(ElemType e)
{
	printf("%d ", e);
}

int main() {
	List L;
	ElemType n;
	InitList(L);	//初始化
	printf("初始化L后：L.base=%u L.length=%d L.listsize=%d\n", L.base, L.length, L.listsize);
	for (int j = 1; j <= 5; j++)
		n = ListInsert(L, 1, j);	//插入
	printf("在L的表头依次插入1～5后：");
	ListTraverse(L, visit);
	printf("L.base=%u L.length=%d L.listsize=%d ", L.base, L.length, L.listsize);
	printf("L是否空：i=%d(1:是 0:否)\n", ListEmpty(L));
	ClearList(L);	//清空
	printf("清空L后：L.base=%u L.length=%d L.listsize=%d ", L.base, L.length, L.listsize);
	printf("L是否空：i=%d(1:是 0:否)\n", ListEmpty(L));
	for (int j = 1; j <= 10; j++)	//插入
		ListInsert(L, j, j);
	printf("在L的表尾依次插入1～10后：");
	ListTraverse(L, visit);
	printf("L.elem=%u L.length=%d L.listsize=%d\n", L.base, L.length, L.listsize);
	ListInsert(L, 1, 0);	//插入
	printf("在L的表头插入0后：");
	ListTraverse(L, visit);
	printf("L.elem=%u(有可能改变) L.length=%d(改变) L.listsize=%d(改变)\n", L.base, L.length, L.listsize);

	if (GetElem(L, 5, n))	//获取元素
		printf("第5个元素的值为%d\n", n);
	else
		printf("没有第5个元素\n");
	if (GetElem(L, 13, n))
		printf("第13个元素的值为%d\n", n);
	else
		printf("没有第13个元素\n");

	if (n = LocateElem(L, 8, equal))	//定位元素
		printf("元素8的位置为%d\n", n);
	else
		printf("没有值为8的元素\n");
	if (n = LocateElem(L, 11, equal))
		printf("元素11的位置为%d\n", n);
	else
		printf("没有值为11的元素\n");

	if (PriorElem(L, 10, n))	//前驱
		printf("元素10的前驱为%d\n", n);
	else
		printf("元素10无前驱\n");
	if (NextElem(L, 10, n))
		printf("元素10的后继为%d\n", n);
	else
		printf("元素10无后继\n");

	if (PriorElem(L, 0, n))		//后继
		printf("元素0的前驱为%d\n", n);
	else
		printf("元素0无前驱\n");
	if (NextElem(L, 0, n))
		printf("元素0的后继为%d\n", n);
	else
		printf("元素0无后继\n");

	ListTraverse(L, visit);
	printf("表长为%d\n", ListLength(L));
	if (ListDelete(L, 3, n))	//删除
		printf("删除第3个元素成功，其值为%d\n", n);
	else
		printf("删除第3个元素失败\n");
	ListTraverse(L, visit);
	DestroyList(L);	//销毁
	printf("销毁L后：L.elem=%u L.length=%d L.listsize=%d\n", L.base, L.length, L.listsize);

	return 0;
}

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

qq_1213701132
关注
  • 2
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【数据结构】—— 顺序表
mist的博客
07-03 1289
顺序表（Sequential List）是一种基本的数据结构，它通过一组连续的存储单元来存储具有相同类型的数据元素。
顺序表实现
最新发布
m0_73736626的博客
07-12 1216
顺序表是用来连续存放数据单元的一种结构，逻辑连续的两个元素在实际上也为连续的。
使用顺序表实现奇偶排序
09-25
【顺序表实现奇偶排序】 在给定的问题中，我们需要对一个整数顺序表进行特殊排序，即把所有的奇数移到偶数的前面。这里我们使用C++编程语言来实现这个算法。首先，顺序表是一种数据结构，它将元素存储在连续的内存...
顺序表实现的图书管理
06-19
定义图书类型结构，定义顺序表；完成功能：初始化构建空表、插入新记录到第i个位置、删除表中第i个记录、按图书名称进行查找、按作者进行查找、按价格区间进行查找。
顺序表测试1_WordforWord_用顺序表实现词频统计_
10-03
在本文中，我们将深入探讨如何使用C语言实现一个顺序表来统计单词的出现频率。顺序表是一种基础的数据结构，它将元素存储在一个连续的内存区域中，通过索引来访问元素，具有简单直观的操作方式。 首先，我们需要...
顺序表
weixin_45309293的博客
10-19 179
顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成据的增删查改。 顺序表一般可分为：静态顺序表（使用定长数组存储）；动态顺序表（使用动态开辟的数组存储）。 静态顺序表适用于确定知道需要存多少数据的场景. 静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用，相比之下动态顺序表更加灵活，根据需要动态分配内存大小。 动态顺序表的实现： public class MyArrayList { public int[] elem; publi
顺序表实现与操作
本资源提供了一个简单的顺序表（Sequence List）实现，用于演示数据结构的基本操作。 顺序表是一种线性数据结构，其中元素在内存中以连续的方式存储。这个实现中，顺序表由一个名为`Vector`的结构体表示，包含三个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值