顺序表(详细)

已于 2022-12-30 16:09:10 修改
阅读量217 收藏
点赞数
分类专栏： # 线性表 文章标签： 数据结构
于 2022-12-17 19:54:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wenjiahui123/article/details/128341476
版权

目录

一.实现结构(俩种)

二.代码实现

(一).初始化

(二).扩容

(三).尾插

(四).头插

(五).尾删

(六).头删

(七).任意位置插入

(八).任意位置删除

(八)查找

(九).修改

(十).交互使用

三.完整代码

实际上就是一种从第一个位置开始向后依次连续存储数据的数组

一.实现结构(两种)

静态:

动态

二.代码实现

使用防御式编程，凡涉及到指针(函数参数中有指针)的地方，全部断言，出现错误后，错误可以被快速清晰的找到.

(一).初始化

注意:

1.为什么参数传指针,形参的改变不影响实参,调试一下

void SLInit(SL* ps)//ps-p-point
{
	ps->a = NULL;
	ps->size = 0;
	ps->capacity = 0;
}

(二).扩容

由于尾插,头插等函数都需要扩容,因此将扩容功能封装成函数,方便使用.

注意:

realloc有两种扩容方式

原地扩容:

异地扩容:旧空间释放,返回新空间的指针

realloc返回值为void*类型

typedef int SLDataType;

SLDataType* tmp = (SLDataType*)realloc(ps->a, newCapacity*sizeof(SLDataType));

(由于reallloc返回类型是void*,但要赋值给int*,强转为int*)realloc(要扩容数组的第一个元素的指针,要扩容到多少个字节数)

void SLCheckCapacity(SL* ps)
{
	//一个数据都没存储(capacity=0),数据存满(capacity=size)这俩种情况都需要扩容
	if (ps->capacity == ps->size)//可以表示俩种情况,0==0,满==满
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		//一个数据都没存,给4个字节空间
		//有数据存储,但已经存满,给俩倍空间
		SLDataType* tmp = (SLDataType*)realloc(ps->a, newCapacity*sizeof(SLDataType));
		//为啥不直接给ps->a,因为害怕realloc扩容失败,等扩容成功后,再把tmp赋值给ps->a
		if (tmp == NULL)
		{
			perror("realloc");
			exit(-1);//退出程序
		}
		ps->a = tmp;
		ps->capacity = newCapacity;
	}
}

(三).尾插

void SLPushBack(SL* ps, SLDataType x)
{
	assert(ps);
	SLCheckCapacity(ps);
	ps->a[ps->size] = x;
	ps->size++;
}

(四).头插

把所有数据向后挪动,而且必须从后向前挪动

void SLPushFront(SL* ps, SLDataType x)
{
	assert(ps);
	SLCheckCapacity(ps);
	int end = ps->size - 1;
	while (end >= 0)
	{
		ps->a[end+1] = ps->a[end];
		--end;
	}
	ps->a[0] = x;
	ps->size++;//标号++
}

(五).尾删

注意:

1.尾删4次,size就会变成-1
数组会越界
因此每次尾删前需要判断size:size>0

2.并不是每次数组越界编译器都会检查,编译器只会抽查.(这里的数组越界会在销毁空间(free)时被编译器检查到)

void SLPopBack(SL* ps)
{
	assert(ps != NULL);
	assert(ps->size > 0);///为假,assert会报错
	ps->size--;
}

(六).头删

注意

1.和尾删一样,每次头删前也需要判断size(当前空间种数据个数)必须大于0

2.头删必须从前向后把数据向前挪动一格,不能从后向前

void SLPopFront(SL* ps)
{
	assert(ps);
	assert(ps->size > 0);///为假,报错
	int begin = 0;
	int end = ps->size - 1;
	while (begin < end)
	{
		ps->a[begin] = ps->a[begin + 1];
		++begin;
	}
	ps->size--;
}

(七).任意位置插入

注意

1.pos范围[0,size]   为什么可以等于size,尾插时ps->a[ps->size]这个位置也可以插入

2.插入数据都需要调用 SLCheckCapacity(ps);函数

3.pos是要插入的位置(pos指的是数组下标)

void SLInsert(SL* ps, int pos, int x)//pos是数组下标
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);
	SLCheckCapacity(ps);
	int begin = pos-1;
	int end = ps->size;
	while (end >= begin)
	{
		ps->a[end + 1] = ps->a[end];
		--end;
	}
	ps->a[pos] = x;
	ps->size++;

}

代码复用

//头插
void SLPushFront(SL* ps, SLDataType x)
{
	SLInsert(ps, 0, x);
}
//尾插
void SLPushBack(SL* ps, SLDataType x)
{
	SLInsert(ps, ps->size, x);//代码复用
}

(八).任意位置删除

注意:begin<size-1而不是begin<size

void SLEarse(SL* ps, int pos)
{


	assert(ps);
	assert(pos >= 0 && pos < ps->size);
    //不用检查数组a是否为空，这里顺带就检查了，pos < ps->size(ps->size为0)

	//注意控制边界，控制方式1
	//int begin = pos;
	//while (begin < ps->size - 1)//小于ps->size - 1而不是小于ps->size，防止数组越界
	//{
	//ps->a[begin] = ps->a[begin + 1];
	//++begin;
	//}
	//注意控制边界，控制方式2
	int begin = pos + 1;
	while (begin < ps->size)
	{
		ps->a[begin - 1] = ps->a[begin];
		++begin;
	}
	ps->size--;
}

代码复用

//头删
void SLPopFront(SL* ps)
{
	SLEarse(ps, 0);
}
//尾删
void SLPopBack(SL* ps)
{
	SLEarse(ps, ps->size - 1);
}

(八)查找

找到了,返回找到数的下标

找不到,返回-1

int SLSearch(SL* ps, SLDataType x)
{
	assert(ps);
	int i = 0;
	for (i = 0; i < ps->size; ++i)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
	}
	return -1;//x不在顺序表中
}

(九).修改

void Modify(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);
	ps->a[pos] = x;
}

(十).交互使用

SLSearch与Modify或者SLEarse可以交互使用

如果顺序表中有要找的数字,则SLSearch会返回该数字下标

而Modify或者SLEarse需要数字下标才能找到数字进行操作

void TestSeqList8()//测试查找与修改
{
	SL sl;
	SLInit(&sl);
	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);
	SLPushBack(&sl, 5);
	PrintSeqList(&sl);


	//SLSearch可以和SLEarse交互使用
	//SLSearch如果找到要找的数会返回下标,把下标传给SLEarse这个数就会被删除
	int num = 0;
	printf("请输入你要删除的值:\n");
	scanf("%d", &num);
	int pos = SLSearch(&sl, num);//返回你要删除那个值的下标
	if (pos != -1)
	{
		SLEarse(&sl, pos);
		PrintSeqList(&sl);
	}
	else
	{
		printf("你要删除的值不在顺序表中\n");
	}


	//SLSearch可以和Modify交互使用
	//SLSearch返回下标,将下标传给Modify修改
	int y, z;
	printf("请输入你要修改的值和修改后的值:");
	scanf("%d %d", &y, &z);//输入哪个数字就会修改哪个数字
	pos = SLSearch(&sl, y);
	if (pos != -1)
	{
		Modify(&sl, pos, z);
	}
	else
	{
		printf("要修改的%d不存在", y);
	}
	PrintSeqList(&sl);
}

三.完整代码

//SeqList.h

#pragma once
#include<stdio.h>
#include<stdlib.h>//realloc,malloc
#include<assert.h>



//typedef int SLDataType;
静态存储,N太小,空间不够用,N太大,浪费空间
//#define MAX 100
//typedef struct SeqList
//{
//	SLDataType a[MAX];//开MAX个数组
//	int size;//当前数据个数
//}SL;




typedef int SLDataType;
typedef struct SeqList
{
	SLDataType* a;//动态顺序表首元素指针
	int size;//当前存储数据个数
	int capacity;//当前存储容量
}SL;

void PrintSeqList(SL* ps);//打印顺序表


void SLInit(SL* ps);//初始化
void SLCheckCapacity(SL* ps);//检查容量

void SLPushBack(SL* ps, SLDataType x);//尾插
void SLPushFront(SL* ps, SLDataType x);//头插

void SLPopBack(SL* ps);//尾删
void SLPopFront(SL* ps);//头删

void SLDestory(SL* ps);//销毁空间

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

int SLSearch(SL* ps, SLDataType x);//查找,返回下标
void Modify(SL* ps, int pos, SLDataType x);//修改数组中下标为pos位置的元素,改为x


//SeqList.c
#define _CRT_SECURE_NO_WARNINGS 1
#include"SeqList.h"

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

void SLInit(SL* ps)//ps-p-point
{
	ps->a = NULL;
	ps->size = 0;
	ps->capacity = 0;
}


void SLCheckCapacity(SL* ps)
{
	//一个数据都没存储(capacity=0),数据存满(capacity=size)这俩种情况都需要扩容
	if (ps->capacity == ps->size)//可以表示俩种情况,0==0,满==满
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		//一个数据都没存,给4个字节空间
		//有数据存储,但已经存满,给俩倍空间
		SLDataType* tmp = (SLDataType*)realloc(ps->a, newCapacity*sizeof(SLDataType));
		//为啥不直接给ps->a,因为害怕realloc扩容失败,等扩容成功后,再把tmp赋值给ps->a
		if (tmp == NULL)
		{
			perror("realloc");
			exit(-1);//退出程序
		}
		ps->a = tmp;
		ps->capacity = newCapacity;
	}
}


void SLPushBack(SL* ps, SLDataType x)
{
	//assert(ps);
	//SLCheckCapacity(ps);
	//ps->a[ps->size] = x;
	//ps->size++;

	SLInsert(ps, ps->size, x);//代码复用
}

void SLPushFront(SL* ps, SLDataType x)
{
	//assert(ps);
	//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);
	//assert(ps->size > 0);///为假,报错
	//ps->size--;

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



void SLPopFront(SL* ps)
{
	//assert(ps);
	//assert(ps->size > 0);///为假,报错
	//int begin = 0;
	//int end = ps->size - 1;
	//while (begin < end)
	//{
	//	ps->a[begin] = ps->a[begin + 1];
	//	++begin;
	//}
	//ps->size--;

	SLEarse(ps, 0);
}


void SLDestory(SL* ps)
{
	assert(ps);
	if (ps->a != NULL)
	{
		free(ps);
		ps->a = NULL;
		ps->capacity = ps->size = 0;
	}
}


void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);
	SLCheckCapacity(ps);
	int begin = pos-1;
	int end = ps->size;
	while (end >= begin)
	{
		ps->a[end + 1] = ps->a[end];
		//ps->a[end] = ps->a[end-1];
		--end;
	}
	ps->a[pos] = x;
	ps->size++;

}

void SLEarse(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);
	int begin = pos;
	int end = ps->size - 1;
	while (begin < end)
	{
		ps->a[begin] = ps->a[begin + 1];
		++begin;
	}
	ps->size--;

}

int SLSearch(SL* ps, SLDataType x)
{
	assert(ps);
	int i = 0;
	for (i = 0; i < ps->size; ++i)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
	}
	return -1;//x不在顺序表中
}


void Modify(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);
	ps->a[pos] = x;
}



//test.c  测试
#define _CRT_SECURE_NO_WARNINGS 1

#include"SeqList.h"

void TestSeqList1()
{
	SL sl;
	SLInit(&sl);
}

void TestSeqList2()//尾插
{
	SL sl;
	SLInit(&sl);
	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);
	SLPushBack(&sl, 5);
	PrintSeqList(&sl);

}
void TestSeqList3()//头插
{
	SL sl;
	SLInit(&sl);
	SLPushFront(&sl, 1);
	SLPushFront(&sl, 2);
	SLPushFront(&sl, 3);
	SLPushFront(&sl, 4);
	SLPushFront(&sl, 5);
	SLPushFront(&sl, 6);
	PrintSeqList(&sl);
}

void TestSeqList4()//尾删
{
	SL sl;
	SLInit(&sl);
	SLPushFront(&sl, 1);
	SLPushFront(&sl, 2);
	SLPushFront(&sl, 3);
	SLPushFront(&sl, 4);
	SLPushFront(&sl, 5);
	SLPushFront(&sl, 6);
	PrintSeqList(&sl);

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

	PrintSeqList(&sl);

}


void TestSeqList5()//尾删
{
	SL sl;
	SLInit(&sl);
	//SL* sl = NULL;
	//SLInit(&sl);

	SLPushFront(&sl, 1);
	SLPushFront(&sl, 2);
	SLPushFront(&sl, 3);
	SLPushFront(&sl, 4);
	SLPushFront(&sl, 5);
	SLPushFront(&sl, 6);
	PrintSeqList(&sl);

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


	PrintSeqList(&sl);

}

void TestSeqList6()//任意位置插入
{
	SL sl;
	SLInit(&sl);
	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);
	SLPushBack(&sl, 5);
	PrintSeqList(&sl);

	SLInsert(&sl, 3, 208);
	PrintSeqList(&sl);

	SLPushBack(&sl, 298);
	PrintSeqList(&sl);

	SLPushFront(&sl, 9998);
	PrintSeqList(&sl);
}


void TestSeqList7()//任意位置删除
{
	SL sl;
	SLInit(&sl);
	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);
	SLPushBack(&sl, 5);
	PrintSeqList(&sl);


	//SLEarse(&sl, 3);

	//PrintSeqList(&sl);

	SLPopBack(&sl);
	PrintSeqList(&sl);
	SLPopFront(&sl);
	PrintSeqList(&sl);


}


void TestSeqList8()//测试查找与修改
{
	SL sl;
	SLInit(&sl);
	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);
	SLPushBack(&sl, 5);
	PrintSeqList(&sl);


	//SLSearch可以和SLEarse交互使用
	//SLSearch如果找到要找的数会返回下标,把下标传给SLEarse这个数就会被删除
	int num = 0;
	printf("请输入你要删除的值:\n");
	scanf("%d", &num);
	int pos = SLSearch(&sl, num);//返回你要删除那个值的下标
	if (pos != -1)
	{
		SLEarse(&sl, pos);
		PrintSeqList(&sl);
	}
	else
	{
		printf("你要删除的值不在顺序表中\n");
	}


	//SLSearch可以和Modify交互使用
	//SLSearch返回下标,将下标传给Modify修改
	int y, z;
	printf("请输入你要修改的值和修改后的值:");
	scanf("%d %d", &y, &z);//输入哪个数字就会修改哪个数字
	pos = SLSearch(&sl, y);
	if (pos != -1)
	{
		Modify(&sl, pos, z);
	}
	else
	{
		printf("要修改的%d不存在", y);
	}
	PrintSeqList(&sl);
}

int main()
{
	//TestSeqList1();
	//TestSeqList2();
	//TestSeqList3();
	//TestSeqList4();
	//TestSeqList5();
	//TestSeqList6();
	//TestSeqList7();
	TestSeqList8();
	return 0;
}

菠萝.吹.雪
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言指针回传,指针传参和返回有关问题
weixin_28727975的博客
05-24 758
指针传参和返回问题在主函数把一个非空指针传到子函数里，让他指向新的地址，然后返回，在主函数里这个指针指向什么地方？#includeint*test(int*a){a=NULL;returna;}voidmain(){intb=3;int*a=&b;printf("%d\n",test(a));printf("*a=%da=%d\n",*a,a);getchar();}输出结...
数据结构C++顺序表详细操作实现(输入命令式)
12-06
代码功能包括： "1:创建顺序表" "2:插入元素" "3:查找元素" "4:删除元素" "5:输出顺序表" "6:退出
c语言顺序表如何传参数,c语言：顺序表传参要是指针类型的才能改变顺序表
weixin_30320081的博客
05-19 309
想在头文件中初始化顺序表，在main函数只能传参的时候传的是(sqlList L),调用LocalElem(L，X)是报错说没有给L初始化.原因:调用初始化的函数，传过去的参数是sqlList L并不能改变实参，虽有后来改为了sqlList *L，就可以了#pragma once#define maxSize 100typedef struct {int data[maxSize];int len...
顺序表的基本操作（超详细）
热门推荐
m0_56992713的博客
10-16 11万+
1.顺序表的定义 使用结构体来构造一个顺序表。 typedef struct { int length;//当前顺序表长度 int Maxsize;//顺序表最大长度 int* data;//定义顺序表中元素类型的数组指针 }SqList; 2.顺序表的初始化 顺序表的初始化是使用动态分配数组空间方式构造一个空的线性表。 #include<stdio.h> #include<stdlib.h> #define InitSize 10 void InitList(SqList
掌握顺序表：从概念到C语言实现
howard2005的专栏
01-16 2万+
C语言实现顺序表的创建与增删改查操作
实验一 顺序表
popoywei的博客
11-01 1229
实验一
顺序表的实现超详细
川子767的博客
02-24 1672
一文带你学会顺序表的基本实现（超详细）
Python实现顺序表（详细）
Sirow的博客
01-08 8324
线性表是具有相同数据类型的n个数据元素的有限序列 顺序表即线性表的顺序存储结构。它是通过一组地址连续的存储单元对线性表中的数据进行存储的，相邻的两个元素在物理位置上也是相邻的。比如，第1个元素是存储在线性表的起始位置LOC(1)，那么第i个元素即是存储在LOC(1)+(i-1)*sizeof(ElemType)位置上，其中sizeof(ElemType)表示每一个元素所占的空间。 Pytho...
《Java数据结构入门》顺序表详解
日常学习记录、分享，愿我们都遇见更好的自己，与诸君共勉
04-25 5795
带你手把手自己模拟实现Java数据结构中的顺序表，很详细的哟😁
【数据结构】顺序表 超详细！
唯有忍受别人不能忍受的，才能享受别人不能享受的
01-29 2302
主要讲述，顺序表的概念 和 具体实现原理 及 详细代码，讲解详细！
C语言实现动态顺序表的实现代码
08-29
下面将详细介绍动态顺序表的实现代码。 一、顺序表的基本概念 顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。顺序表采用顺序存储的方式存储，就是将...
线性表之顺序表
03-28
下面我们将详细探讨顺序表的建表、查询、插入和删除操作。 **建表**： 建立顺序表通常是从空表开始，通过一系列插入操作将元素添加到表中。例如，可以初始化一个足够大的数组，然后逐个将元素加入数组的末尾。这种...
PTA—C语言数据结构：顺序表.ppt
10-11
下面我们将详细讨论顺序表的概念、特性以及C语言中的实现方法。 顺序表是一种线性数据结构，它的特点是元素在内存中是连续存储的，可以通过索引快速访问任意位置的元素。这种结构简单直观，易于理解和操作。在C语言...
数据结构-顺序表与链表详解
m0_62918577的博客
11-05 1852
顺序表概念及分类，以及动态顺序表的接口实现 链表的概念及结构以及无头单向非循环链表的接口实现 在不同方面解析顺序表和链表的区别
数据结构_顺序表详细代码
destiny_JL的博客
12-02 1802
#include <stdio.h> #include <stdlib.h> #define M 100 typedef int ElemType; typedef struct { ElemType elem[M]; /* 线性表占用的数组空间*/ int last; /*记录线性表中最后一个元素在数组elem[ ] 中的位置（下标值），空表置为-1*/ }SeqList; SeqLi
【数据结构】——1.1树
最新发布
qq_43507078的博客
09-07 981
树，二叉树
数据结构-栈、队列-相关练习
2401_86587256的博客
09-05 1457
数据结构初阶部分，栈和队列的相关练习。
数据结构----树
2301_77841194的博客
09-07 948
1、树(Tree)是n(n≥0)个结点的有限集。n=O时称为空树。在任意一棵非空树中:(1）有且仅有一个特定的称为根(Root)的结点;(2)当n>1时,其余结点可分为m(m>0)个互不相交的有限集T1、T2、……、Tm,其中每一个集合本身又是一棵树,并且称为根的子树(SubTree)2、树的结点包含一个数据元素及若干指向其子树的分支。结点拥有的子树数称为结点的度(Degree)。度为0的结点称为叶结点（Leaf）或终端结点;度不为0的结点称为非终端结点或分支结点。
C++实现顺序表删除操作详解
以下是对顺序表删除操作的详细说明： 1. **删除操作的前提条件** - 在执行删除操作之前，需要检查位置`pos`是否有效。如果`pos，表示位置不合法，应直接返回`false`。 - 同样，需要确认顺序表是否为空，即`list....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值