静态顺序表的实现创建、查找、删除

最新推荐文章于 2022-09-17 15:48:09 发布
最新推荐文章于 2022-09-17 15:48:09 发布
阅读量737 收藏
点赞数 1
分类专栏： 数据结构与算法
本文为博主原创文章，转载需标明出处。
本文链接：https://blog.csdn.net/My_heart_/article/details/51465325
版权

顺序表概述：用顺序存储方法存储的线性表

实现的功能：1、建立顺序表并初始化

                     2、在顺序表尾部插入元素

                     3、删除尾部元素

                            4、从前往后输出

                            5、在顺序表头插入元素

                            6、在任意位置插入元素

                            7、删除顺序表任意位置元素

                           8、删除给定数据为元素

                           9、删除所有为给定数的元素

                          10、排序（冒泡、选择排序）

////****静态版顺序表****/

SeqList.h   

<span style="font-size:18px;">#ifndef  SEQLIST_H
#define  SEQLIST_H
#define  MAX_NUM 5
#include<stdio.h>
#include<string.h>
#include<assert.h>
typedef int DataType;
typedef  unsigned int  size_t;
typedef struct SeqList
{
	DataType arr[MAX_NUM];   //数组
	size_t  sz;             //已经放有元素的总个数
}SeqList,*PSeqList;


void InitSeqList(PSeqList pSeqList);//初始化

void PushBack(PSeqList pSeqlist, DataType data);//尾插
void PopBack(PSeqList pSeqList);  //删除尾元素

void PrintSeqList(SeqList SeqList);//从前往后输出

void PushFront(PSeqList pSeqList, DataType data);//头插
void PopFront(PSeqList pSeqList);//头删
void Insert(PSeqList pSeqList, int pos, DataType data);//任意位置插入

int  Find(PSeqList pSeqList, DataType data);//查找元素

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

//移除data数据
void Remove(PSeqList pSeqList,DataType  data);

void RemoveALL(PSeqList pSeqList,DataType data );//去除所有的data元素

void BUbbleSort(PSeqList pSeqList);  //冒泡排序
void SelectSort(PSeqList pSeqList);//选择排序

#endif </span>
SeqList.c 

#include"SeqList.h"

//初始化
void InitSeqList(PSeqList pSeqList)
{
	assert(NULL != pSeqList);
	pSeqList->sz = 0;
	memset(pSeqList->arr, 0, MAX_NUM*sizeof(DataType));
}

void PrintSeqList(SeqList SeqList)//从前往后输出
{
	size_t iIdx = 0;
	/*assert(NULL != SeqList);*/
	for (; iIdx < SeqList.sz; iIdx++)
	{
		printf("%d", SeqList.arr[iIdx]);
	}
	printf("\n");
}

void PushBack(PSeqList pSeqList, DataType data)//尾插
{
	assert(pSeqList);
	if ((pSeqList->sz) >= MAX_NUM)  //是否满了
	{
		return;
	}
	pSeqList->arr[pSeqList->sz] = data;
	pSeqList->sz++;
}


void PopBack(PSeqList pSeqList)//删除尾元素
{
	assert(NULL != pSeqList);
	if ((pSeqList->sz) <= 0)
	{
		return;
	}
	pSeqList->sz--;
}
void PushFront(PSeqList pSeqList, DataType data)//从开头插入一个数
{
	int iIdx = 0;
	assert(NULL!= pSeqList);
	if (pSeqList->sz >= MAX_NUM)//检查是否满了
	{
		return;
	}
	for (iIdx = (pSeqList->sz) - 1; iIdx >= 0; iIdx--)
	{
		pSeqList->arr[iIdx + 1] = pSeqList->arr[iIdx];
	}
	pSeqList->arr[0] = data;
	pSeqList->sz++;

}
void PopFront(PSeqList pSeqList)//删除头元素
{
	size_t iIdx = 0;
	assert(pSeqList);
	if (pSeqList->sz <= 0)
	{
		return;
	}
	for (iIdx = 0; iIdx < pSeqList->sz-1; iIdx++)//注意这里的sz-1防止越界
	{
		pSeqList->arr[iIdx] = pSeqList->arr[iIdx + 1];
	}
	pSeqList->sz--;
}

void Insert(PSeqList pSeqList, int pos, DataType data)//任意位置插入
{
	assert(NULL != pSeqList);
	if ((pSeqList->sz < MAX_NUM)&&(pos >= 0) && (pos < pSeqList->sz))//对元素总数检测，位置的检测
	{
		int iIdx = pSeqList->sz;
		for (; iIdx >pos ; iIdx--)
		{
			pSeqList->arr[iIdx] = pSeqList->arr[iIdx - 1];
		}
		pSeqList->arr[pos] = data;
		pSeqList->sz++;
	}
}

int  Find(PSeqList pSeqList, DataType data)
{
	int iIdx = 0;
	assert(NULL != pSeqList);
	for (iIdx = 0; iIdx < pSeqList; iIdx++)
	{
		if (data == pSeqList->arr[iIdx])
		{
			return iIdx;
		}
	}
	return -1;
}

//删除顺序表pos位置元素
void Erase(PSeqList pSeqList, int pos)
{
	assert(NULL != pSeqList);
	if ((pos >= 0) && (pos < pSeqList->sz))
	{
		int iIdx = pos;
		for (; iIdx < pSeqList->sz-1; iIdx++)
		{
			pSeqList->arr[iIdx] = pSeqList->arr[iIdx + 1];
		}
		pSeqList->sz--;
	}	
}
//移除data数据
void Remove(PSeqList pSeqList, DataType  data)
{
	int ret = 0;
	assert(NULL != pSeqList);
	ret = Find(pSeqList, data);
	Erase(pSeqList, ret);
}

void RemoveALL(PSeqList pSeqList, DataType data)
{
	int iCount=0 ;
	int iIdx = 0;
	assert(NULL != pSeqList);
	if (pSeqList->sz <= 0)
	{
		return;
	}
	for (; iIdx < pSeqList->sz; iIdx++)
	{
		if (data == pSeqList->arr[iIdx])
		{
			++iCount;
		}
		else
		{
			pSeqList->arr[iIdx - iCount] = pSeqList->arr[iIdx];
		}		
	}
	pSeqList->sz -= iCount;
}
void BUbbleSort(PSeqList pSeqList) //冒泡排序
{
	int iIdx = 0;
	int jIdx = 0;
	int flag = 0;
	assert(NULL!=pSeqList);
	if (pSeqList->sz == 0)
	{
		return;
	}
	for (iIdx = 0; iIdx < pSeqList->sz - 1; iIdx++)
	{
		flag = 0;
		for (jIdx = 0; jIdx < (pSeqList->sz - 1) - iIdx; jIdx++)
		{
			if (pSeqList->arr[jIdx] > pSeqList->arr[jIdx+1])//小到大
			{
				DataType temp = pSeqList->arr[jIdx+1];
				pSeqList->arr[jIdx+1] = pSeqList->arr[jIdx];
				pSeqList->arr[jIdx] = temp;
				flag = 1;
			}
		}
		if (flag != 1)
		{
			return;
		}
	}
	return;
}

void SelectSort(PSeqList pSeqList)//选择排序
{
	int iIdx = 0;
	int jIdx = 0;
	int min = 0;   
	assert(NULL!=pSeqList);
	for (iIdx = 0; iIdx < pSeqList->sz - 1; iIdx++)
	{
		min = iIdx;
		for (jIdx = iIdx; jIdx < (pSeqList->sz - 1); jIdx++)
		{
			if (pSeqList->arr[min] > pSeqList->arr[jIdx])  //从小到大
			{
				min = jIdx;
			}
		}
		//每次找到比arr[min]还小的数就交换！
		if (min != iIdx)
		{
			DataType temp = pSeqList->arr[iIdx];
			pSeqList->arr[iIdx] = pSeqList->arr[min];
			pSeqList->arr[min] = temp;
		}
	}
}

>>>>>为方便各位和我一样正”在路上“学习的同学，我也把测试函数也放在下面，方便大家检验本人的程序，同时测试函数里面的诸多代码都是重复性的，所以就留下来，免得大家做一些重复性的工作<<<<<

test.c


#include "SeqList.h"
void Test1()
{
	SeqList seqList;
	InitSeqList(&seqList);//地址传递
	PushBack(&seqList, 1);
	PushBack(&seqList, 2);
	PushBack(&seqList, 3);
	PushBack(&seqList, 4);
	PrintSeqList(seqList);
}
void test2()
{
	SeqList seqList;
	InitSeqList(&seqList);//地址传递
	PushBack(&seqList, 1);
	PushBack(&seqList, 2);
	PushBack(&seqList, 3);
	PushBack(&seqList, 4);
	PrintSeqList(seqList);
	
	PopBack(&seqList);
	PrintSeqList(seqList);
	PopBack(&seqList);
	PrintSeqList(seqList);
	PopBack(&seqList);
	PrintSeqList(seqList);
	PopBack(&seqList);
	PrintSeqList(seqList);
}



void test3()
{
	SeqList seqList;
	InitSeqList(&seqList);//地址传递
	PushFront(&seqList, 1);
	PushFront(&seqList, 2);
	PushFront(&seqList, 3);
	PushFront(&seqList, 4);
	PrintSeqList(seqList);

	PopFront(&seqList);
	PrintSeqList(seqList);
	PopFront(&seqList);
	PrintSeqList(seqList);
	PopFront(&seqList);
	PrintSeqList(seqList);
	PopFront(&seqList);
	PrintSeqList(seqList);
}
void test4()
{
	SeqList seqList;
	int ret = 0;
	InitSeqList(&seqList);//地址传递
	PushFront(&seqList, 1);
	PushFront(&seqList, 2);
	PushFront(&seqList, 3);
	PushFront(&seqList, 4);
	PrintSeqList(seqList);

	Insert(&seqList,0,55);
	PrintSeqList(seqList);
	ret = Find(&seqList, 55);
	printf("%d ", ret);
	Erase(&seqList, 0);
	PrintSeqList(seqList);
}

void test5()
{
	SeqList seqList;
	InitSeqList(&seqList);//地址传递
	PushBack(&seqList, 1);
	PushBack(&seqList, 2);
	PushBack(&seqList, 2);
	PushBack(&seqList, 3);
	PushBack(&seqList, 3);
	PrintSeqList(seqList);

	RemoveALL(&seqList, 3);
	PrintSeqList(seqList);
}
test6()
{
	SeqList seqList;
	InitSeqList(&seqList);//地址传递
	PushBack(&seqList, 4);
	PushBack(&seqList, 3);
	PushBack(&seqList, 2);
	PushBack(&seqList, 1);
	PushBack(&seqList, 5);
	PrintSeqList(seqList);

	SelectSort(&seqList);
	PrintSeqList(seqList);
}
int main()
{
	/*Test1();*/
	//test2();
	/*test3();*/
	//test4();
	/*test5();*/
	test6();
	return 0;
}


这里对于顺序表的总长度是直接给定的，这样就存在一些限制。后面我会对其改进，实现动态的顺序表！

大笑


CodingStart
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
创建一个静态的顺序表存放整数
04-17
创建一个静态的顺序表存放整数。大小为10.完成以下的操作输入6个整数，1.打 印出顺序表中的内容，并显示表中剩余的空间个数。在顺序表中的第3个位置插入元素O.2.打印出顺序表中的内容，并显示表中剩余的空间个数。再试图向表中第11个位置插入整数0,3.程序提示超出范围。4.删除表中第6个元素，打印出顺序表中的内容，并显示表中剩余的空间个数。 二：编写一程序，动态地创建一个顺序表。要求顺序表初始长度为20,向顺序表中输 入15个整数，并打印出来: 再删除顺序表中的第5个元素。打印出删除后的结果。
顺序表的静态建立
weixin_34072458的博客
12-24 128
1 #include<stdio.h> 2 #define MaxSize 100 3 typedef int Elemtype; 4 typedef struct{ 5 Elemtype data[MaxSize]; 6 int length; 7 }SqList; 8 9 /*插入元素操作*/ 10 bool ListIns...
顺序表的静态创建
junfuyou的博客
08-04 273
#include <stdio.h> #define MaxSize 10 typedef struct { int data[MaxSize]; //静态初始化存放数据 int length; //元素的个数 }SeqList; //初始化 void InitList(SeqList *L) { for (int i = 0; i < MaxSize; i++) { L->data[i] = 0; }
数据结构：静态查找表
weixin_30784945的博客
11-16 136
　数据结构：静态查找表（C语言版）　 1.写在前面 　　►从查找说起： 　　　　在英汉字典中查找某个英文单词的中文解释；在新华字典中查找某个汉字的读音、含义；在对数表、平方根表中查找某个数的对数、平方根；邮递员送信件要按收件人的地址确定位置等等。　　　　从计算机、计算机网络中查找特定的信息，就需要在计算机中存储包含该特定信息的表。查找是许多程序中最消耗时间的一部分。因而，一个好的查找方法会大...
C语言顺序表的静态建立
m0_51894865的博客
09-17 457
2. 除最后一个元素以外，每个元素都有一个后继；1. 除第一个元素以外，每个元素都有一个前驱；定义：n个相同数据元素组成的有限的序列；3. 一对一的关系；
C++实现基于静态数组的顺序表
12-17
静态数组的使用使得在创建顺序表时可以预分配空间，但同时也限制了动态扩展的能力，当元素数量超过最大值时，需要重新分配更大的数组，这在某些场景下可能不够灵活。在实际应用中，根据需求可以选择动态数组（如C++...
C语言实现动态顺序表的实现代码
08-29
除了插入操作外，顺序表还支持其他操作，如删除、查找、排序等。这些操作可以通过对顺序表的结构体进行修改和访问来实现。 四、结论 本文主要介绍了C语言实现动态顺序表的实现代码，动态顺序表是指在内存中开辟一...
数据结构静态顺序表.zip
02-03
静态顺序表是一种固定大小的数组，其长度在创建时就已经确定，且在表的整个生命周期内不会改变。这与动态数组（如C++中的`std::vector`或Java中的ArrayList）不同，后者可以在运行时调整大小。静态顺序表适用于那些...
数据结构c++代码（顺序表的代码，包括静态顺序表和动态顺序表）
07-13
静态顺序表的优点在于空间利用率高，因为其大小在创建时已经确定，不会因为空间分配和释放而产生额外开销。然而，它的缺点是当预设的容量不足时，无法直接添加新元素，需要重新创建一个更大的数组并转移已有元素，这...
数据结构实验报告-静态查找表
04-03
静态查找表，顾名思义，是指在创建后不再进行动态添加或删除元素的查找表。它通常以数组的形式存在，因为数组提供了直接通过索引访问元素的能力，使得查找效率较高。静态查找表的主要操作包括查找、插入和删除，但...
静态查找表。实现有序表的折半查找算法
05-22
静态查找表。实现有序表的折半查找算法 静态查找表。实现有序表的折半查找算法 静态查找表。实现有序表的折半查找算法静态查找表。实现有序表的折半查找算法
cpp代码-顺序表的静态实现
07-16
在静态顺序表中，我们通常会预先定义一个固定大小的数组，然后在该数组中插入、删除和查找元素。 在`main.cpp`文件中，可能会包含一个类（如`SequentialList`），这个类将封装数组操作。类的构造函数可能初始化数组...
数据结构 静态查找表
11-19
在这个压缩包文件中，"静态查找表"很可能是包含了一个C语言实现的静态查找表的源代码或者示例程序。这个程序可能包含了上述的实现细节，如结构体定义、数组操作以及查找、插入和删除的函数。通过阅读和理解这个代码...
顺序表的相关操作实现
08-07
本文展示顺序表的一些基本操作，包括静态顺序表和动态顺序表的初始化，按位置查找，按值查找，插入操作，删除操作等，用作数据结构系统学习的资料，比较完整
顺序表的基本操作.zip
最新发布
03-16
这个压缩包“顺序表的基本操作.zip”可能包含了关于顺序表的各种基本操作的详细资料，包括创建、插入、删除、查找以及对顺序表的其他常见操作。让我们深入探讨一下顺序表及其基本操作。 顺序表是线性数据结构的一种...
静态顺序表
小Z的博客
12-05 365
顺序表 顺序表 ：用一段地址连续的存储单元一次存储数据元素的线性结构 连续的地址空间 ，一般情况下采用数组，但是数组有静态数组和动态数组，所以顺序表分为：静态顺序表和动态顺序表 静态顺序表 1. 结构： #define MAX_SiZE 10 typedef int DataType;typedef struct SeqList { DataType array[MA
静态顺序表的实现
追梦的小蚂蚁
04-14 218
Seqlist.h #define _CRT_SECURE_NO_WARNINGS 1 #pragma once #include&lt;stdio.h&gt; #include&lt;assert.h&gt; #include&lt;stdlib.h&gt; #include&lt;malloc.h&gt; #define MAX_SIZE 10 typedef int DataType;...
静态查找表
挺拔的劲松（sdp）的专栏
09-13 4176
【问题描述】静态查找表可以有不同的表示方法，在不同的表示方法中，实现查找操作的方法也不同。对静态查找表可以用顺序表或线性链表进行表示，也可组织成有序的顺序表，或者是索引顺序表，相应的查找方法可采用顺序查找方法、折半查找方法和索引顺序查找的方法。设计一个有关静态查找表的建立、查找等基本操作的演示程序，并计算和分析查找成功时的平均查找长度。【数据描述】静态查找表的抽象数据类型定义：ADT Static
数据结构：顺序表的静态和动态创建
weixin_51227472的博客
07-20 464
最近在看数据结构，今天刚看完顺序表，做个记录。 1）顺序表的静态初始化 #include <stdio.h> #include <stdlib.h> #define N 6 typedef struct{ int a[N];//N是常数，顺序表最多可存10个，固定了所以是静态分配 int length;//顺序表现在的长度 }list;//顺序表类型叫list，这个顺序表存的是整数（你还可以存别的的类型数据，只需要把int改掉就ok了） void mylist(list *l){
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值