顺序表（动态顺序表）

最新推荐文章于 2024-06-15 16:46:40 发布
最新推荐文章于 2024-06-15 16:46:40 发布
阅读量96 收藏
点赞数 3
分类专栏： 数据结构 文章标签： c++ c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huichaochao/article/details/128960041
版权

其实也不知道发啥，就发个前几天刚写好的循序表吧！话不多说，直接上代码

#pragma once
#include<stdio.h>
#include<stdlib.h>
typedef int list;
typedef struct sequential
{
	list* p;
	list size;    //数据的个数
	list capacity;//顺序表的容量
}sl;

void init(sl* a,list x);                 //初始化
void pushfront(sl* a, list x);           //头插
void popfront(sl* a);                    //头删
void pushback(sl* a, list x);            //尾插
void popback(sl* a);                     //尾删
void push(sl* a,  list location, list x);//任意位置插
void pop(sl* a, list location);          //任意位置删
void find(sl* a, list x);                //寻找一个数据
void expansion(sl* a);                   //扩容
void destory(sl* a);                     //释放空间
void print(sl* a);                       //打印
#define _CRT_SECURE_NO_WARNINGS 1
#include"Sequential_list.h"
//初始化
void init(sl* a,list x)
{
	a->capacity = 0;
	a->size = 0;
	a->p = NULL;
	list* tem = NULL;
	tem = (list*)realloc(a->p, sizeof(list) * x);
	if (tem == NULL)
	{
		printf("动态内存开辟失败\n");
		return;
	}
	else
	{
		a->p = tem;
		a->capacity = x;
		a->size = 0;
	}
}
//扩容
void expansion(sl* a)
{
	list* tem = NULL;
	if (a->size == a->capacity)
	{
		tem = (list*)realloc(a->p, ((a->capacity) * 2) * sizeof(list));
		if (tem == NULL)
		{
			printf("扩容失败\n");
			return;
		}
		else
		{
			a->p = tem;
			a->capacity = a->capacity * 2;
		}
	}
}
//释放空间
void destory(sl* a)
{
	free(a->p);
	a->p = NULL;
}
//打印
void print(sl* a)
{
	list i = 0;
	for (i = 0; i < a->size; i++)
	{
		printf("%d ", a->p[i]);
	}
}
//头插
//里面的beagin并不是第一个元素的意思，因为是头插，所以是最后一个元素的小标，起名beagin是因为这个接口函数的功能是头插
void pushfront(sl* a,list x)
{
	if (a->size == a->capacity)
	{
		//如果a->size与a->capacity相等，代表数据已满，要扩容
		//因为a是指针变量，a中存储的是结构体的地址，传给扩容函数后，相当于扩容函数存放的地址是结构体的地址
		expansion(a);
		list beagin = 0;
		if (a->size != 0)
		{
			for (beagin = a->size - 1; beagin >= 0; beagin--)
			{
				a->p[beagin + 1] = a->p[beagin];
			}
			beagin = 0;
			a->p[beagin] = x;
			a->size++;
		}
		else
		{
			beagin = 0;
			a->p[beagin] = x;
			a->size++;
		}
	}
	else if(a->size<a->capacity)
	{
		//严格来说还要判断是否越界，但是，因为数据个数比容量小，而且每次插入的个数是一个，所以就没有判断，而且上面还有数据与相等判断
		list beagin = a->size - 1;
		for (beagin = a->size - 1; beagin >= 0; beagin--)
		{
			a->p[beagin + 1] = a->p[beagin];
		}
		beagin = 0;
		a->p[beagin] = x;
		a->size++;
	}
	else
	{
		printf("程序出错\n");
		//exit(-1)表示程序异常，并且退出
		exit(-1);
	}
}
//尾插
void pushback(sl* a, list x)
{
	//判断一下顺序表中是否含有数据
	if (0 == a->size)
	{
		a->p[a->size] = x;
		a->size++;
	}
	else
	{
		//顺序表中含有数据，所以要判断空间够不够
		if (a->size < a->capacity)
		{
			list end = a->size;
			a->p[end] = x;
			a->size++;
		}
		else if (a->capacity == a->size)
		{
			//相等代表在插入数就不够用，所以要扩容
			expansion(a);
			list end = a->size;
			a->p[end] = x;
			a->size++;
		}
		else
		{
			printf("程序异常\n");
			exit(-1);
		}
	}
}
//头删
void popfront(sl* a)
{
	//先判断一下a->size是否为0
	if (0 == a->size)
	{
		printf("顺序表中没有数据\n");
		exit(-1);
	}
	else
	{
		//数据不是0，判断一下内存是否够用
		if (a->size < a->capacity)
		{
			list beagin = 1;
			for (beagin = 1; beagin < a->size; beagin++)
			{
				a->p[beagin - 1] = a->p[beagin];
			}
			a->size--;
		}
		else if(a->capacity == a->size)
		{
			expansion(a);
			list beagin = 1;
			for (beagin = 1; beagin < a->size; beagin++)
			{
				a->p[beagin - 1] = a->p[beagin];
			}
			a->size--;
		}
		else
		{
			printf("程序异常\n");
			exit(-1);
		}
	}
}
//尾删
void popback(sl* a)
{
	//判断顺序表中的数据是否为0
	if (a->size != 0)
	{
		a->size--;
	}
	else
	{
		printf("程序异常\n");
		exit(-1);
	}
}
//任意位置的插入
void push(sl* a, list location, list x)
{
	//因为是任意位置插入的数据，所以一定要先判断空间够不够用，切记，一定一定要先判断空间够不够用
	if (a->size < a->capacity)
	{
		//插入位置为0且数据个数是0，则相当于是头插入
		if (a->size == 0&&location == 0)
		{
			pushfront(a,x);
		}
		//插入位置不为0，且数据个数为0，这时因为顺序表的规则，只能在数据开始的第一个位置插入数据，但是插入位置不是0，所以异常
		else if (a->size == 0 && location != 0)
		{
			printf("输入位置异常\n");
			exit(-1);
		}
		//数据个数不为0，且插入位置是0，相当于是头插
		else if (a->size != 0 && location == 0)
		{
			pushfront(a, x);
		}
		//当两个都不为0时，就需要挪动数据，需要判断插入位置与数据的大小
		else if (a->size != 0 && location != 0)
		{
			if (location < a->size)
			{
				list end = a->size - 1;
				for (end = a->size - 1; end >= location - 1; end--)
				{
					a->p[end + 1] = a->p[end];
				}
				a->p[location - 1] = x;
				a->size++;
			}
			//此时相当于尾插
			else if (location == a->size)
			{
				pushback(a, x);
			}
			else
			{
				printf("输入位置异常\n");
				exit(-1);
			}
		}
	}
	//空间不够用，所以要扩容
	else if (a->capacity == a->size)
	{
		expansion(a);
	    if (a->size != 0 && location == 0)
		{
			pushfront(a, x);
		}
		//当两个都不为0时，就需要挪动数据，需要判断插入位置与数据的大小
		else if (a->size != 0 && location != 0)
		{
			if (location < a->size)
			{
				list end = a->size - 1;
				for (end = a->size - 1; end >= location - 1; end--)
				{
					a->p[end + 1] = a->p[end];
				}
				a->p[location - 1] = x;
				a->size++;
			}
			//此时相当于尾插
			else if (location == a->size)
			{
				pushback(a, x);
			}
			else
			{
				printf("输入位置异常\n");
				exit(-1);
			}
		}
	}
	else
	{
		printf("程序异常\n");
		exit(-1);
	}
}
//任意位置删除数据
void pop(sl* a, list location)
{
	//因为是删除数据，所以就不用考虑空间够不够用的问题，直接找到位置删除即可
	if (a->size != 0)
	{
		//此时相当于尾删
		if (location == a->size)
		{
			popback(a);
		}
		else if (location < a->size)
		{
			list beagin = location;
			for (beagin = location; beagin < a->size; beagin++)
			{
				a->p[beagin - 1] = a->p[beagin];
			}
			a->size--;
		}
		else
		{
			printf("删除数据异常\n");
			exit(-1);
		}
	}
	else
	{
		printf("数据个数为0，无法删除数据，程序异常\n");
		exit(-1);
	}
}
//寻找一个数据
void find(sl* a, list x)
{
	list count = 0;
	list i = 0;
	list flag = 0;
	if (a->size != 0)
	{
		for (i = 0; i < a->size; i++)
		{
			if (x == a->p[i])
			{
				flag = 1;
				printf("找到了，下标是%d  \n", i);
				count++;
			}
			else;
		}
		if (1 == flag)
		{
			printf("它的个数是%d \n", count);
		}
		else
		{
			printf("找不到\n");
		}
	}
	else
	{
		printf("程序异常\n");
		exit(-1);
	}
}
#define _CRT_SECURE_NO_WARNINGS 1
#include"Sequential_list.h"
void test()
{
	sl st;
	init(&st,4);
	expansion(&st);
	/*pushfront(&st, 1);
	pushfront(&st, 2);
	pushback(&st, 10);
	pushback(&st, 11);
	push(&st, 3, 3);
	push(&st, 4, 666);
	pop(&st, 1);
	popfront(&st);
	popback(&st);
	print(&st);
	find(&st, 666);*/

}
int main()
{
	test();
	return 0;
}

大家可以看到，我的三个文件依次是头文件，测试文件，最后汇总的文件，其实顺序表的思想很简单，就是我们所学的数组的原理，就是插入，删除的思想，思想还是和数组一样。不同点就是扩容的这里，我用的是realloc函数，因为这个函数我个人感觉比malloc函数好用。还有就是，我们一般扩容是扩两倍，避免扩大了浪费空间。然后就是我写这么多的原因就是我不管写那个接口函数，基本都判断了顺序表内没有数据的情况。在也没啥注意点说了。

最后，希望大家能支持一下吧！谢谢

超超同学
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
顺序表
Outtch_的博客
11-07 3548
顺序表是什么呢？ 顾名思义，顺序表是物理地址连续的存储单元依次存储数据的线性结构，一般情况下采用数组存储，在数组上完成数据的增删查改。 顺序表和数组有什么区别呢? 顺序表比数组更约束，顺序表物理地址上必须连续存储，数组是顺序表在实际编程中的具体实现方式。 顺序表分为静态顺序表和静态顺序表（主要区别在于他们的容量是否可变） 静态顺序表 静态顺序表的概念： 顺序表的容量在静态时期（编译期间）确定，大...
动态顺序表(C语言)
学代码的咸鱼的博客
03-28 2816
轻松带你搞定顺序表！
【数据结构】顺序表
加油！！！
10-30 2205
存储单元依次存储。
【数据结构】顺序表(实现+详解+源码+通讯录项目(静态+动态+文件保存))
热门推荐
Edward_Asia的博客
10-18 1万+
概念及结构 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 顺序表一般可以分为： 静态顺序表：使用定长数组储存元素。 动态顺序表：使用动态开辟的数组储存。 ...
＜数据结构＞ 顺序表
bit_zyx的博客
03-13 9277
目录 一、顺序表介绍 二、准备工作 1、创建顺序表 2、初始化顺序表 3、检测是否需要扩容 4、销毁顺序表 5、打印顺序表 三、四大功能 1、增加数据 头插 尾插 指定下标插入 2、删除数据 头删 ...
《Java数据结构入门》顺序表详解
日常学习记录、分享，愿我们都遇见更好的自己，与诸君共勉
04-25 5503
带你手把手自己模拟实现Java数据结构中的顺序表，很详细的哟😁
顺序表的动态存储细节
Bing's Blog
12-03 2073
顺序表的动态存储细节@(算法学习) 在顺序表的动态存储定义中需要包含的数据成员是（C） I. 数组指针 II. 表中元素个数n III. 表的大小maxSize IV. 数组基址base A. I 、II B. I 、II、IV C. I 、II、III D. 全部如果是在代码中写顺序表的动态存储方式，可能上手就知道要定义一个可动态增长的数组，通过malloc或者n
顺序表的动态分配
m0_51703122的博客
06-21 1755
顺序表的动态分配
数据结构-顺序表（动态分配存储空间）
快乐的小小程序猿
09-21 1万+
#include <stdio.h> #include <malloc.h> #include <stdlib.h> /** * 数组空间动态分配 */ #define InitSize 100 //动态分配存储空间时，不限制最大，只给定一个初始值 #define ListIncrement 10 //分配增量 typedef struct { int...
顺序表的动态存储
chenjunshuo的博客
01-24 1994
顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 顺序表一般分为： 1.静态顺序表：使用定长的数组存储； 2.动态顺序表：使用动态开辟的数组存储； 由于静态顺序表相对简单，我们便以动态顺序表为例来实现顺序表的相关接口； 首先是顺序表结构体的定义： 一般来说顺序表的结构体中主要包含：用于存储数据的数组，用于记录末尾数据下标（还能...
C语言实现动态顺序表的实现代码
12-31
C语言实现动态顺序表的实现代码 顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。线性表采用顺序存储的方式存储就称之为顺序表。顺序表是将表中的结点...
C++实现动态顺序表
12-17
本文实例为大家分享了C++实现动态顺序表的具体代码，供大家参考，具体内容如下 Vector.h #pragma once #include #include #include #include using namespace std; typedef int DataType; class Vector { ...
动态顺序表，纯手写无抄袭
03-10
有关于动态顺序表的头插尾插，头删尾删，任意位置嵌入，并且有着规避非法访问空间造成程序崩溃的语句，再加上结尾free掉动态开辟指针并且赋上空指针，给动态开辟内存空间后如何判断动态内存开辟是否成功，没有则返回...
【C++提高编程-05】----C++之Deque容器实战
最新发布
一伦明悦的博客
06-15 900
Deque（双端队列）是C++ STL中的一种序列容器
【C++】——Stack与Queue（含优先队列（详细解读）
m0_74092462的博客
06-09 1035
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
【C语言】一维数组（详解）
lrq13965748542的博客
06-11 1010
有了下标引用操作符，我们可以轻松访问到数组中的元素了，比如我们访问下标为7的元素，我们就可以使用 arr[7]，想要访问下标为3的元素，就使用 arr[3]。我们知道数组中所有元素的类型都是相同的，那只要计算出一个元素所占字节的个数，数组的元素个数就能计算出来。以后在代码中需要数组元素个数的地方就不用固定写死了，使用上面的计算，不管数组怎样变化，计算出的大小也就随着变化了。数组也是有类型的，数组算是一种自定义类型，去掉数组名留下的就是数组的类型。实现了数组的访问，现在我们也可以实现对数组中进行数据的输入。
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] CPU算力分配(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-11 396
### 问题描述 K小姐是某公司运营部门的主管,最近她需要对公司的两组服务器进行算力分配。每组服务器有多个算力不同的 $CPU$,其中 $A$ 组第 $i$ 个 $CPU$ 的运算能力为 $A[i]$,而 $B$ 组第 $i$ 个 $CPU$ 的运算能力为 $B[i]$。一组服务器的总算力是各 $CPU$ 的算力之和。 为了让两组服务器的算力相等,K小姐允许从每组各选出一个 $CPU$ 进行一次交换。她希望从 $A$ 组服务器中选出算力尽可能小的 $CPU$ 来交换,你能帮她计算出应该选择哪两个 $CP
一文理清sshc包的使用场景和掌握两种连接方式及异常场景
克克克克业业的学习记录
06-14 744
通过各种编程语言实现SSH客户端和服务端的功能不仅展示了SSH协议的灵活性和强大性，也为开发者提供了广泛的选择来满足不同的应用需求。Go语言的ssh包为开发人员提供了一个强大且灵活的工具，用于构建需要SSH交互的应用程序。SSHc包通常是指实现了SSH客户端功能的代码库或工具集。
STL——Stacks容器
qq_74811378的博客
06-11 304
top() 函数返回对栈顶元素的引用. 举例,如下代码显现和清空一个堆栈。所有的这些操作可以被用于堆栈. 相等指堆栈有相同的元素并有着相同的顺序。size() 函数返当前堆栈中的元素数目。如当前堆栈为空，empty() 函数 返回。值压栈，使其成为栈顶的第一个元素。pop() 函数移除堆栈中最顶层元素。push() 函数将。
C++动态分配顺序表
04-11
C++中可以使用动态分配的顺序表来实现动态数组，其中vector是C++标准库中提供的一个动态数组容器[^2]。下面是一个使用vector实现动态分配顺序表的示例代码： ```cpp #include #include int main() { std::...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值