【数据结构】顺序表

已于 2022-11-07 21:18:50 修改
阅读量574 收藏 9
点赞数 10
文章标签： 数据结构 链表
于 2022-07-28 15:23:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kdjjdjdjjejje128/article/details/126032444
版权

到目前为止我们C语言的学习告一段落了，算是勉强入门吧。😃 😃 😃 接下来我们会用c语言实现一些初阶数据结构，这个过程代码量很大，大家要自己多动手敲一下。

文章目录

前言

什么是线性表？

线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…
线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

例如下图所示：
在这里插入图片描述

顺序表和链表都属于线性表，本章主要讲解顺序表。
注：顺序表和链表可能每本书或者每个人的代码都有所差异，但是我们所要达到的目的都是一样的。

一、顺序表

顺序表的概念与结构

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改（主要操作是增删查改，也还有许多其他操作）。

可以把顺序表看作一个数组。

顺序表一般可以分为两种：
1. 静态顺序表：使用定长数组存储元素。
. 在这里插入图片描述
2. 动态顺序表：使用动态开辟的数组存储。
在这里插入图片描述
这里我们主要来讲讲动态顺序表，因为静态顺序表的空间大小是固定的，使用不方便，这也导致我们以后工作之类的时候一般不用静态的顺序表用的是动态的顺序表。

二、动态顺序表的实现

动态顺序表的实现一般使用3个文件来完成，一个Seqlist.h头文件，一个Seqlist.c的源文件，一个test.c的源文件

1、Seqlist.h头文件

这里面一般用来放着函数的声明，一些全局变量或者其他变量的声明或者重命名

#pragma once//防止头文件被重复包含
#include<stdio.h>
#include<assert.h>//断言头文件
#include<stdlib.h>//动态内存开辟等操作头文件

下面的结构体之类的重命名是为了方便识别和使用，大家可以重命名为自己想要的名字

typedef int SLDataType;
//这里我们将int重命名为SLDataType，因为我们可能操作的数据是字符或者是浮点数
//所以将int重命名，如果是操作其他数据直接修改这里的int就行


typedef struct Seqlist
{
	SLDataType* a;//指针
	SLDataType size;//有效数据个数
	SLDataType count;//容量
}SL;//将struct Seqlist重命名为SL,这样更加方便使用


以下是接口函数：
void SLInit(SL* ps);//初始化数据
void SLPrint(SL* ps);//打印数据
void SLDelete(SL* ps);//释放/销毁
void SLPushback(SL* ps, SLDataType x);//尾插数据
void SLPushfront(SL* ps,SLDataType);//头插数据
void SLPopback(SL* ps);//尾删数据
void SLPopfront(SL* ps);//头删数据
int SLFind(SL* ps, SLDataType x);//查找数据
void SLInsert(SL* ps, SLDataType pos, SLDataType x);//任意位置插入数据
void SLErase(SL* ps, SLDataType pos);//任意位置删除数据
void SLModity(SL* ps, SLDataType pos, SLDataType x);//修改数据

接下来就是实现也就是定义的实现了，注意我们这里最后实现test.c文件，因为主函数在这个文件里面，包括菜单实现，接口的调用等等。如果提前写菜单会把自己累死，特别是调试的时候，头铁的读者可以试试哦！

2、Seqlist.c源文件

这个文件里面放的都是函数的定义了，我不会按照每一个接口调用的顺序来实现，而是先实现之后再调用接口
这里在test.c里面有一个变量：

SL s;

大家要注意

小前言

我们尽量在每个函数里面都开始断言一下，这样防止传参的指针是空指针，容易发现错误
然后小编是之前经过测试了的，这里test.c小编会把测试代码和菜单都给大家，就不重新在测试一遍了

1、包含头文件

这一点必不可少

#include"Seqlist.h"

2、初始化数据

void SLInit(SL* ps)//初始化
{
	assert(ps);
	ps->a = NULL;//先将指针初始化为空
	ps->size = ps->count = 0;//有效数据个数和容量初始化为0
	//这里可以进行连等
}

3、打印数据

void SLPrint(SL* ps)//打印
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)//i小于ps->size也就是目前的有效数据个数
	{
		printf("%d->", ps->a[i]);//这里每打印一个数据后面加一个箭头更像顺序表
		//ps->a[i]就是找到指针a，对指针a加i的地址解引用，得到下标为i的数据进行打印
	}
	printf("NULL\n");//这里打印完所有数据后再打印一个NULL然后换行
}

4、释放/销毁

void SLDelete(SL* ps)//释放/销毁
{
	assert(ps);
	free(ps->a);//动态内存释放
	ps->a = NULL;//指针置空
	ps->size = ps->count = 0;//有效数据个数和容量置0
}

接下来就是增删查改等操作了，在删除的时候我们不用考虑空间的大小，但是在插入数据的时候要考虑空间够不够，不够就要进行扩容

5、扩容

void SLChack(SL* ps)//扩容
{//下面插入数据操作进行之前先调用扩容函数判断需不需要扩容
	if (ps->size == ps->count)//如果有效数据个数等于容量就扩容
	{//这里的SLDataType就是我们之前重命名的int
		SLDataType newcount = ps->count == 0 ? 4 : ps->count * 2;
		//这里的newcount可以理解为新的容量。
		//这段代码的意思是：ps->count也就是旧的容量是不是0，如果是就让旧容量的空间开辟4个整型空间，然后赋值给新容量
		//如果旧容量不是0，而且需要扩容就扩容两倍然后赋值给新容量
		SLDataType* p = (SLDataType*)realloc(ps->a, sizeof(SLDataType) * newcount);
		//这里就是动态内存扩容的操作，扩容的空间大小就是新容量的空间大小
		if (p == NULL)
		{
			perror("realloc fail");
			return;
		}
		else
		{
			ps->a = p;//扩容成功后将扩容的地址赋值给原来的指针，由原来指针进行维护
			ps->count = newcount;//再将新容量赋值给旧容量。至此扩容完成
		}
	}
}

很多人都不清楚这里据扩容为什么扩2倍，因为扩2倍最合适。
如果扩容少了要多次扩容，如果扩容多了就会造成大量浪费；
如果扩容1.5倍这种小数倍的话很麻烦：
因为如果原数据只有3个怎么扩1.5倍，或许等我们以后学了c++会轻而易举，但是如果进行跨平台操作呢？
是不是会得到不一样的结果，所以扩2倍是合适的

6、尾插数据

void SLPushback(SL* ps, SLDataType x)//尾插
{
	assert(ps);
	SLChack(ps);//判断是否需要扩容
	ps->a[ps->size] = x;
	//将x数据插入ps->size的位置即可，因为原来有效数据是ps->size个，但是下标最大是ps->size-1
	//将x插入到下标ps->size就是相当于在最后插入了数据
	ps->size++;//这里有效数据个数加1
}

7、头插数据

void SLPushfront(SL* ps,SLDataType x)//头插
{
	assert(ps);
	SLchack(ps);//判断扩容
	SLdatatype end = ps->size - 1;//end就是最后一个有效数据的下标
	while (end >= 0)//如果下标大于等于0
	{
		ps->a[end + 1] = ps->a[end];将下标0到下标ps->size-1的元素全部右移，也就是从后向前移动
		--end;
	}
	ps->a[0] = x;//将下标为0的地址插入x数据
	ps->size++;
}

8、尾删数据

void SLPopback(SL* ps)//尾删
{
	assert(ps && ps->size > 0);//断言一下，如果有效数据个数大于0就可以进行删除
	if (ps->size == 0)
	{
		exit(-1);//这种是暴力判断，如果有效数据个数为0，直接终止整个程序
	}
	ps->size--;//尾删直接把有效数据个数减一就行
}

9、头删数据

void SLPopfront(SL* ps)//头删
{
	assert(ps);
	assert(ps->size > 0);//与上面一样
	SLDataType end = 0;//end是下标，从0开始
	while (end < ps->size - 1)
	{
		ps->a[end] = ps->a[end + 1];//将下标为1的有效数据到最后一个有效数据全部左移，也就是从前向后移动
		++end;
	}
	ps->size--;//容量减一
}

10、任意位置插入数据

void SLInsert(SL* ps, size_t pos, SLDataType x)//任意位置插入
//pos是下标，x是插入数据
{//size_t pos;下标不会是负数
	assert(ps && pos <= ps->size);//pos=ps->size就是尾插,无影响
	SLChack(ps);
	size_t end = ps->size;//这里end与pos类型对应，无符号整型
	while (end > pos)
	{//如果end下标大于pos下标，那么就将pos到end中间的数据全部右移
		ps->a[end] = ps->a[end - 1];
		--end;
	}
	ps->a[pos] = x;//插入x
	ps->size++;
}

11、任意位置删除数据

void SLErase(SL* ps, SLDataType pos)//任意位置删除
{
	assert(ps && pos < ps->size);//同上断言
	SLDataType end = pos;//end下标被赋值为pos
	while (end < ps->size - 1)//如果不是删除最后一个有效数据
	{
		ps->a[end] = ps->a[end + 1];//把删除数据右边的数据全部左移
		++end;
	}
	ps->size--;
}

12、查找数据

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;
}

查找数据是有返回值的，如果成功则返回下标，如果失败返回-1；查找没有更好的方法，因为我们不知道数据是不是有序的，不能使用二分，快排这个时候又比较慢，使用直接循环遍历即可

13、修改数据

这个就太简单了

void SLModity(SL* ps, SLDataType pos, SLDataType x)//修改
{
	assert(ps && pos < ps->size);//同上
	ps->a[pos] = x;//直接把下标对应值修改即可
}

到目前为止我们的函数定义已经全部完成了，接下来就是test.c文件了

3、test.c源文件

这个文件有两大部分，一部分是测试用例，一部分就是调用和菜单

1、测试用例

这里小编偷懒了，直接把测试用例全部放在一起了，读者可以放开多个函数测试

void TestSL1()
{
	SL s;
	SLInit(&s);//初始化
	SLPushback(&s, 1);//尾插
	SLPushback(&s, 2);
	SLPushback(&s, 3);
	SLPushback(&s, 4);
	SLPushback(&s, 5);
	SLPushback(&s, 6);
	SLPrint(&s);//打印

	SLPushfront(&s, 10);//头插
	SLPushfront(&s, 20);
	SLPushfront(&s, 30);
	SLPushfront(&s, 40);
	SLPrint(&s);

	SLPopback(&s);//尾删
	SLPopback(&s);
	SLPopback(&s);
	SLPrint(&s);

	SLPopfront(&s);//头删
	SLPopfront(&s);
	SLPopfront(&s);
	SLPrint(&s);

	SLInsert(&s, 1, 10);//任意位置插入
	SLPrint(&s);

	SLErase(&s, 3);//任意位置删除
	SLPrint(&s);

	SLModity(&s, 3, 30);//任意位置修改
	SLPrint(&s);

	SLDelete(&s);
}

2、菜单和调用

void menu()
{
	printf("-------------------------------\n");
	printf("***0、退出程序   5、打印数据***\n");
	printf("***1、尾插数据   2、头插数据***\n");
	printf("***3、尾删数据   4、头删数据***\n");
	printf("***6、任意插入   7、任意删除***\n");
	printf("***8、查找数据   9、修改数据***\n");
	printf("-------------------------------\n");
}//大家也可以用枚举的方法来，我这里没有用枚举
int main()
{
	SL s;
	SLInit(&s);//初始化
	int n = 0;
	do
	{
		menu();
		printf("请选择操作：");
		int x = 0;
		int y = 0;
		scanf("%d", &n);
		switch (n)
		{
		case 1:
			printf("请输入尾插数据，以-1截止\n");
			do
			{
				scanf("%d", &x);
				if (x != -1)
				{
					SLPushback(&s, x);
				}
			} while (x != -1);
			break;
		case 2:
			printf("请输入头插数据，以-1截止\n");
			do
			{
				scanf("%d", &x);
				if (x != -1)
				{
					SLPushfront(&s, x);
				}
			} while (x != -1);
			break;
		case 3:
			SLPopback(&s);
			break;
		case 4:
			SLPopfront(&s);
			break;
		case 5:
			SLPrint(&s);
			break;
		case 6:
			printf("请输入插入下标和插入数据\n");
			scanf("%d %d", &x, &y);
			SLInsert(&s, x, y);
			break;
		case 7:
			printf("请输入删除数据下标\n");
			scanf("%d", &x);
			SLErase(&s, 3);
			break;
		case 8:
			printf("请输入查找数据下标\n");
			scanf("%d", &x);
			SLFind(&s, x);
			printf("x下标数据为:%d\n", s.a[x]);
			break;
		case 9:
			printf("请输入修改下标和修改数据\n");
			scanf("%d %d", &x, &y);
			SLModity(&s, x, y);
			break;
		case 0:
			SLDelete(&s);//这里是释放/销毁函数
			printf("退出程序\n");
			break;
		default:
			printf("输入错误，请重新输入:");
		}
	} while (n);
	return 0;
}

也行有的读者已经想到了，既然有任意位置插入删除数据，那么直接给一个首元素下标和最后一个元素下标调用对应函数不就可以了，的确可以，如下图：

void SLPushback(SL* ps, SLDataType x)//尾插
{
	/*assert(ps);
	SLChack(ps);//判断是否需要扩容
	ps->a[ps->size] = x;
	//将x数据插入ps->size的位置即可，因为原来有效数据是ps->size个，但是下标最大是ps->size-1
	//将x插入到下标ps->size就是相当于在最后插入了数据
	ps->size++;*/
	SLInsert(ps, ps->size, x);
}


void SLPushfront(SL* ps,SLDataType x)//头插
{
	/*assert(ps);
	SLchack(ps);
	SLdatatype end = ps->size - 1;//end就是最后一个有效数据的下标
	while (end >= 0)
	{
		ps->a[end + 1] = ps->a[end];
		//将下标0到下标ps->size-1的元素全部右移，也就是从后向前移动
		--end;
	}
	ps->a[0] = x;//将下标为0的地址插入x数据
	ps->size++;*/
	SLInsert(ps, 0, x);
}


void SLPopback(SL* ps)//尾删
{
	/*assert(ps && ps->size > 0);//断言一下，如果有效数据个数大于0就可以进行删除
	if (ps->size == 0)
	{
		exit(-1);//这种是暴力判断，如果有效数据个数为0，直接终止整个程序
	}
	ps->size--;//尾删直接把有效数据个数减一就行*/
	SLErase(ps, ps->size - 1);
}


void SLPopfront(SL* ps)//头删
{
	/*assert(ps);
	assert(ps->size > 0);
	SLDataType end = 0;
	while (end < ps->size - 1)
	{
		ps->a[end] = ps->a[end + 1];
		//将下标为1的有效数据到最后一个有效数据全部左移，也就是从前向后移动
		++end;
	}
	ps->size--;*/
	SLErase(ps, 0);
}

这样确实可行，但是这样调用效率会有所下降，为了还是有很多地方直接头删头插、尾删尾插的，所以大家都掌握比较好

还有一个玩法，在我们查找数据的时候对这个数据进行修改或者插入删除操作

int x = 0;
scanf("%d", &x);//输入一个值
int pos = SLFind(&s, x);//查找返回值的下标
if (pos != -1)//如果不等于-1表示找到对应的下标了
{
	SL....(&s, pos);//各种函数的调用
}
SLPrint(&s);//打印

玩法其实还是有一些的。

三、全部代码

1、Seqlist.h

#pragma once//防止头文件被重复包含
#include<stdio.h>
#include<assert.h>//断言头文件
#include<stdlib.h>//动态内存开辟等操作头文件

下面的结构体之类的重命名是为了方便识别和使用，大家可以重命名为自己想要的名字

typedef int SLDataType;
//这里我们将int重命名为SLDataType，因为我们可能操作的数据是字符或者是浮点数
//所以将int重命名，如果是操作其他数据直接修改这里的int就行


typedef struct Seqlist
{
	SLDataType* a;//指针
	SLDataType size;//有效数据个数
	SLDataType count;//容量
}SL;//将struct Seqlist重命名为SL,这样更加方便使用


以下是接口函数：
void SLInit(SL* ps);//初始化数据
void SLPrint(SL* ps);//打印数据
void SLDelete(SL* ps);//释放/销毁
void SLPushback(SL* ps, SLDataType x);//尾插数据
void SLPushfront(SL* ps,SLDataType);//头插数据
void SLPopback(SL* ps);//尾删数据
void SLPopfront(SL* ps);//头删数据
int SLFind(SL* ps, SLDataType x);//查找数据
void SLInsert(SL* ps, SLDataType pos, SLDataType x);//任意位置插入数据
void SLErase(SL* ps, SLDataType pos);//任意位置删除数据
void SLModity(SL* ps, SLDataType pos, SLDataType x);//修改数据

2、Seqlist.c

#define _CRT_SECURE_NO_WARNINGS
#include"Seqlist.h"
void SLInit(SL* ps)//初始化
{
	assert(ps);
	ps->a = NULL;//先将指针初始化为空
	ps->size = ps->count = 0;//有效数据个数和容量初始化为0
	//这里可以进行连等
}


void SLPrint(SL* ps)//打印
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)//i小于ps->size也就是目前的有效数据个数
	{
		printf("%d->", ps->a[i]);//这里每打印一个数据后面加一个箭头更像顺序表
		//ps->a[i]就是找到指针a，对指针a加i的地址解引用，得到下标为i的数据进行打印
	}
	printf("NULL\n");//这里打印完所有数据后再打印一个NULL然后换行
}


void SLDelete(SL* ps)//释放/销毁
{
	assert(ps);
	free(ps->a);//动态内存释放
	ps->a = NULL;//指针置空
	ps->size = ps->count = 0;//有效数据个数和容量置0
}


void SLChack(SL* ps)//扩容
{//下面插入数据操作进行之前先调用扩容函数判断需不需要扩容
	if (ps->size == ps->count)//如果有效数据个数等于容量就扩容
	{//这里的SLDataType就是我们之前重命名的int
		SLDataType newcount = ps->count == 0 ? 4 : ps->count * 2;
		//这里的newcount可以理解为新的容量。
		//这段代码的意思是：ps->count也就是旧的容量是不是0，如果是就让旧容量的空间开辟4个整型空间，然后赋值给新容量
		//如果旧容量不是0，而且需要扩容就扩容两倍然后赋值给新容量
		SLDataType* p = (SLDataType*)realloc(ps->a, sizeof(SLDataType) * newcount);
		//这里就是动态内存扩容的操作，扩容的空间大小就是新容量的空间大小
		if (p == NULL)
		{
			perror("realloc fail");
			return;
		}
		else
		{
			ps->a = p;//扩容成功后将扩容的地址赋值给原来的指针，由原来指针进行维护
			ps->count = newcount;//再将新容量赋值给旧容量。至此扩容完成
		}
	}
}


void SLPushback(SL* ps, SLDataType x)//尾插
{
	/*assert(ps);
	SLChack(ps);//判断是否需要扩容
	ps->a[ps->size] = x;
	//将x数据插入ps->size的位置即可，因为原来有效数据是ps->size个，但是下标最大是ps->size-1
	//将x插入到下标ps->size就是相当于在最后插入了数据
	ps->size++;*/
	SLInsert(ps, ps->size, x);
}


void SLPushfront(SL* ps,SLDataType x)//头插
{
	/*assert(ps);
	SLchack(ps);
	SLdatatype end = ps->size - 1;//end就是最后一个有效数据的下标
	while (end >= 0)
	{
		ps->a[end + 1] = ps->a[end];
		//将下标0到下标ps->size-1的元素全部右移，也就是从后向前移动
		--end;
	}
	ps->a[0] = x;//将下标为0的地址插入x数据
	ps->size++;*/
	SLInsert(ps, 0, x);
}


void SLPopback(SL* ps)//尾删
{
	/*assert(ps && ps->size > 0);//断言一下，如果有效数据个数大于0就可以进行删除
	if (ps->size == 0)
	{
		exit(-1);//这种是暴力判断，如果有效数据个数为0，直接终止整个程序
	}
	ps->size--;//尾删直接把有效数据个数减一就行*/
	SLErase(ps, ps->size - 1);
}


void SLPopfront(SL* ps)//头删
{
	/*assert(ps);
	assert(ps->size > 0);
	SLDataType end = 0;
	while (end < ps->size - 1)
	{
		ps->a[end] = ps->a[end + 1];
		//将下标为1的有效数据到最后一个有效数据全部左移，也就是从前向后移动
		++end;
	}
	ps->size--;*/
	SLErase(ps, 0);
}


void SLInsert(SL* ps, size_t pos, SLDataType x)//任意位置插入
//pos是下标，x是插入数据
{//size_t pos;下标不会是负数
	assert(ps && pos <= ps->size);//pos=ps->size就是尾插,无影响
	SLChack(ps);
	size_t end = ps->size;//这里end与pos类型对应，无符号整型
	while (end > pos)
	{
		ps->a[end] = ps->a[end - 1];
		//如果end下标大于pos下标，那么就将pos到end中间的数据全部右移
		--end;
	}
	ps->a[pos] = x;//插入x
	ps->size++;
}


void SLErase(SL* ps, SLDataType pos)//任意位置删除
{
	assert(ps && pos < ps->size);
	SLDataType end = pos;
	while (end < ps->size - 1)//如果不是删除最后一个有效数据
	{
		ps->a[end] = ps->a[end + 1];//把删除数据右边的数据全部左移
		++end;
	}
	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 SLModity(SL* ps, SLDataType pos, SLDataType x)//修改
{
	assert(ps && pos < ps->size);
	ps->a[pos] = x;//直接把下标对应值修改即可
}

3、test.c

#define _CRT_SECURE_NO_WARNINGS
#include"Seqlist.h"
void TestSL1()
{
	SL s;
	SLInit(&s);//初始化
	SLPushback(&s, 1);//尾插
	SLPushback(&s, 2);
	SLPushback(&s, 3);
	SLPushback(&s, 4);
	SLPushback(&s, 5);
	SLPushback(&s, 6);
	SLPrint(&s);//打印

	SLPushfront(&s, 10);//头插
	SLPushfront(&s, 20);
	SLPushfront(&s, 30);
	SLPushfront(&s, 40);
	SLPrint(&s);

	SLPopback(&s);//尾删
	SLPopback(&s);
	SLPopback(&s);
	SLPrint(&s);

	SLPopfront(&s);//头删
	SLPopfront(&s);
	SLPopfront(&s);
	SLPrint(&s);

	SLInsert(&s, 1, 10);//任意位置插入
	SLPrint(&s);

	SLErase(&s, 3);//任意位置删除
	SLPrint(&s);

	SLModity(&s, 3, 30);//任意位置修改
	SLPrint(&s);

	SLDelete(&s);
}
void menu()
{
	printf("-------------------------------\n");
	printf("***0、退出程序   5、打印数据***\n");
	printf("***1、尾插数据   2、头插数据***\n");
	printf("***3、尾删数据   4、头删数据***\n");
	printf("***6、任意插入   7、任意删除***\n");
	printf("***8、查找数据   9、修改数据***\n");
	printf("-------------------------------\n");
}//大家也可以用枚举的方法来，我这里没有用枚举
int main()
{
	SL s;
	SLInit(&s);//初始化
	int n = 0;
	do
	{
		menu();
		printf("请选择操作：");
		int x = 0;
		int y = 0;
		scanf("%d", &n);
		switch (n)
		{
		case 1:
			printf("请输入尾插数据，以-1截止\n");
			do
			{
				scanf("%d", &x);
				if (x != -1)
				{
					SLPushback(&s, x);
				}
			} while (x != -1);
			break;
		case 2:
			printf("请输入头插数据，以-1截止\n");
			do
			{
				scanf("%d", &x);
				if (x != -1)
				{
					SLPushfront(&s, x);
				}
			} while (x != -1);
			break;
		case 3:
			SLPopback(&s);
			break;
		case 4:
			SLPopfront(&s);
			break;
		case 5:
			SLPrint(&s);
			break;
		case 6:
			printf("请输入插入下标和插入数据\n");
			scanf("%d %d", &x, &y);
			SLInsert(&s, x, y);
			break;
		case 7:
			printf("请输入删除数据下标\n");
			scanf("%d", &x);
			SLErase(&s, 3);
			break;
		case 8:
			printf("请输入查找数据下标\n");
			scanf("%d", &x);
			SLFind(&s, x);
			printf("x下标数据为:%d\n", s.a[x]);
			break;
		case 9:
			printf("请输入修改下标和修改数据\n");
			scanf("%d %d", &x, &y);
			SLModity(&s, x, y);
			break;
		case 0:
			SLDelete(&s);
			printf("退出程序\n");
			break;
		default:
			printf("输入错误，请重新输入:");
		}
	} while (n);
	return 0;
}

//int x = 0;
//scanf("%d", &x);//输入一个值
//int pos = SLFind(&s, x);//查找返回值的下标
//if (pos != -1)//如果不等于-1表示找到对应的下标了
//{
//	SL....(&s, pos);//各种函数的调用
//}
//SLPrint(&s);//打印

四、总结

顺序表其实比较简单，大家多敲就能掌握玩法。再小编的数据结构实现可能与大家的有所差异，但是目的都是一样的，这些大家不用在意，不管黑猫白猫，能抓老鼠的就是好猫。我们第一步只要能写出来，然后去学习其他人优秀的代码，相互取长补短就行。好了，本期内容就到这里了，我们下期见！

ks不知火
关注
  • 10
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
数据结构入门——顺序表（SeqList）详解（初始化、增、删、查、改）
ZHA_123的博客
11-01 3320
线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。本篇博客我们主要介绍一下顺序表的内容，最后会给出顺序表的应用，也就是之前拖了大家很久的通讯录动态版。
顺序表（数据结构）
outdated_socks的博客
04-07 5375
顺序表详解
数据结构顺序表头文件“SeqList.h”
阳新第一帅
03-22 9128
顺序表头文件SeqList.h包含顺序表的操作有： 1.初始化； 2.求当前数据元素个数； 3.插入数据元素； 4.删除数据元素； 5.取数据元素。
《数据结构》— 数据结构头文件
69小石头的博客
12-16 6629
#include<string.h> #include<ctype.h> #include<malloc.h> // malloc()等 #include<limits.h> // INT_MAX等 #include<stdio.h> // EOF(=^Z或F6),NULL #include<stdlib.h> /...
合工大数据结构顺序表实验
04-14
本实验“合工大数据结构顺序表实验”聚焦于数据结构中的一个重要基础概念——顺序表。顺序表是一种线性数据结构，其中元素在内存中以连续的方式存储，就像数组一样。对于18级合工大的学生来说，这个实验旨在深化他们...
数据结构顺序表c++代码
12-06
本文将深入探讨“数据结构顺序表”的概念以及如何使用C++实现它的基本操作，包括创建、查找、插入和删除。 顺序表，顾名思义，是元素在内存中按照线性顺序排列的数组。它具有连续的存储空间，每个元素都有一个固定...
头歌数据结构顺序表的基本操作1-6关
05-18
【顺序表】是一种基本的数据结构，它在计算机科学中被广泛使用，特别是在处理大量有序或无序数据时。顺序表的实现通常是通过数组来完成的，数组中的元素按顺序存储，便于快速访问和操作。本题涉及顺序表的六种基本...
数据结构顺序表操作示例
09-04
数据结构中的顺序表是一种基本的线性数据结构，它的特点是所有元素存储在一块连续的内存空间中，元素之间的逻辑顺序与物理顺序一致。在顺序表上进行操作时，主要有插入和删除等基本操作。 1. **插入操作**： 在...
c语言数据结构顺序表合并
12-01
1.建立两个顺序表（通过随机函数生成）； 2.排序（升序），输出合并前的结果； 3.对这两个顺序表进行合并（保持升序）； 4.输出合并结果
数据结构源文件代码
08-11
数据结构教程（李春葆）第五版重要的例题代码，能够涵盖所有的章节
头文件和源文件关联的问题
Sam的专栏
09-30 6543
    (对标题的解释：标题中的“源文件”是狭义的概念。小弟只是为了区分，把.h文件称为“头文件“，把.cpp文件称为“源文件“。)    今天有个同事来问我#include 和#inlcude “xxx.h”的区别（关于这个问题，网上已经说滥了，而且林锐博士的《高质量C++/C编程指南》也作了说明）。从这个问题，偶引申出好几个问题，不得已，又去往上”狗狗”了（惭愧的很啊，每次都只能去”狗狗”
顺序表
weixin_45309293的博客
10-19 174
顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成据的增删查改。 顺序表一般可分为：静态顺序表（使用定长数组存储）；动态顺序表（使用动态开辟的数组存储）。 静态顺序表适用于确定知道需要存多少数据的场景. 静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用，相比之下动态顺序表更加灵活，根据需要动态分配内存大小。 动态顺序表的实现： public class MyArrayList { public int[] elem; publi
【数据结构】线性表之顺序表
大米饭的记录册
12-05 433
文章讲解了顺序表及其各个接口的具体实现，包括顺序表的增删查改等。
数据结构-顺序表（学习笔记）
YYYJ_BOY的博客
04-26 1612
顺序表是以数组为储存方式，将n（n>=0）个属性相同的数据元素组成的一个有限序列 顺序表存储结构的实现 ①需要一个数组来存放数据 ②需要一个整形变量来表示顺序表的长度 一、定义顺序表类型 #define LISTSIZE 100 //顺序表的长度 typedef int DataType; //顺序表的数据类型 typedef struct { DataType items[LIST...
数据结构（2）线性表——顺序表
dnsy的博客
07-29 374
数据结构（2）线性表——顺序表
数据结构一线性表 (顺序表、单链表、双链表)
热门推荐
openXu的专栏
07-17 1万+
转载请标明出处： https://blog.csdn.net/xmxkf/article/details/81019110 本文出自:【openXu的博客】 1、线性表及其逻辑结构   线性表是最简单也是最常用的一种数据结构。英文字母表（A、B、…、Z）是一个线性表，表中每个英文字母是一个数据元素；成绩单是一个线性表，表中每一行是一个数据元素，每个数据元素又由学号、姓名、成绩等数据项...
线性数据结构--顺序表
qq_38117478的博客
07-05 275
线性数据结构： 1、顺序表：连续的空间，通过数组实现（seqlist）; 2.链表：存储空间不连续，分为：单向链表、双向链表、循环链表（linklist）; 首先介绍顺序表的实现： 动态链表可以进行元素的插入、删除、排序 具体代码如下： 1.初始化 利用malloc()函数动态开辟内存空间 2.检查顺序表容量，若容量等于默认容量则进行增容
数据结构顺序表C++
最新发布
09-06
- *1* [数据结构顺序表c++代码](https://download.csdn.net/download/qq_46546083/13458006)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值