顺序表的基本操作(C语言实现，简单易懂！)

最新推荐文章于 2023-12-01 16:15:36 发布
最新推荐文章于 2023-12-01 16:15:36 发布
阅读量2.4w 收藏 720
点赞数 186
分类专栏： 笔记 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53392188/article/details/113064666
版权

你们的每个赞都能让我开心好几天✿✿ヽ(°▽°)ノ✿

目录

这篇文章看的人还挺多，我顺便写了顺序栈的，不过只发了个总代码
顺序栈

一、学习内容

1、 创建顺序表
2、 按数值查找
3、 按位置查找
4、 插一个数值
5、 删一个数值
6、 销毁顺序表
7、 求前驱算法
8、 求后继算法

二、准备工作

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#define LIST_MaxSize 1000//该顺序表最大的数量

typedef int ElemType;//给int定义一个别名

typedef enum Status{
	success,fail,NoCreate//success表示成功，fail表示失败，NoCreate表示顺序表还未创建
}Status;
Status status;//定义status这个枚举变量,status是表明顺序表基本操作的状态``
  1. 为什么要给int定义一个别名呢？因为顺序表的数据类型不一定是int，有可能是double等其他类型，采用宏定义的好处就是：若需要改变顺序表的数据类型，只需要在宏定义处改变int为其他的数据类型即可（理论上确实如此，但由于我的代码后面用到了随机数产生顺序表的元素，直接把宏定义中的int改double并不可行）。
  2. 为什么要用枚举呢？实际上就是表明顺序表基本操作的一个状态。用bool逻辑值也可以，或者等等，只要能表示出顺序表的基本操作的状态即可。

三、顺序表的结构

typedef struct Sqlist
{
	int *elem;//元素 
	int length;//元素个数，即长度 
}Sqlist;

四、顺序表的基本操作

1. 创建顺序表

Status List_Init(Sqlist *L)
{

	int i;
	L->elem=(ElemType *)malloc(LIST_MaxSize*sizeof(ElemType));//要开辟多余的空间是为了后面的插入算法 
	/*我这里采用的是取0~100的随机数，方便检测程序的对错，也可以手动输入*/ 
	srand(time(0)); //时间取种
	for(i=0;i<L->length;i++)
	{
		L->elem[i]=rand()%101;
	}
	if(L->elem)//若成功申请内存
	{
		for(i=0;i<L->length;i++)
		{
			printf("%d\n",L->elem[i]);
		}
		return success;
	}
	return fail;
}

2. 按数值查找

Status List_Locate(Sqlist *L,ElemType elem,int *pos,int *count)//count是用于记录相同数值出现的次数
{
	int len=L->length,i=0,flag=0;
	if(len==0)return NoCreate; 
	while(i<len)
	{
		if(L->elem[i]==elem)
		{
			if(*count==0)flag=i;
			*count=(*count)+1;	
		}
		i++;
	}
	if(*count!=0)
	{
		*pos=flag;
		return success;
	}
	return fail;
}

3. 按位置查找

Status List_Retrieve(Sqlist *L,ElemType *elem,int *pos)
{
	if(0<=*pos&&*pos<=L->length)
	{
		*elem=L->elem[*pos-1];
		return success;
	}
	return fail; 
}

4. 插入一个数值

Status List_Insert(Sqlist *L,ElemType elem,int pos)//第pos个元素换为elem 
{
	int i;
	for(i=L->length-1;i>=pos-1;i--)
	{
		L->elem[i+1]=L->elem[i];//数据元素后移一位	
	}
	L->elem[pos-1]=elem;
	L->length++;
	return success;
}

5. 删除一个数值

Status List_Remove(Sqlist *L,int pos)
{
	int i;
	for(i=pos-1;i<L->length-1;i++)
	{
		L->elem[i]=L->elem[i+1];	
	}
	L->length--;
	return success;	
}

6. 销毁顺序表

Status List_Destroy(Sqlist *L)
{
	if(status==NoCreate) 
	{
		printf("您还没有创建顺序表！请先创建顺序表\n");
	}
	if(L->elem)
	{
		free(L->elem);
		L->elem=NULL;
		L->length;
		return NoCreate; 
	}	
}

7. 求前驱算法

Status List_Prior(Sqlist *L,int pos)
{
	ElemType elem;
	if(1<pos&&pos<=L->length)
	{
		elem=L->elem[pos-1-1];
		printf("前驱数值为：%d\n",elem);
		return success;
	}
	return fail;
}

8. 求后继算法

Status List_Next(Sqlist *L,int pos)
{
	ElemType elem;
	if(1<pos&&pos<=L->length-1)
	{
		elem=L->elem[pos-1-1];
		printf("后继数值为：%d\n",elem);
		return success;
	}
	return fail;
}

五、总代码

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#define LIST_MaxSize 1000
//顺序表的最大元素个数 
/*可以自行修改宏定义*/ 
typedef int ElemType;

typedef enum Status{
	success,fail,NoCreate
}Status;

Status status;//定义status这个枚举变量,status是表明顺序表基本操作的状态 
typedef struct Sqlist
{
	int *elem;//元素 
	int length;//元素个数，即长度 
}Sqlist; 

/*1、创建顺序表*/
Status List_Init(Sqlist *L)
{

	int i;
	L->elem=(ElemType *)malloc(LIST_MaxSize*sizeof(ElemType));//要开辟多余的空间是为了后面的插入 
	/*我这里采用的是取0~100的随机数，方便检测程序的对错*/ 
	srand(time(0)); 
	for(i=0;i<L->length;i++)
	{
		L->elem[i]=rand()%101;
	}
	if(L->elem)
	{
		for(i=0;i<L->length;i++)
		{
			printf("%d\n",L->elem[i]);
		}
		return success;
	}
	return fail;
}

/*2、按按数值查找算法(加强一下，可以找到出现多次的数值)*/
Status List_Locate(Sqlist *L,ElemType elem,int *pos,int *count)
{
	int len=L->length,i=0,flag=0;
	if(len==0)return NoCreate; 
	while(i<len)
	{
		if(L->elem[i]==elem)
		{
			if(*count==0)flag=i;
			*count=(*count)+1;	
		}
		i++;
	}
	if(*count!=0)
	{
		*pos=flag;
		return success;
	}
	return fail;
}

/*3、按位置查找*/
Status List_Retrieve(Sqlist *L,ElemType *elem,int *pos)
{
	if(0<=*pos&&*pos<=L->length)
	{
		*elem=L->elem[*pos-1];
		return success;
	}
	return fail; 
}

/*4、插入一个数值*/
Status List_Insert(Sqlist *L,ElemType elem,int pos)//第pos个元素换为elem 
{
	int i;
	for(i=L->length-1;i>=pos-1;i--)
	{
		L->elem[i+1]=L->elem[i];//数据元素后移一位	
	}
	L->elem[pos-1]=elem;
	L->length++;
	return success;
} 

/*5、删除一个数值*/ 
Status List_Remove(Sqlist *L,int pos)
{
	int i;
	for(i=pos-1;i<L->length-1;i++)
	{
		L->elem[i]=L->elem[i+1];	
	}
	L->length--;
	return success;	
} 

/*6、销毁顺序表*/
Status List_Destroy(Sqlist *L)
{
	if(status==NoCreate) 
	{
		printf("您还没有创建顺序表！请先创建顺序表\n");
	}
	if(L->elem)
	{
		free(L->elem);//释放申请的空间
		L->elem=NULL;//置为空指针，保证使用安全 
		L->length=0;//长度变为0
		return NoCreate; 
	}	
} 

/*7、求前驱算法*/ 
Status List_Prior(Sqlist *L,int pos)
{
	ElemType elem;
	if(1<pos&&pos<=L->length)
	{
		elem=L->elem[pos-1-1];
		printf("前驱数值为：%d\n",elem);
		return success;
	}
	return fail;
}

/*8、求后继算法*/
Status List_Next(Sqlist *L,int pos)
{
	ElemType elem;
	if(1<pos&&pos<=L->length-1)
	{
		elem=L->elem[pos-1-1];
		printf("后继数值为：%d\n",elem);
		return success;
	}
	return fail;
}

int main()
{
	printf("------------------提示：该顺序表最大能存1000个元素------------------\n\n"); 
	int i,pos,count=0,n;
	status=NoCreate;
	Sqlist L;
	L.length=0;//空表，此时还未创建顺序表 
	ElemType elem;
	printf("****************1、 创建顺序表\t"); 
	printf("2、 按数值查找****************\n");
	printf("****************3、 按位置查找\t"); 
	printf("4、 插一个数值****************\n");
	printf("****************5、 删一个数值\t"); 
	printf("6、 销毁顺序表****************\n"); 
	printf("****************7、 求前驱算法\t");
	printf("8、 求后继算法****************\n");
	printf("****************9、 菜单的选项\t");
	printf("10、展示顺序表****************\n"); 
	printf("****************11、顺序表个数\t");
	printf("12、结束该程序****************\n"); 
	while(1)
	{
		scanf("%d",&n);
		switch(n)
		{
			case 1: {
						printf("您想初始化这个顺序表多少个元素呢？(随机数):");
						scanf("%d",&L.length);
						if(L.length>LIST_MaxSize)
						{
							printf("元素个数超过了最大值！\n");
							break;
						}
						status=List_Init(&L);
						if(status==success)	
						{
							printf("顺序表初始化成功！\n");
						}	
						if(status==fail)	printf("顺序表初始化失败！\n");	
						break;
					}
					
			case 2: {
						if(status==NoCreate)printf("您还没有创建顺序表！请先创建顺序表\n");
						else
						{
							printf("请输入你想要查找的数值:"); 
							scanf("%d",&elem);
							status=List_Locate(&L,elem,&pos,&count);
							if(status==success)
							{
								printf("找到了！第一次出现在第%d个位置，共出现了%d次\n",pos+1,count);
		
							}
							else printf("您输入的数值不在顺序表之中！\n");
							
						} 
						break;	
					} 
					
			case 3: {
						if(status==NoCreate)printf("您还没有创建顺序表！请先创建顺序表\n");
						else
						{
							printf("按位置查找，你查的数字序号为：");
							scanf("%d",&pos);
							status=List_Retrieve(&L,&elem,&pos);
							if(status==success)
							{
								printf("该数值为：%d\n",elem);
							}
							else printf("您输入的序号越界了！\n"); 	
						}
						break;
					}
					
			case 4: {
						if(status==NoCreate)printf("您还没有创建顺序表！请先创建顺序表\n");
						else
						{
							printf("请输入您想插入的元素位置：");
							scanf("%d",&pos);
							if(pos>L.length||L.length==LIST_MaxSize)
							{
								printf("您插入的元素超出了您创建顺序表的范围！\n");
								break;
							}
							printf("请输入您想插入的元素数值：");
							scanf("%d",&elem); 
							status=List_Insert(&L,elem,pos);
							if(status==success)	printf("插入成功！\n");
							else printf("插入不成功！\n");	
						}
						break;
					} 
					
			case 5: {	
						if(status==NoCreate)printf("您还没有创建顺序表！请先创建顺序表\n");
						else
						{
							printf("请输入您想删除的元素位置：");
							scanf("%d",&pos);
							if(pos>L.length||L.length==LIST_MaxSize)
							{
								printf("您删除的元素超出了您创建顺序表的范围！\n");
								break;
							}
							status=List_Remove(&L,pos);
							if(status==success)printf("删除成功！\n"); 
							
						}
						break;
					}
					
			case 6: {
						status=List_Destroy(&L);
						if(status==NoCreate)	printf("销毁成功！\n");
						status=NoCreate;
						break;
					}
					
			case 7: {
						if(status==NoCreate)printf("您还没有创建顺序表！请先创建顺序表\n");
						else
						{
							printf("请输入元素位置：");
							scanf("%d",&pos);
							status=List_Prior(&L,pos);
							if(status==fail)printf("该位置无前驱！\n"); 
						}
						break;
					}
					
			case 8: {
						if(status==NoCreate)printf("您还没有创建顺序表！请先创建顺序表\n");
						else
						{
							status=List_Next(&L,pos);
							if(status==fail)printf("该位置无后继！\n"); 
						}
						break;
					}	
				
			case 9: {	
						printf("--------------------------------------------------------------\n");//分割线 
						printf("****************1、 创建顺序表\t"); 
						printf("2、 按数值查找****************\n");
						printf("****************3、 按位置查找\t"); 
						printf("4、 插一个数值****************\n");
						printf("****************5、 删一个数值\t"); 
						printf("6、 销毁顺序表****************\n"); 
						printf("****************7、 求前驱算法\t");
						printf("8、 求后继算法****************\n");
						printf("****************9、 菜单的选项\t");
						printf("10、展示顺序表****************\n"); 
						printf("****************11、顺序表个数\t");
						printf("12、结束该程序****************\n");  
						printf("--------------------------------------------------------------\n");//分割线 	
						break;
					}
			
			case 10:{
						if(status==NoCreate)printf("您还没有创建顺序表！请先创建顺序表\n");
						else
						{
							printf("-----------------------------------\n");//分割线 
							for(i=0;i<L.length;i++)
							{
								printf("%d\n",L.elem[i]);
							}
							printf("-----------------------------------\n");//分割线 	
						}
						break;
					}
					
			case 11:{
						if(status==NoCreate)printf("您还没有创建顺序表！请先创建顺序表\n");
						else printf("顺序表的元素个数为：%d\n",L.length);
						break;
					} 
			
			case 12:{
						printf("再见，祝您生活幸福愉快！");
						return 0; 
					}
					
			default:{
						printf("请输入1~12内的整数！\n");
						break;
					}
			
		}
		count=0;//用完一次后重置
		pos=0; //用完一次后重置 
	}	
}

主函数的设计由大家自己发挥即可，只要能够表明顺序表的基本操作的一个状态并对该状态作出一个提示信息，都是一个好程序。

我今天第一次做完这个顺序表，可能代码有很多啰嗦的地方，我水平有限，请朋友们谅解！写的不好的地方还请朋友们指出。

最后，如果这篇文章对你有帮助，就点个赞或者评论一下吧,谢谢！

你们的每个赞都能让我开心好几天✿✿ヽ(°▽°)ノ✿

若oo尘
关注
  • 186
    点赞
  • 踩
  • 720
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 21
    评论
专栏目录
[简单易懂]数据结构顺序表——C语言
m0_63816268的博客
03-17 1117
前言💖： ​ 顺序表是线性表的一种，而线性表是n个具有相同特性的数据元素（换种说法，顺序表其实就是数组）的有限序列。线性表是在实际中广泛使用的数据结构，常见的线性表：顺序表，链表，栈，队列，字符串… ​ 线性表在逻辑上是线性结构，也就是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上储存时，通常以数组和链式结构的形式存储。 为什么要学习顺序表？ 1.连续的物理空间，方便下标随机访问（查找访问） 2.支持排序，二分查找 车站🚗： 代码注释 结构体定义 初始化和打印函数 扩容函数 尾插尾
数据结构—顺序表实现(C语言版本)
08-04
顺序表是一种基本的数据结构，它的实现方式在C语言中尤为重要，因为C语言提供了底层内存操作的能力，使得我们能够更直观地理解数据结构的内部工作原理。 顺序表在计算机内存中连续分配空间，每个元素在内存中都有一...
数据结构-顺序表的基本实现（C语言，简单易懂，含全部代码）
阿龙的博客
04-14 4201
【数据结构基础入门】顺序表的概念、结构和接口实现
掌握顺序表：从概念到C语言实现
howard2005的专栏
01-16 2万+
C语言实现顺序表的创建与增删改查操作
顺序表-c语言实现
m0_46343224的博客
11-02 1219
c语言实现的顺序表，通俗易懂，相信你能舒服的看懂，有问题可以私信我。
BFS - C语言链表实现（简单易懂）
Yoru的博客
12-01 927
C语言链表实现BFS，从原理上讲解BFS。 进阶讲解最短路径标记。
[C语言实现]数据结构——顺序表详解
FlashRider的干货分享小窝
03-01 796
C语言实现的比较易懂的数据结构顺序表实现
数据结构——顺序表（Ｃ语言版）
weixin_53811859的博客
03-30 6592
室友一把王者的时间，手把手带你拿捏严奶奶数据结构里面的动态顺序表实现（C语言版），纯手工绘画，保证让初学者的xdm也一目了然，精简易懂
C语言链表详解（通俗易懂）
热门推荐
weixin_61661271的博客
06-05 5万+
线性表是实际中广泛应用的重要数据结构，本文用通俗易懂的方法讲解它。
数据结构-带头双向循环链表的基本实现（C语言，简单易懂，含全部代码）
阿龙的博客
04-26 2216
【数据结构基础入门】带头双向循环链表的概念、结构和接口实现
c语言实现顺序表简单易懂
06-20
本文详细介绍了如何使用C语言实现顺序表，包括了顺序表的创建、清空、判断是否为空或满、元素的替换、插入和删除等基本操作。通过对这些关键代码的理解，初学者可以更好地掌握顺序表这一数据结构的实现原理，为后续...
二叉树的基本操作实现（C语言）.pdf
最新发布
04-24
### 二叉树的基本操作实现（C语言） #### 一、二叉树的定义与结构 二叉树是一种树形数据结构，其中每个节点最多只有两个子节点，分别称为左子节点和右子节点。在计算机科学中，二叉树经常被用来实现二叉查找树和...
线性表顺序存储C语言实现
10-04
在IT领域，数据结构是计算机科学中的核心概念，它研究如何高效地组织和管理数据。线性表是一种基本且常用的数据结构，它是由n（n...在DEV环境下，你可以使用这些函数来创建和操作线性表，并通过EDV顺序表文件进行实践。
顺序查找算法C语言源程序.zip
07-24
下面是一个简单的C语言示例代码片段，展示了顺序查找的实现方式： ```c #include int sequential_search(int arr[], int size, int target) { for (int i = 0; i ; i++) { if (arr[i] == target) { return i; ...
python:@运算符（numpy库中的运算符）
若丶尘的博客
07-17 2万+
前言 我在《python数学实验与建模》这本书中发现了@运算符，这可真是个奇怪的符号！我大量的尝试与查资料后，终于揭开这个@的意义 一、@运算符 1.仅仅支持数组运算 因此，必须用到numpy.array()才能使用这个运算符 2.这是python3.5后的新运算符 它与numpy.dot（）的作用是一样的，矩阵乘法（就是线性代数里学的）！ 举个例子： from numpy import array,dot a=array([[1,2], [1,2]]) b=array([[5,6],
plt.imshow()的基本含义
若丶尘的博客
03-13 9471
plt.imshow()的基本含义
Yolov5:报错UnicodeDecodeError: ‘gbk‘ codec can‘t decode byte 0xad in position 577
若丶尘的博客
07-28 6303
yolov5训练时 UnicodeDecodeError: 'gbk' codec can't decode byte 0xad in position 577 illegal multibyte sequence报错解决
顺序栈的基本操作(C语言实现，简单易懂！)
若丶尘的博客
10-04 4397
一、学习内容 1、 顺序栈初始化 2、 顺序栈的入栈 3、 顺序栈的出栈 4、 顺序栈取栈顶 5、 顺序栈的清空 6、 顺序栈的销毁 7、 顺序栈的判空 8、 顺序栈的判满 9、所有元素出栈 10、求栈元素个数
顺序表基本操作c语言
09-24
顺序表是一种线性结构，可以通过连续的内存空间来存储元素。在C语言中，可以使用数组来实现顺序表。下面是顺序表的基本操作： 1. 初始化顺序表： ```c #define MAX_SIZE 100 // 定义顺序表的最大长度 typedef struct { int data[MAX_SIZE]; // 存储数据的数组 int length; // 当前顺序表的长度 } SeqList; void InitList(SeqList *list) { list->length = 0; // 初始化顺序表的长度为0 } ``` 2. 插入元素： ```c int Insert(SeqList *list, int pos, int element) { if (pos < 1 || pos > list->length + 1) { return 0; // 插入位置非法，返回失败 } if (list->length >= MAX_SIZE) { return -1; // 顺序表已满，返回失败 } for (int i = list->length; i >= pos; i--) { list->data[i] = list->data[i - 1]; // 向后移动元素 } list->data[pos - 1] = element; // 在插入位置插入新元素 list->length++; // 长度加1 return 1; // 插入成功 } ``` 3. 删除元素： ```c int Delete(SeqList *list, int pos) { if (pos < 1 || pos > list->length) { return 0; // 删除位置非法，返回失败 } for (int i = pos; i < list->length; i++) { list->data[i - 1] = list->data[i]; // 向前移动元素 } list->length--; // 长度减1 return 1; // 删除成功 } ``` 4. 查找元素： ```c int Search(SeqList *list, int element) { for (int i = 0; i < list->length; i++) { if (list->data[i] == element) { return i + 1; // 返回元素在顺序表中的位置 } } return 0; // 没有找到元素 } ``` 5. 获取指定位置的元素： ```c int GetElement(SeqList *list, int pos) { if (pos < 1 || pos > list->length) { return -1; // 位置非法，返回错误值 } return list->data[pos - 1]; // 返回指定位置的元素 } ``` 6. 修改指定位置的元素： ```c int Modify(SeqList *list, int pos, int element) { if (pos < 1 || pos > list->length) { return 0; // 位置非法，返回失败 } list->data[pos - 1] = element; // 修改指定位置的元素 return 1; // 修改成功 } ```
评论 21
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

若oo尘

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值