动态顺序表 (C数组)

最新推荐文章于 2024-09-17 19:56:07 发布
最新推荐文章于 2024-09-17 19:56:07 发布
阅读量193 收藏
点赞数 2
分类专栏： C/C++小项目 文章标签： c++ c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lihua777/article/details/124457492
版权

SeqList.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

//#define N 200
//typedef int SLDataType;
//
 静态顺序表 -- N太小，可能不够用，N太大，可能浪费空间
//struct SeqList
//{
//	SLDataType a[N];
//	int size;
//};

typedef int SLDataType;

// 动态顺序表
typedef struct SeqList
{
	SLDataType* a; // 指向动态数组指针
	int size;      // 数据个数
	int capacity;  // 容量-空间大小
}SL;

void SLPrint(SL* ps);

// 增删查改
//void SeqListInit(SL s);
void SLInit(SL* ps);
void SLDestory(SL* ps);

void SLCheckCapacity(SL* ps);

// 头插/头删/尾插/尾插
// O(1)
void SLPushBack(SL* ps, SLDataType x);
void SLPopBack(SL* ps);

// O(N)
void SLPushFront(SL* ps, SLDataType x);
void SLPopFront(SL* ps);

// 任意位置插入删除
void SLInsert(SL* ps, int pos, SLDataType x);
void SLErase(SL* ps, int pos);

// 查找和修改
int SLFind(SL* ps, SLDataType x);
void SLModify(SL* ps, int pos, SLDataType x);

SeqList.c

#include "SeqList.h"

void SLPrint(SL* ps)
{
	assert(ps != NULL);
	//assert(ps);

	for (int i = 0; i < ps->size; ++i)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}

void SLInit(SL* ps)
{
	assert(ps != NULL);

	ps->a = NULL;
	ps->size = ps->capacity = 0;
}

void SLDestory(SL* ps)
{
	assert(ps != NULL);

	if (ps->a)
	{
		free(ps->a);
		ps->a = NULL;
		ps->capacity = ps->size = 0;
	}
}


void SLCheckCapacity(SL* ps)
{
	assert(ps != NULL);

	// 检查容量空间，满了扩容
	if (ps->size == ps->capacity)
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		SLDataType* tmp = (SLDataType*)realloc(ps->a, newCapacity*sizeof(SLDataType));
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			//exit(-1);
			return;
		}

		ps->a = tmp;
		ps->capacity = newCapacity;
	}
}

void SLPushBack(SL* ps, SLDataType x)
{
	/*assert(ps != NULL);

	SLCheckCapacity(ps);

	ps->a[ps->size] = x;
	ps->size++;*/

	SLInsert(ps, ps->size, x);
}

void SLPushFront(SL* ps, SLDataType x)
{
	//assert(ps != NULL);

	//SLCheckCapacity(ps);

	 挪动数据
	//int end = ps->size - 1;
	//while (end >= 0)
	//{
	//	ps->a[end + 1] = ps->a[end];
	//	--end;
	//}

	//ps->a[0] = x;
	//ps->size++;

	SLInsert(ps, 0, x);
}

void SLPopBack(SL* ps)
{
	//assert(ps != NULL);

	ps->a[ps->size - 1] = 0;
	 温柔检查
	///*if (ps->size == 0)
	//{
	//	printf("SeqList is empty\n");
	//	return;
	//}*/

	 暴力检查
	//assert(ps->size > 0);

	//ps->size--;

	SLErase(ps, ps->size - 1);
}

void SLPopFront(SL* ps)
{
	/*assert(ps != NULL);
	assert(ps->size > 0);

	int begin = 1;
	while (begin < ps->size)
	{
		ps->a[begin - 1] = ps->a[begin];
		++begin;
	}

	ps->size--;*/

	SLErase(ps, 0);
}

void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);

	SLCheckCapacity(ps);

	// 挪动数据
	int end = ps->size - 1;
	while (end >= pos)
	{
		ps->a[end + 1] = ps->a[end];
		--end;
	}

	ps->a[pos] = x;
	ps->size++;
}

void SLErase(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);

	//int begin = pos;
	//while (begin < ps->size-1)
	//{
	//	ps->a[begin] = ps->a[begin + 1];
	//	++begin;
	//}

	int begin = pos + 1;
	while (begin < ps->size)
	{
		ps->a[begin - 1] = ps->a[begin];
		++begin;
	}

	ps->size--;
}

int SLFind(SL* ps, SLDataType x)
{
	assert(ps);
	for (int i = 0; i < ps->size; ++i)
	{
		if (ps->a[i] == x)
			return i;
	}

	return -1;
}

void SLModify(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);

	ps->a[pos] = x;
}

test.c

#include "SeqList.h"

void TestSeqList1()
{
	SL sl;
	SLInit(&sl);
	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);
	SLPrint(&sl);

	SLPushBack(&sl, 5);
	SLPrint(&sl);

	SLPushBack(&sl, 5);
	SLPushBack(&sl, 5);
	SLPushBack(&sl, 5);
	SLPushBack(&sl, 5);
	SLPrint(&sl);
}

void TestSeqList2()
{
	SL sl;
	SLInit(&sl);
	SLPushFront(&sl, 1);
	SLPushFront(&sl, 2);
	SLPushFront(&sl, 3);
	SLPushFront(&sl, 4);
	SLPushFront(&sl, 5);
	SLPrint(&sl);

	SLPushBack(&sl, 5);
	SLPushBack(&sl, 5);
	SLPrint(&sl);
}

void TestSeqList3()
{
	SL sl;
	SLInit(&sl);
	SLPushFront(&sl, 1);
	SLPushFront(&sl, 2);
	SLPushFront(&sl, 3);
	SLPushFront(&sl, 4);
	SLPushFront(&sl, 5);
	SLPrint(&sl);

	SLPopBack(&sl);
	SLPopBack(&sl);
	SLPopBack(&sl);
	SLPopBack(&sl);
	SLPopBack(&sl);
	//SLPopBack(&sl);
	SLPrint(&sl);

	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPrint(&sl);

	SLDestory(&sl);
}

void TestSeqList4()
{
	SL sl;
	SLInit(&sl);
	//SL* psl = NULL;
	//SLInit(psl);
	SLPushFront(&sl, 1);
	SLPushFront(&sl, 2);
	SLPushFront(&sl, 3);
	SLPushFront(&sl, 4);
	SLPushFront(&sl, 5);
	SLPrint(&sl);

	SLPopFront(&sl);
	SLPrint(&sl);

	SLPopFront(&sl);
	SLPopFront(&sl);
	SLPopFront(&sl);
	SLPopFront(&sl);
	//SLPopFront(&sl);
	SLPrint(&sl);

	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPrint(&sl);

	SLDestory(&sl);
}

void TestSeqList5()
{
	SL sl;
	SLInit(&sl);
	SLPushFront(&sl, 1);
	SLPushFront(&sl, 2);
	SLPushFront(&sl, 3);
	SLPushFront(&sl, 4);
	SLPushFront(&sl, 5);
	SLPrint(&sl);

	SLInsert(&sl, 3, 40);
	SLPrint(&sl);
	SLInsert(&sl, 0, 40);
	SLPrint(&sl);

	SLPushBack(&sl, 1000);
	SLPrint(&sl);

	SLDestory(&sl);
}

void TestSeqList6()
{
	SL sl;
	SLInit(&sl);
	SLPushFront(&sl, 1);
	SLPushFront(&sl, 2);
	SLPushFront(&sl, 3);
	SLPushFront(&sl, 4);
	SLPushFront(&sl, 5);
	SLPrint(&sl);

	SLErase(&sl, 2);
	SLPrint(&sl);
	SLErase(&sl, 0);
	SLPrint(&sl);
	SLErase(&sl, 2);
	SLPrint(&sl);

	SLPopFront(&sl);
	SLPrint(&sl);
	SLPopBack(&sl);
	SLPrint(&sl);
}

void TestSeqList7()
{
	SL sl;
	SLInit(&sl);
	SLPushFront(&sl, 1);
	SLPushFront(&sl, 2);
	SLPushFront(&sl, 2);
	SLPushFront(&sl, 3);
	SLPushFront(&sl, 2);
	SLPushFront(&sl, 4);
	SLPushFront(&sl, 5);
	SLPrint(&sl);

	//int x = 0;
	//printf("请输入你要删除的值:");
	//scanf("%d", &x);
	//int pos = SLFind(&sl, x);
	//if (pos != -1)
	//{
	//	SLErase(&sl, pos);
	//}
	//else
	//{
	//	printf("没找到:%d\n", x);
	//}
	//SLPrint(&sl);

	int x = 0;
	printf("请输入你要删除的值:");
	scanf("%d", &x);
	int pos = SLFind(&sl, x);
	while (pos != -1)
	{
		SLErase(&sl, pos);

		pos = SLFind(&sl, x);
	}
	SLPrint(&sl);

	int y, z;
	printf("请输入你要修改的值和修改后的值:");
	scanf("%d%d", &y, &z);
	pos = SLFind(&sl, y);
	if (pos != -1)
	{
		SLModify(&sl, pos, z);
	}
	else
	{
		printf("没找到:%d\n", y);
	}
	SLPrint(&sl);
}

//int main()
//{
//	 TestSeqList7();
//
//	// 越界是不一定报错的
//	// 系统对越界的检查，设岗抽查。
//	//int a[10];
//	//a[0] = 0;
//	a[10] = 1;
//	a[11] = 1;
//	//a[12] = 1;
//	//a[15] = 1;
//
//	return 0;
//}

void menu()
{
	printf("****************************************\n");
	printf("1、尾插 2、头插\n");
	printf("5、查找 6、删除\n");
	printf("7、修改 8、打印\n");
	printf("-1、退出\n");
	printf("****************************************\n");
}

int main()
{
	SL sl;
	SLInit(&sl);

	int option = -1;
	do
	{
		menu();
		if (scanf("%d", &option) == EOF)
		{
			printf("scanf输入错误\n");
			break;
		}

		int val, pos;
		int y, z;
		switch (option)
		{
		case 1:
			printf("请连续输入你要尾插的数据，以0结束:>");
			scanf("%d", &val);
			while (val != 0)
			{
				SLPushBack(&sl, val);
				scanf("%d", &val);
			}
			break;
		case 2:
			break;
		case 3:
			break;
		case 4:
			break;
		case 5:
			break;
		case 6:
			break;
		case 7:
			printf("请输入你要修改的值和修改后的值:");
			scanf("%d%d", &y, &z);
			pos = SLFind(&sl, y);
			if (pos != -1)
			{
				SLModify(&sl, pos, z);
			}
			else
			{
				printf("没找到:%d\n", y);
			}
			break;
		case 8:
			SLPrint(&sl);
			break;
		default:
			printf("输入错误,请重新输入\n");
			break;
		}
	} while (option != -1);

	SLDestory(&sl);

	return 0;
}

lihua777
关注
专栏目录
顺序表与数组根本不是一码事！
数据结构和算法教程（C语言版）
12-26 1137
很多人认为顺序表就是数组，或者数组就是顺序表等等，这些理解都是错误的、片面的。
数据结构----使用c语言 实现数组(顺序表)的源码
小墨蛇的博客
05-29 246
学系数据解构中线性结构----顺序存储的数组。以下内容知识一个记录。
C语言利用动态数组实现顺序表（不限数据类型）
weixin_33800593的博客
01-08 305
实现任意数据类型的顺序表的初始化，插入，删除（按值删除；按位置删除），销毁功能。、 顺序表结构体 　　实现顺序表结构体的三个要素：（1）数组首地址；（2）数组的大小；（3）当前数组元素的个数。 1 //顺序表结构体 2 struct DynamicArray{ 3 void **addr; //指向数组的首地址（指向数组的指针） 4 int capacity; //...
c语言数组顺序表,数据结构之_动态数组 顺序表的实现
weixin_42149145的博客
05-24 214
数据结构之_动态数组 顺序表的实现1.基本概念线性表的顺序存储结构，指的是用一段地址连续的存储单元依次存储线性表的数据元素。线性表 (a1，a2，……，an)的顺序存储示意图如下：2.线性表顺序存储的设计与实现操作要点:插入元素算法判断线性表是否合法判断插入位置是否合法把最后一个元素到插入位置的元素后移一个位置将新元素插入线性表长度加1获取元素操作判断线性表是否合法判断位置是否合法直接通过数组下标...
【数据结构】C实现动态顺序表
耕田人的博客
05-14 319
什么是线性结构？ 线性结构： 线性结构是一个有序数据元素的集合。 其中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的。 常用的线性结构有：线性表，栈，队列，双队列，数组，串。 线性结构特点： 集合中必存在唯一的一个"第一个元素"； 集合中必存在唯一的一个"最后的元素"； 除最后元素之外，其它数据元素均有唯一的"...
动态顺序表(C语言)
学代码的咸鱼的博客
03-28 3051
轻松带你搞定顺序表！
顺序表——动态分配顺序表上的基本操作（初始化、遍历、插入、查找、删除、判空等）
薛定谔的猫的博客
04-15 4709
文章目录顺序表的定义顺序表上的操作初始化求表长遍历表动态分配插入操作查找操作按值查找按位查找删除操作判空操作销毁操作完整代码及实例 顺序表的定义  线性表的顺序存储又称顺序表。它是用一组地址连续的存储单元依次存储线性表中的数据元素，使得逻辑上相邻的两个元素在物理位置上也相邻。  顺序表的特点： 随机访问。通过首地址和元素序号可在时间O（1）内找到指定元素。 存储密度高。每个结点只存储数据元素。 逻辑上相邻的元素在物理上也相邻，故插入和删除操作需要移动大量元素。 顺序表上的操作  在顺序表上的操作主要有：
C语言实现动态顺序表的实现代码
12-31
C语言实现动态顺序表的实现代码 顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。线性表采用顺序存储的方式存储就称之为顺序表。顺序表是将表中的结点...
＜数据结构＞ （C语言实现） 动态顺序表
shinamashiro_的博客
04-11 2004
1.线性表 线性表是n个具有相同特性的数据元素的有限序列。 常见的线性表：顺序表、链表、栈、队列、字符串...... 线性表在逻辑上是线性结构，相当于连续的一条直线。但在物理结构上不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式进行存储。 2.顺序表 优点： 连续的物理空间，方便下标随机访问。 缺陷： 不能按需申请和删除空间 插入数据时，空间不够需要扩容，扩容有性能消耗(realloc空间不够时异地扩容，性...
使用C语言实现动态顺序表
Keep_Trying_Go的博客
08-06 569
使用C语言实现动态顺序表
顺序表的存储结构采用动态数组的方式实现（数据结构C语言版）
luo_si_yuan的博客
11-05 1571
①顺序表的动态数组实现 首先先要创建一个顺序表给它分配预先定义好的“#define LIST_INIT_SIZE 100”空间长度并且将内容置为空。 ②输入输出数据，这部分功能的实现就要用到 前面结构中定义的“ElemType *elem”指针 来实现动态数组的遍历 输入或输出 输入：scanf("%d",L.elem+i);注意：要确定输入长度 输出：printf("%d\n",*(L.el...
数据结构C语言——动态顺序表的实现
m0_59086544的博客
06-17 862
本篇文章主要介绍的是数据结构中使用C语言来实现动态顺序表的一些基本操作。
【数据结构】之 动态顺序表（C语言）（含完整代码）
weixin_53936115的博客
12-18 1211
顺序表概念： 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构。一般情况下用数组存储。在数组上完成数据的增删查改。 代码解析： 1.准备工作 1.首先对一些头文件的引用和创建一个结构体，结构体包含一个数组，size表示该数组目前有多少个元素，capacity表示目前数组能存多少个元素。例如： #include<stdio.h> #include<stdlib.h> #include<malloc.h> #include&l...
线性表之顺序存储结构（C语言动态数组实现）
weixin_30682415的博客
05-16 423
线性表的定义：N个数据元素的有限序列 线性表从存储结构上分为：顺序存储结构（数组）和 链式存储结构（链表） 顺序存储结构：是用一段连续的内存空间存储表中的数据L=(a1,a2,a3....an) 链式存储结构：是用一段一段连续的内存空间存储表中每一行的数据，段与段之间通过一个引用（指针）相互连接来，形成一个链式的存储结构 看到顺序存储结构的图示，我们可能会马上联想到C语...
C++ STL中sort函数
weixin_43349440的博客
09-15 410
刷题中经常遇到，用于各种元素排序，可以自定义排序方式，vector、deque适用。详细讲解：https://zhuanlan.zhihu.com/p/36274119。，为避免QuickSort快排的递归调用带来过大的额外负荷，就改用。一旦分段后的数据量小于某个门槛。STL的sort算法，
【C++】 —— string的使用
LH__1314的博客
09-16 1429
string类虽然不在STL的容器中，但string类十分重要，string类是对字符串的存储和相关操作。
CF C. Nikita and LCM
qq_74190237的博客
09-13 333
思维题.首先先对数组排序,考虑一种特殊情况,那就是如果数组最大值不能被其他数整除,这代表什么?代表其他数里面有某个质因子,最大值里面没有或者数量不管,所有最小公倍数都会大于最大值.那么其他情况的话,就可以确定所有的数都是最大数的因子,那么形成的最小公倍数也一定是最大数的因子,那么就可以枚举一下最大数的因子,就可以了.给长度为n的数组,求出最长的特殊子数组,如果子数组的最小公倍数不在原数组中,那么就是特殊的.
斗破C++编程入门系列之三十一：继承与派生：派生类对基类成员的访问控制之保护继承与私有继承（一星斗师）
最新发布
南北粉面馆
09-17 965
正当萧炎准备用青莲台收取青莲地心火之时，一只可爱的小动物突然出现，原来她是美杜莎女王的伴生灵魂–紫幽炎蛇，是只六阶魔兽，没想到这所谓的进化，便是进化灵魂，用灵魂之力凝聚成真正的身体，若机缘足够，激发体内的远古巨兽血脉，就能进化为堪比斗宗强者的七彩吞天蟒。美杜莎女王的行为引发了天地异像，为了族人的未来，她义无反顾的与异火进行着最后的抗争，然而在灵魂体与天雷触碰的一瞬间，她还是失败了，与天雷一并化做漫天的鳞羽。斗气有十一个阶别，斗之气，斗者，斗师，大斗师，斗灵，斗王，斗皇，斗宗，斗尊，斗圣，斗帝。
顺序表的数组与链表实现
在C语言中，数组形式的顺序表通常通过定义一个结构体来实现。例如，`SqList` 结构体包含了数组 `elem` 用于存储元素，以及一个整型变量 `length` 用来记录表的长度。数组 `elem` 的大小被定义为 `MAXSIZE`，即最大...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值