数据结构顺序表的实现

最新推荐文章于 2024-04-15 13:24:47 发布
最新推荐文章于 2024-04-15 13:24:47 发布
阅读量739 收藏 5
点赞数 10
文章标签： 开发语言 青少年编程 c语言 c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62981548/article/details/124570018
版权

前言

在我们生活当中我们所用的QQ，vx，它们所展示的界面（如群的名字，人的昵称）这些就是一组数据，这些数据都被保存在内存当中，界面是去内存当中将这些数据拿出来然后展示在这个界面上，所以它的底层可以用顺序表，或者链表来进行存储这些数据。

一、顺序表是什么？

顺序表是在计算机内存中以数组的形式保存的线性表，顺序表是简单的一种线性结构，逻辑上相邻的数据在计算机内的存储位置也是相邻的，可以快速定位第几个元素，中间不允许有空值，插入、删除时需要移动大量元素。

顺序表：线性表采用顺序存储的方式存储就称之为顺序表，顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中，所以一般用数组来存储。

二、顺序表的分类

1.静态顺序表（使用定长（长度是固定的）数组存储）

让我们先来看一看顺序表的静态存储结构是怎样的，上代码：

#define MAX_SIZE 100 //方便修改定长数组长度的大小，增强程序可维护性
typedef int SLDataType;//方便替换数据类型，增加程序可维护性
typedef struct SeqList
{
  SLDataType array[MAX_SIZE];//定长数组
  size_t size;//有效的数据个数
}SL;//重新命名这个数据类型为SL

2.动态顺序表（使用动态开辟的数组存储）

让我们先来看一看顺序表的动态存储结构是怎样的，上代码：

#define MAX_SIZE 10
typedef int SLDataType;
typedef struct SeqList
{
	SLDataType *a; //指向动态开辟的数组
	int size;//有效数据个数
    int capacity;//容量空间的大小
}SL;

三、静态顺序表的增删查改

1.静态结构初始化

void InitSeqList(SL *psl)//传入顺序表结构体对象的地址，用指针接收
{
	memset(psl->a, 0, MAX_SIZE*sizeof(SLDataType)); //利用memset函数初始化定长数组，这里也可以通过for循环来初始化数组
	psl->size = 0; //置有效数为0
}

2.头插元素

void HeadInsert(SL *psl,int x) // x表达的是要头插的数
{
	if (psl->size >= MAX_SIZE)//如果有效数据超出了最大容量，则终止程序
	{
		printf("SeqList is full!");
		assert(psl->size < MAX_SIZE);//断言，如果里面条件为假，就终止程序
	}
	else
	{
		int end = psl->size - 1;//end为最后一个有效数据的下标
		do
		{
			psl->a[end+1] = psl->a[end]; //从后往前依次往后挪
			end--; //一直到下标为0
		} while (end>=0);
		psl->a[0] = x; 
		psl->size++; 

	}
}

补充：

 3.尾插元素

void FinalInsert(SL *psl, int x)
{
	if (psl->size >= MAX_SIZE)
	{
		printf("SeqList is full!");
		assert(psl->size < MAX_SIZE);
	}
	else
	{
		psl->a[psl->size] = x; //将要插入的x放到下标为psl->size上，也就是末尾的有效数据加1的位置上
		psl->size++;
	}
}

4.自测头插尾插

我们要养成勤测代码的好习惯，避免写好后出现一大堆的错误

测试很成功！目前代码并没有问题

5.头删元素与尾删元素

void HeadDelete(SL *psl)
{
	assert(psl->size > 0);//如果不成立直接报错
	int start = 1; //下标访问
	while (start < psl->size)
	{
		psl->a[start - 1] = psl->a[start]; //迭代过程
		start++; //迭代条件
	}
	psl->size--;
}


void FinalDelete(SL *psl)
{
	assert(psl->size > 0);
	psl->size--; //通过直接控制有效数来删除
}

代码测试：

运行结果：

测试正确，并没有问题（要测试多次，防止偶然性的发生）

 6.定位插入

void PosInsert(SL *psl, int pos, int x)//pos为插入的位置
{
	assert(psl->size < MAX_SIZE);
	int end = psl->size - 1;
	do{
		psl->a[end+1] = psl->a[end];//迭代过程
        end--;
	} while (end>=pos);迭代条件
	psl->a[pos] = x;//插入位置
	psl->size++;
}

分析图：

end首先是作为最后一个有效数据的下标，将最后一个有效数据往后移（前提是后面有容量），end--，重复以上过程，一直到pos = end时候，我们选定的位置就空出来了 ，再进行赋值。

7.定位删除

void PosDelete(SL *psl,int pos)
{
	assert(psl->size > 0); //断言如果不成立直接报错
	int start = pos + 1; //下标引用 pos为删除的位置
	while (start <= psl->size - 1) //迭代条件
	{
		psl->a[start - 1] = psl->a[start]; //迭代过程
		start++;
	}
	psl->size--;
}

分析图：

pos是要删除的位置，这时候我们可以把pos后面的数据拿到pos这里来，把pos原来的值进行覆盖，这样pos后面的位置就空出来了（也就是I这个长方形图），因为是顺序存储 ，然后再把后面的数据往前移（变成图II）一直到start 小于psl->size - 1结束（因为psl->size -1是最后一个数据的下标）

8.对静态顺序表的总结

我们发现对于静态顺序表，它的容量是一个定值，很容易造成空间浪费严重的问题，过大浪费，过小又保存不了，这时候为了避免这个问题，用动态顺序表就大大提高了空间的利用率，减少了空间的浪费。

四、动态顺序表的增删查改

1.动态顺序表的初始化

void InitSeqList(SL *psl)
{
	psl->a = NULL; //用指针来指向那片动态开辟的数组，先进行初始化为0
	psl->size = 0;//有效数据，与静态顺序表无异
	psl->capacity = 0; //容量，相当于静态顺序表中的MAX_SIZE，只不过这个是动态的可以变化
}

2.尾插元素

void FinalInsert(SL *psl, int x)
{
	if (psl->size == psl->capacity) 
	{
		int newcapacity = psl->capacity == 0 ? 20 : psl->capacity * 2;
		SLDataType *temp = realloc(psl->a, newcapacity*sizeof(SLDataType));
		if (temp == NULL)
		{
			printf("分配失败！");
			exit(-1);
		}
		psl->a = temp;
		psl->capacity = newcapacity;
	}
		psl->a[psl->size] = x;
		psl->size++;
	
}

因为容量一开始是0，所以一开始必须给这个动态数组分配空间，如果空间为0，那么就要分配给20个空间给这个动态数组，如果有空间，空间又被装满了，那么则分配上次空间的2倍作为新的空间，如果分配成功，则让psl->a维护那片动态开辟的空间，容量换为新的容量，最后再进行尾插操作（与静态顺序表类似）。若没有分配成功，则要输出分配失败，并退出程序。

3.头插元素

void HeadInsert(SL *psl,int x)
{
	if (psl->size == psl->capacity)
	{
		int newcapacity = psl->capacity == 0 ? 20 : psl->capacity * 2;
		SLDataType *temp = realloc(psl->a, newcapacity*sizeof(SLDataType));
		if (temp == NULL)
		{
			printf("分配失败");
			exit(-1);
		}
		psl->a = temp;
		psl->capacity = newcapacity;
	}
	
		int end = psl->size - 1;
		do
		{
			psl->a[end+1] = psl->a[end];
			end--;
		} while (end>=0);
		psl->a[0] = x;
		psl->size++;

	
}

与尾插类似先判断容量是不是够用，然后就跟静态顺序表中的头插思路一样

4.展示元素

void PrintSeqList(SL *psl)
{
	for (int i = 0; i < psl->size; i++)//用有效数据控制
	{
		printf("%d ", psl->a[i]);
	}
}

5.尾删元素

void FinalDelete(SL *psl)
{
	assert(psl->size > 0);
	psl->size--;
}

6.头删元素

void HeadDelete(SL *psl)
{
	assert(psl->size > 0);
	int start = 1;
	while (start < psl->size)
	{
		psl->a[start - 1] = psl->a[start];
		start++;
	}
	psl->size--;
}

7.删除指定元素

void PosDelete(SL *psl,int pos)
{
	assert(psl->size > 0);
	int start = pos + 1;
	while (start <= psl->size - 1)
	{
		psl->a[start - 1] = psl->a[start];
		start++;
	}
	psl->size--;
}

8.插入指定元素

void PosInsert(SL *psl, int pos, int x)
{
	if (psl->size == psl->capacity)
	{
		int newcapacity = psl->capacity == 0 ? 20 : psl->capacity * 2;
		SLDataType *temp = realloc(psl->a, newcapacity*sizeof(SLDataType));
		if (temp == NULL)
		{
			printf("分配失败！");
			exit(-1);
		}
		psl->a = temp;
		psl->capacity = newcapacity;
	}

	int end = psl->size - 1;
	do{
		psl->a[end+1] = psl->a[end];
		end--;
	} while (end>=pos);
	psl->a[pos] = x;
	psl->size++;
}

原理相同，先判断要不要开辟空间然后后面的代码就跟顺序表差不多

五、代码分布

1.SeqLIst.h

#include<stdio.h>
#include<string.h>
#include<assert.h>
#include<stdlib.h>
#include<malloc.h>
#define MAX_SIZE 100
typedef int SLDataType;
typedef struct SeqList
{
	SLDataType *a;
	int size;
	int capacity;
}SL;
void InitSeqList(SL *psl);

//头插，尾插，头删，尾删
void HeadInsert(SL *psl,int x);
void FinalInsert(SL *psl,int x);
void HeadDelete(SL *psl);
void FinalDelete(SL *psl);
void PrintSeqList(SL *psl);
void PosInsert(SL *psl, int pos, int x);
void PosDelete(SL *psl, int pos);

2.SeqList.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Seqlist.h"

void InitSeqList(SL *psl)
{
	psl->a = NULL;
	psl->size = 0;
	psl->capacity = 0;
}
void HeadInsert(SL *psl,int x)
{
	if (psl->size == psl->capacity)
	{
		int newcapacity = psl->capacity == 0 ? 20 : psl->capacity * 2;
		SLDataType *temp = (SLDataType *)realloc(psl->a, newcapacity*sizeof(SLDataType));
		if (temp == NULL)
		{
			printf("分配失败");
			exit(-1);
		}
		psl->a = temp;
		psl->capacity = newcapacity;
	}
	
		int end = psl->size - 1;
		do
		{
			psl->a[end+1] = psl->a[end];
			end--;
		} while (end>=0);
		psl->a[0] = x;
		psl->size++;

	
}
void FinalInsert(SL *psl, int x)
{
	if (psl->size == psl->capacity)
	{
		int newcapacity = psl->capacity == 0 ? 20 : psl->capacity * 2;
		SLDataType *temp = (SLDataType *)realloc(psl->a, newcapacity*sizeof(SLDataType));
		if (temp == NULL)
		{
			printf("分配失败！");
			exit(-1);
		}
		psl->a = temp;
		psl->capacity = newcapacity;
	}
		psl->a[psl->size] = x;
		psl->size++;
	
}
void HeadDelete(SL *psl)
{
	assert(psl->size > 0);
	int start = 1;
	while (start < psl->size)
	{
		psl->a[start - 1] = psl->a[start];
		start++;
	}
	psl->size--;
}
void FinalDelete(SL *psl)
{
	assert(psl->size > 0);
	psl->size--;
}
void PosInsert(SL *psl, int pos, int x)
{
	if (psl->size == psl->capacity)
	{
		int newcapacity = psl->capacity == 0 ? 20 : psl->capacity * 2;
		SLDataType *temp = (SLDataType *)realloc(psl->a, newcapacity*sizeof(SLDataType));
		if (temp == NULL)
		{
			printf("分配失败！");
			exit(-1);
		}
		psl->a = temp;
		psl->capacity = newcapacity;
	}

	int end = psl->size - 1;
	do{
		psl->a[end+1] = psl->a[end];
		end--;
	} while (end>=pos);
	psl->a[pos] = x;
	psl->size++;
}

void PosDelete(SL *psl,int pos)
{
	assert(psl->size > 0);
	int start = pos + 1;
	while (start <= psl->size - 1)
	{
		psl->a[start - 1] = psl->a[start];
		start++;
	}
	psl->size--;
}
void PrintSeqList(SL *psl)
{
	for (int i = 0; i < psl->size; i++)
	{
		printf("%d", psl->a[i]);
	}
}

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Seqlist.h"
void menu()
{
	printf("\n**********************************\n");
	printf("**********************************\n");
	printf("***********0.退出程序*************\n");
	printf("***********1.头插*****************\n");
	printf("***********2.尾插*****************\n");
	printf("***********3.头删*****************\n");
	printf("***********4.尾删*****************\n");
	printf("***********5.定位插***************\n");
	printf("***********6.定位删***************\n");
	printf("**********************************\n");
	printf("**********************************\n");
	printf("**********************************\n");
}
void SeqListTest01()
{
	SL sl;
	InitSeqList(&sl);
	int input = 0;
	do
	{
		menu();
		scanf("%d", &input);
		switch (input)
		{
		case 0:
			printf("退出程序！\n");
			break;
		case 1:
		{
			int x = 0;
			printf("请输入要头插的数字>");
			scanf("%d", &x);
			HeadInsert(&sl, x);
			PrintSeqList(&sl);
			break;
		}
		case 2:
		{
			int x = 0;
			printf("请输入要尾插的数字>");
			scanf("%d", &x);
			FinalInsert(&sl, x);
			PrintSeqList(&sl);
			break;
		}
		case 3:
		{
			printf("成功删除\n");
			HeadDelete(&sl);
			PrintSeqList(&sl);
			break;
		}
		case 4:
		{
			printf("成功删除\n");
			FinalDelete(&sl);
			PrintSeqList(&sl);
			break;
		}
		case 5:
		{
			int x = 0;
			int pos = 0;
			printf("请输入想要插入的数字>");
			scanf("%d", &x);
			printf("请输入想要插入的位置的下标>");
			getchar();
			scanf("%d", &pos);
			PosInsert(&sl, pos, x);
			PrintSeqList(&sl);
			break;
		}
		case 6:
		{
			int pos = 0;
			printf("请输入想要删除的位置的下标>");
			scanf("%d", &pos);
			printf("成功删除\n");
			PosDelete(&sl, pos);
			PrintSeqList(&sl);
			break;
		}
		}
	} while (input);
	 
}
int main()
{
	SeqListTest01();

	return 0;
}

代码测试

 

六、静态顺序表与动态顺序表的类比

细心的网友们都发现了，动态顺序表其实跟静态顺序表上的代码大致上一样的，但是开辟的方式却有所不同，一个是动态开辟的用了realloc一个是静态开辟的就是用的数组，让我们来比较一下他们两个的优缺点吧
扩容方法：动态开辟一块新的空间（一般是为原空间的两倍），将原空间的数据拷贝到新的空间，然后让指针指向新的空间。
优缺点比较
静态顺序表创建空间时为静态开辟，没用realloc函数，代码简单，不存在内存泄露问题
动态顺序表，动态开辟空间，使用灵活，减少了空间浪费。


 

飞飞的飞
关注
  • 10
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 9
    评论
【数据结构——顺序表的实现】
m0_56069910的博客
01-21 1195
顺序表的具体实现
【数据结构】顺序表的实现
学了就忘是正常现象
08-01 1075
【数据结构】顺序表的实现及数组相关oj题
【数据结构】--顺序表的实现
最新发布
2301_78009847的博客
04-15 1023
/动态顺序表//一级指针指向的动态开辟的数组int size;//有效数据个数//数组的容量大小}SL;
【数据结构】顺序表的实现——超级无敌详细
qq_59702185的博客
08-07 2009
在当我们每想插入一个数据的时候，我们都要对顺序表进行判断，容量 capacity 是否和 size 相等，如果相等的话，那么，顺序表的空间就不够我们进行插入数据了。当然我们不能需要插入一个数据就开辟一个数据的大小，这样的话，付出的代价很大，我们可以每次增容 2 倍的capacity大小的容量，或者4倍，2倍是比较好的了。在我们想把顺表表最后一个数据删除时，不能直接赋为0，第一，我们不知道SLDataType到底是什么数据类型，第二，顺序表的最后一个数据有可能就是0，没有意义。遍历一遍顺序表，打印顺序表。..
【数据结构】C语言实现顺序表（超级详细）
热门推荐
m0_74459723的博客
01-01 1万+
顺序表作为线性表的一种，它是用一段数据元素的线性结构，一般情况下采用。在数组上完成数据的增删查改。顺序表一般分为：1、静态顺序表——使用定长数组进行存储元素。这种存储方式在存储数据时比较有局限性，当数据存储量非常小的时候，数组长度太长，会造成空间的浪费；当数据存储量非常大的时候，数组空间可能会不够，但是这种存储方式不能进行扩容。所以在实现顺序表时，我们通常使用的是动态顺序表。这样能够提高我们的空间利用率。2、动态顺序表——使用动态开辟的数组进行存储元素。
顺序表的实现超详细
川子767的博客
02-24 1336
一文带你学会顺序表的基本实现（超详细）
数据结构顺序表，c语言简单实现
01-12
顺序表是一种基本的数据结构，它的实现简单直观，适用于小规模数据的存储。本文将深入探讨数据结构中的顺序表及其C语言实现。 顺序表，顾名思义，是指元素在内存中按照线性顺序排列的数组。这种结构允许我们通过...
数据结构 顺序表实现的购票系统
06-20
定义顺序表，包含成员{影片名；时间；座位数；票价；评价；上座率} 完成功能：1、初始化构造顺序表；2、插入一条影片信息；3、删除一条影片信息；4、按影片名查找；5、购票；6、退票；7、求上座率；8、查看评价
数据结构顺序表操作示例
09-04
数据结构中的顺序表是一种基本的线性数据结构，它的特点是所有元素存储在一块连续的内存空间中，元素之间的逻辑顺序与物理顺序一致。在顺序表上进行操作时，主要有插入和删除等基本操作。 1. **插入操作**： 在...
数据结构顺序表 C语言代码实现以及realloc的使用
07-09
数据结构中的顺序表是一种基本的线性存储结构，它在内存中连续存放元素，通过下标访问元素。本文将深入探讨如何使用C语言实现顺序表，并重点讲解`realloc`函数在扩展内存时的作用。 首先，我们需要理解顺序表的基本...
合工大数据结构顺序表实验
04-14
本实验“合工大数据结构顺序表实验”聚焦于数据结构中的一个重要基础概念——顺序表。顺序表是一种线性数据结构，其中元素在内存中以连续的方式存储，就像数组一样。对于18级合工大的学生来说，这个实验旨在深化他们...
数据结构 顺序表的实现（c语言版）
06-05
数据结构 顺序表的实现（c语言版）
数据结构顺序表的算法实现
07-06
数据结构中顺序表的C语言程序简单源代码，数据结构顺序表的算法实现
数据结构的源代码（顺序表）
05-30
数据结构线性表的顺序表示，有插入结点，删除结点，计算节点个数等功能，可选择功能执行。
顺序表的原理与初始化
骆驼胡杨的博客
07-22 471
顺序表是简单的一种线性结构，逻辑上相邻的数据在计算机内的存储位置也是相邻的，可以 快速定位第几个元素，中间不允许有空值，插入、删除时需要移动大量元素。 顺序表的三个要素： 用 elems 记录存储位置的基地址 分配一段连续的存储空间 size 用 length 记录实际的元素个数，即顺序表的长度 结构体定义 #define MAX_SIZE 100 //表示顺序表的空间大小 struct _SqList{ ElemType *elems; // 顺序表的基地址 int length;
顺序表的实现
weixin_53316121的博客
03-13 2695
目录 1.顺序表的概念 2.静态顺序表 分析： 3.动态顺序表 分析： 4.顺序表初始化 5.顺序表尾部操作 5.1尾插 空间检查函数实现 分析： 5.2尾删 分析： 6.顺序表的头部操作 6.1头插 分析： 6.2头删 分析： 7.固定位置操作 7.1固定位置插入 分析： 7.2固定位置删除 分析： 8.查找及打印 9.销毁顺序表 10.我的菜单及主函数 直接上代码： 1.顺序表的概念 顺序表是用一段物理地址连续的存储单元依次存储数据元素...
顺序表的初始化【C语言】
少年一贯快马扬帆，道阻且长不转弯； 要盛大，要绚烂，要哗然； 要用理想的泰坦尼克，去撞现实的冰川； 要当烧赤壁的风，而非借鉴草船； 要为了一片海，就肯翻万山。
07-14 3022
/*By yangbocsu 线性表之顺序表 2021.07.14*/ #include <stdio.h> #include "stdlib.h" /*预定义常量和类型*/ /*函数结果状态码*/ #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2 /.
数据结构-顺序表(c++)含全代码
Abieai的博客
11-24 6443
顺序表的原理及实现 文章目录前言一、顺序表是什么？二、创建顺序表三、顺序表的初始化及销毁1.顺序表的初始化2.顺序表的销毁四、顺序表的基本操作1.顺序表的添加元素2.顺序表的插入元素3.顺序表的删除元素4.打印顺序表的元素五、完整代码总结 前言 提示：以下是本篇文章正文内容，下面案例可供参考 一、顺序表是什么？ 线性表的顺序存储又称顺序表。 它是用一组地址连续的存储单元依次存储线性表中的数据元素，从而使得逻辑上相邻的两个元素在物理地址上也相邻。 顺序表的特点是表中元素的逻辑顺序与其物理顺序相
c语言顺序表的初始化Status,数据结构（c语言版）顺序表的建立、初始化、插入、删除、遍历等12个基本操作及测试...
weixin_29367131的博客
05-19 3966
数据结构是计算机类学生基本上必修的一门课程，也是比较难得一门课程。对于初学者来说刚开始学肯定会不理解，感觉很难，所以最近写了个数据结构的顺序表。顺序表包含了初始化、判空、求表长、销毁、定位、删除、插入、等十二个基本操作。运行了一下感觉还可以，所以想拿出来和大家分享一下！以下是源代码，建立一个工程第一个头文件：一些基本的定义声明#include#include#define OK 1#define ...
python数据结构顺序表实现2、删除学号为2018007的记录；
06-28
回答3：</h3><br/>顺序表是一种线性结构，可以用数组实现。在Python中，我们可以用列表（List）来实现顺序表。删除学号为2018007的记录，可以按照以下步骤进行： 1. 创建一个列表，存储所有学生的相关信息，例如...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值