静态顺序表的概念及实现

最新推荐文章于 2022-06-30 20:33:10 发布
最新推荐文章于 2022-06-30 20:33:10 发布
阅读量501 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 线性表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Eric_qiushui/article/details/79951204
版权

静态顺序表，不涉及动态申请空间

一、顺序表概念

1.首先，顺序表的概念了解一下：
顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。线性表采用顺序存储的方式存储就称之为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。

//顺序表声明
 typedef int DataType;
#define MAX_SIZE 10 

typedef struct SeqList
{
	DataType _array[MAX_SIZE];
	int _size; // 表示顺序表中有效元素的个数 
}SeqList, *PSeqList;

2.特点：
可以通过下标访问，遍历顺序表；但是在顺序表中插入或删除操作比较麻烦（因为需要移大量元素）。

二、顺序表的基本操作

这次的操作对象都是静态顺序表，不涉及动态申请内存

  1. 顺序表的初始化：
//SeqList.h
//声明
void SeqListInit(PSeqList ps);


//SeqList.c
//定义
void SeqListInit(PSeqList ps)
{
	assert(ps);//顺序表已经定义，若传进来的ps是NULL属非法操作
	memset(ps->_array, 0, sizeof(DataType));
	ps->_size = 0;
}

2.顺序表尾插操作：

//SeqList.h 声明
void SeqListPushBack(PSeqList ps, DataType data);


//SeqList.c 定义
void SeqListPushBack(PSeqList ps, DataType data)
{
	assert(ps);//顺序表已经定义，若传进来的ps是NULL属非法操作
	//需要考虑顺序表是否已经满了的情况，如果表已满，无法插入，直接返回
	if (MAX_SIZE == ps->_size)
	{
		printf("顺序表已满！！！\n");
		return;
	}
	else
	{
		ps->_array[ps->_size] = data;
		ps->_size++;//插入成功就让size++;
	}
}

3.顺序表的尾删：

//SeqList.h 声明
void SeqListPopBack(PSeqList ps);


//SeqList 定义
void SeqListPopBack(PSeqList ps)
{
	assert(ps);//顺序表已经定义，若传进来的ps是NULL属非法操作
	//同样，需要判断顺序表是否为空表，若为空，无法删除，直接返回
	if (0 == ps->_size)
	{
		printf("表已空，无法删除！！！\n");
		return;
	}
	else//若顺序表不为空，只需要让size--即可
	{
		ps->_size--;
	}	
}

4.顺序表的遍历
为了直观的看出操作是否正确，我们定义了一个辅助函数PrintSeqList，打印顺序表中所有元素。

//SeqList.h 声明
void PrintSeqList(PSeqList ps);


//SeqList.c 定义
void PrintSeqList(PSeqList ps)
{
	int i = 0;
	assert(ps);顺序表已经定义，若传进来的ps是NULL属非法操作
	while (i < ps->_size)
	{
		printf("%d ", ps->_array[i]);
		i++;
	}
	printf("\n");
}

5.为验证1、2、3、4的操作，我们写了一个测试函数

//test.c
#include "SeqList.h"

//测试函数--测试顺序表的初始化、尾插和尾删操作
void TestSeqListInit_PushBack_PopBack()
{
	SeqList seq;//定义顺序表
	SeqListInit(&seq);//初始化顺序表
	SeqListPushBack(&seq, 0);//对顺序表尾插一个元素
	SeqListPushBack(&seq, 1);
	SeqListPushBack(&seq, 2);
	SeqListPushBack(&seq, 3);
	PrintSeqList(&seq);//打印顺序表
	SeqListPopBack(&seq);//尾删顺序表的一个元素
	PrintSeqList(&seq);
}
//主函数
int main()
{
	TestSeqListInit_PushBack_PopBack();//调用测试函数
	system("pause");
	return 0;
}

测试结果：
运行之后的结果

6.顺序表的头插

//SeqList.h 声明
void SeqListPushFront(PSeqList ps, DataType data);


//SeqList.c 定义
//顺序表头插相对比较麻烦，需要把第一个及以后元素向后移动
void SeqListPushFront(PSeqList ps, DataType data)
{
	int i = 0;
	assert(ps);//顺序表已经定义，若传进来的ps是NULL属非法操作
	if (MAX_SIZE == ps->_size)
	{
		//若条件成立，表示表已满，无法插入，直接返回
		printf("表已满，无法插入！！！\n");
		return;
	}
	else
	{
		i = ps->_size;		
		//把所有元素后移
		while (0 != i)
		{
			ps->_array[i] = ps->_array[i-1];
			i--;
		}
		//将data赋给顺序表第一个元素
		ps->_array[0] = data;
		ps->_size++;
	}
}

7.顺序表的头删

//SeqList.h 声明
void SeqListPopFront(PSeqList ps);


//SeqList.c 定义
//同头插，顺序表的头删也比较麻烦，要搬大量元素
void SeqListPopFront(PSeqList ps)
{
	int i = 0;
	assert(ps);//参数检验，是否非法
	if (0 == ps->_size)
	{//表已空，无法删除
		printf("表已空！！！\n");
		return;
	}
	else
	{//让第二及第二个元素一次向前覆盖即可
		while (i < ps->_size-1)
		{
			ps->_array[i] = ps->_array[i+1];
			i++;
		}
	}
	ps->_size--;//最后让用来统计元素个数的size--
}

8.接下来测试顺序表的头插和头删

//test.c 
void TestSeqListPushFront_PopFront()
{
	SeqList seq;//定义一个顺序表
	SeqListInit(&seq);//顺序表初始化
	PrintSeqList(&seq);//先打印一遍顺序表，方便对比头插以后结果

	SeqListPushFront(&seq, 3);//头插一个元素
	SeqListPushFront(&seq, 2);
	SeqListPushFront(&seq, 1);
	SeqListPushFront(&seq, 0);
	PrintSeqList(&seq);//再次打印顺序表

	SeqListPopFront(&seq);//头删一个元素
	PrintSeqList(&seq);//再次打印顺序表
}

//主函数
int main()
{
	TestSeqListPushFront_PopFront();
	system("pause");
	return 0;
}

测试结果：
头插_头删
9. 在顺序表的pos位置插入元素data
注意：pos位置应该按照数组角度来看，不是客观上的第pos个位置

//SeqList.h 声明
// 顺序表pos位置插入元素data 
void SeqListInsert(PSeqList ps, int pos, DataType data);

// SeqList.c 定义
// 顺序表pos位置插入元素data 
void SeqListInsert(PSeqList ps, int pos, DataType data)
{
	int i = 0;
	//参数检验
	assert(ps);
	if (pos < 0 || pos > MAX_SIZE)
	{
		printf("pos位置非法！！\n");
		return;
	}
	//要在pos位置插入元素，需要将pos位置及pos以后元素往后移一个单位
	//所以需要判断表是否已经满了
	if (MAX_SIZE == ps->_size)
	{
		//表已满，插入失败
		printf("表已满，无法插入！！！\n");
		return;
	}
	i = ps->_size - 1;
	while (i >= pos)
	{
		ps->_array[i + 1] = ps->_array[i];
		i--;
	}
	ps->_array[pos] = data;
	ps->_size++;
}

10.删除顺序表中pos位置元素
同样注意：pos位置应该按照数组角度来看，不是客观上的第pos个位置

// 删除顺序表pos位置元素 
void SeqListErase(PSeqList ps, int pos);

//SeqList.c 定义
// 删除顺序表pos位置元素 
void SeqListErase(PSeqList ps, int pos)
{
	int i = 0;
	//参数检验
	assert(ps);
	if (pos<0 || pos>MAX_SIZE)
	{
		printf("pos位置不合法！！！\n");
		return;
	}
	if (0 == ps->_size)
	{
		printf("表已空！！！\n");
		return;
	}
	//所有参数已检验合格
	i = pos;
	while (i<ps->_size)
	{
		ps->_array[i] = ps->_array[i + 1];
		i++;
	}
	ps->_size--;
}

11.测试顺序表的指定位置插入与删除

//测试顺序表指定位置的插入与删除
void TestSeqListInsert_Erase()
{
	SeqList seq;//定义顺序表
	SeqListInit(&seq); //初始化顺序表
	SeqListPushBack(&seq, 0);//给顺序表尾插元素
	SeqListPushBack(&seq, 1);
	SeqListPushBack(&seq, 3);
	PrintSeqList(&seq);//打印顺序表

	SeqListInsert(&seq, 2, 2);//在顺序表的第pos+1个位置插入元素2
	PrintSeqList(&seq);//打印顺序表

	SeqListErase(&seq, 3);//删除顺序表中第pos+1个位置的元素
	PrintSeqList(&seq);//打印顺序表
}
//主函数
int main()
{
	TestSeqListInsert_Erase();
	system("pause");
	return 0;
}

测试结果：
顺序表指定位置插入和删除结果
12.在顺序表中查找data元素的第一次出现

//SeqList.h 声明
// 在顺序表中查找值为data的元素，找到返回该元素在顺序表中的位置，否则返回-1 
int SeqListFind(PSeqList ps, DataType data);

//SeqList.c 定义
// 在顺序表中查找值为data的元素，找到返回该元素在顺序表中的位置，否则返回-1 
int SeqListFind(PSeqList ps, DataType data)
{
	int i = 0;
	//参数检验
	assert(ps);
	//遍历顺序表，寻找data的第一次出现
	while (i < ps->_size)
	{
		if (ps->_array[i] == data)
		{
		//data第一次出现，返回它的下标
			return i;
		}
		i++;
	}
	//顺序表中没有data元素，返回-1
	return -1;
}

13.删除顺序表中第一个data元素

//SeqList.h 声明
// 移除顺序表中第一个值为data的元素 
void Remove(PSeqList ps, DataType data);

//SeqList.c 定义
// 移除顺序表中第一个值为data的元素 
void Remove(PSeqList ps, DataType data)
{
	int ret = 0;
	//参数检验
	assert(ps);
	//首先在顺序表中查找data元素，SeqListFind函数是用来在顺序表中查找值为data的元素，找到返回该元素在顺序表中的位置，否则返回-1
	//SeqListFind函数的函数声明及定义在12
	ret = SeqListFind(ps, data);
	if (-1 == ret)
	{
	//下标为-1,没找到data元素
		printf("顺序表中无该元素！！！\n");
		return;
	}
	else
	{
	//顺序表中有data元素，且第一个data元素下标为ret,调用SeqListErase函数删除下标为ret元素，即删除data元素
	//SeqListErase函数在10中定义
		SeqListErase(ps, ret);
		printf("顺序表中第一个元素为%d的元素已删除\n", data);
	}
}

14.删除顺序表中所有值为data的元素

//SeqList.h 声明
// 移除顺序表中所有值为data的元素 
void RemoveAll(PSeqList ps, DataType data);

// 移除顺序表中所有值为data的元素 
void RemoveAll(PSeqList ps, DataType data)
{
	int i = 0;//i当作循环变量，遍历顺序表
	int count = 0;//统计在顺序表中删了多少个值data的元素个数
	int index = 0;//辅助删除的变量
	//参数检验
	assert(ps);
	while (i < ps->_size)
	{
		if (data == ps->_array[i])
		{
		//遇到值为data的元素，跳过，并让计数器+1
			i++;
			count++;
			continue;
		}
		ps->_array[index] = ps->_array[i];//依次赋值
		i++;
		index++;
	}
	//最后让用来统计顺序表中元素个数的size-count,得到现在顺序表中所有元素个数
	ps->_size -= count;
	printf("顺序表中所有值为%d的元素已删除\n", data);

}

15.测试顺序表的查找函数、删除第一个值为data元素函数以及删除所有值为data的元素

//测试函数 test.c
void TestSeqListRemove_RemoveAll()
{
	SeqList seq;//定义顺序表
	SeqListInit(&seq);//初始化顺序表
	SeqListPushBack(&seq, 0); //给顺序表尾插元素
	SeqListPushBack(&seq, 1);
	SeqListPushBack(&seq, 2);
	SeqListPushBack(&seq, 3);
	SeqListPushBack(&seq, 2);
	SeqListPushBack(&seq, 2);
	SeqListPushBack(&seq, 3);
	PrintSeqList(&seq);//打印顺序表

	Remove(&seq, 2);//删除顺序表中第一个值为2的元素
	PrintSeqList(&seq);//打印顺序表

	RemoveAll(&seq, 2);//删除顺序表中所有值为2的元素
	PrintSeqList(&seq);//打印顺序表
}
//主函数
int main()
{
	TestSeqListRemove_RemoveAll();
	system("pause");
	return 0;
}

测试结果：
删除元素（第一次，所有）

到此几乎顺序表的基本操作就没有了。

本人能力有限，如有错误欢迎指正，谢谢大家！

zhangbaqing
关注
专栏目录
静态顺序表
小Z的博客
12-05 385
顺序表 顺序表 ：用一段地址连续的存储单元一次存储数据元素的线性结构 连续的地址空间 ，一般情况下采用数组，但是数组有静态数组和动态数组，所以顺序表分为：静态顺序表和动态顺序表 静态顺序表 1. 结构： #define MAX_SiZE 10 typedef int DataType;typedef struct SeqList { DataType array[MA
静态顺序表概念及代码
KMP查找法
01-31 214
一、顺序表的概念 按照线形表的逻辑顺序，依次存储到一块连续的存储空间中。 二、特点 1、优点是可以按照下标进行访问，与数组相似，比较方便。 2、缺点是如果需要插入或删除元素，则需要移动大量的元素。 三、代码展示 1、头文件 #include<stdio.h> #include<assert.h> #include<string.h> 2、顺序表的声明 #def...
静态顺序表的定义
qq_47745029的博客
06-30 205
定义基础数据表
数据结构c++代码（顺序表的代码，包括静态顺序表和动态顺序表）
07-13
顺序表是一种线性结构，它的所有元素在内存中连续存放，可以分为静态顺序表和动态顺序表。静态顺序表通常是在编译时就预分配好固定大小的数组，而动态顺序表则可以根据需要动态地调整其容量。 静态顺序表的优点在于...
C++实现基于静态数组的顺序表
08-19
本文详细介绍了基于静态数组的顺序表的实现，包括基本概念、基本操作和实现代码。顺序表是一种常见的数据结构，广泛应用于各种领域。通过学习顺序表的实现，可以更好地理解数据结构的基本概念和编程技术。
C语言实现动态顺序表的实现代码
08-29
C语言实现动态顺序表的实现代码 本文主要介绍了C语言实现动态顺序表的实现代码，动态顺序表是指在内存中开辟一块...通过本文的介绍，读者可以更好地理解顺序表的基本概念和实现方式，并可以根据需要实现自己的顺序表。
数据结构静态顺序表.zip
02-03
在这个“数据结构静态顺序表.zip”压缩包中，包含的是作者用C语言实现的静态顺序表源代码。 首先，让我们深入理解静态顺序表的概念。静态顺序表是一种固定大小的数组，其长度在创建时就已经确定，且在表的整个生命...
动态顺序表
wangneng691811457的博客
09-20 221
// 动态顺序表   #pragma once   #define __SEQ_LIST__   #ifdef __SEQ_LIST__       typedef int DataType;       #define DEFAULT_CAPICITY 3  
C++静态数组顺序表详解与操作实现
本文将深入探讨如何在C++中使用基于静态数组实现顺序表（Sequential List）。顺序表是一种线性数据结构，其中元素存储在连续的内存空间中，支持高效的随机访问。本文的核心知识点包括顺序表在C++中的基础操作： 1. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值