数据结构顺序表，实现增删改查

已于 2023-07-19 21:24:04 修改
阅读量544 收藏 3
点赞数 1
分类专栏： 数据结构 # 数据结构练习（7月17） 文章标签： 数据结构
于 2023-07-17 21:08:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53478812/article/details/131774780
版权

一、顺序表结构体定义

#define MAXSIZE 8            //定义常量MAXSIZE，表示数据元素的最大个数为8
typedef int datatype;        //重定义int类型，分别后期修改顺序表中存储的数据类型
typedef struct
{
	int len;  //顺序表长度
	datatype data[MAXSIZE];  //数据元素
}Seqlist;

二、顺序表创建空间

Seqlist *Request_space(void) //创建空间
{
	Seqlist *list=(Seqlist *)malloc(sizeof(Seqlist));
	if(NULL==list)
		return NULL;
	list->len=0;            //顺序表长度初始化为0
	memset(list->data,0,sizeof(datatype)*MAXSIZE);  //数据元素初始化为0
 	return list;
}

三、实现顺序表增删改查

1. 判断顺序表是否为空

int empty_list(Seqlist *list)  //判断顺序表长度是否为空
{	
	return list->len==0?-1:0;
}

2. 判断顺序表是否为满

int full_list(Seqlist *list)  //判断顺序表长度是否为满
{
	return list->len==MAXSIZE?-1:0;
}

3. 实现输出

void Output(Seqlist *list)  //实现输出
{
	if(NULL==list||empty_list(list))
		return ;
	for(int i=0;i<list->len;i++)
	printf("%d ",list->data[i]);
	puts("");
}

4. 顺序表尾插

int insert_rear(datatype value,Seqlist *list)  //实现尾插
{
	if(NULL==list||full_list(list))
		return -1;
	list->data[list->len]=value;
	list->len++;
	return 0;
}

5. 顺序表尾删

int delete_rear(Seqlist *list)  //实现尾删
{
	if(NULL==list||empty_list(list))
		return -1;
	list->len--;
	return 0;
}

6.  实现任意下标查找

datatype search_by_sub(int sub,Seqlist *list)  //实现任意下标查找
{
	if(NULL==list||empty_list(list)||sub<0||sub>=list->len)
		return -1;
	return list->data[sub];
}

7. 实现任意下标修改

int modify_list(int sub,datatype modify,Seqlist *list)  //实现任意下标修改
{
	if(NULL==list||empty_list(list)||sub<0||sub>=list->len)
		return -1;
	list->data[sub]=modify;
	return 0;
}

8. 实现任意下标插入

int insert_list(int sub,datatype value,Seqlist *list)  //实现任意下标插入
{
	if(NULL==list||full_list(list)||sub<0||sub>list->len)
		return -1;
	for(int i=list->len-1;i>=sub;i--)
	{
		list->data[i+1]=list->data[i];
	}
	list->data[sub]=value;
	list->len++;
	return 0;
}

9. 实现任意下标删除

int delete_list(int sub,Seqlist *list)  //实现任意下标删除
{
	if(NULL==list||empty_list(list)||sub<0||sub>=list->len)
		return -1;
	for(int i=sub;i<list->len-1;i++)
	{
		list->data[i]=list->data[i+1];
	}
	list->len--;
	return 0;
}

10. 实现任意元素修改

int modify_by_element(datatype value,datatype modify,Seqlist *list)  //实现任意元素修改
{
	if(NULL==list||empty_list(list))
		return -1;
	for(int i=0;i<list->len;i++)
	{
		if(list->data[i]==value)
		{
			list->data[i]=modify;
			return 0;
		}
	}
	printf("the value was not found\n");
	return -1;
}

11. 实现任意元素查找

int search_by_element(datatype value,Seqlist *list)  //实现任意元素查找
{
	if(NULL==list||empty_list(list))
		return -1;
	for(int i=0;i<list->len;i++)
	{
		if(value==list->data[i])
			return i;
	}
	printf("the value was not found\n");
	return -1;
}

12. 实现任意元素插入

int insert_by_element(datatype value,datatype modify,Seqlist *list)  //实现任意元素插入
{
	int sub=search_by_element(value,list);
	if(sub==-1)
		return -1;
	insert_list(sub,modify,list);
	return 0;
}

13. 实现任意元素删除

int delete_by_element(datatype value,Seqlist *list)  //实现任意元素删除
{
	int sub=search_by_element(value,list);
	if(sub==-1)
		return -1;
	delete_list(sub,list);
	return 0;
}

14. 实现顺序表去重

int delete_repeat(Seqlist *list)  //实现顺序表去重
{
	if(NULL==list||empty_list(list))
		return -1;
	for(int i=0;i<list->len-1;i++)
	{
		for(int j=i+1;j<list->len;j++)
		{
			if(list->data[i]==list->data[j])
			{
				delete_list(j,list);
				j--;  //防止漏删
			}
		}
	}
	return 0;
}

15. 实现顺序表排序

int sort_list(Seqlist *list)  //实现顺序表排序
{
	int count;
	if(NULL==list||empty_list(list))
		return -1;
	for(int i=1;i<list->len;i++)
	{
		count=0;
		for(int j=0;j<list->len-i;j++)
		{
			if(list->data[j]>list->data[j+1])
			{
				datatype temp=list->data[j];list->data[j]=list->data[j+1];list->data[j+1]=temp;
				count++;
			}
		}
		if(count==0)break;
	}
	return 0;
}

16.  实现顺序表合并

int combine_list(Seqlist *list,Seqlist *list_b,Seqlist *list_c)  //顺序表合并
{
	int p=0,q=0;
	while(p<list->len&&q<list_b->len)
	{
		if(list->data[p]<=list_b->data[q])
			list_c->data[list_c->len++]=list->data[p++];
		else
			list_c->data[list_c->len++]=list_b->data[q++];
	}
	while(p<list->len)
	{
		list_c->data[list_c->len++]=list->data[p++];
	}
	while(q<list_b->len)
	{
		list_c->data[list_c->len++]=list_b->data[q++];
	}
	return 0;
}

四、分布编译实现顺序表增删改查【完整代码】

头文件 head.h

#ifndef __HEAD_H__
#define __HEAD_H__

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define MAXSIZE 8

typedef int datatype;
typedef struct
{
	int len;
	datatype data[MAXSIZE];
}Seqlist;

Seqlist * Request_space(void);  //顺序表创建空间
int full_list(Seqlist *list);  //判断顺序表长度是否为满
int empty_list(Seqlist *list);  //判断顺序表长度是否为空
int insert_rear(datatype value,Seqlist *list);  //实现尾插
void Output(Seqlist *list);  //实现输出
int delete_rear(Seqlist *list);  //实现尾删
datatype search_by_sub(int sub,Seqlist *list);  //实现任意下标查找
int modify_list(int sub,datatype modify,Seqlist *list);  //实现任意下标修改
int insert_list(int sub,datatype value,Seqlist *list);  //实现任意下标插入
int delete_list(int sub,Seqlist *list);  //实现任意下标删除
int search_by_element(datatype value,Seqlist *list);  //实现任意元素查找
int modify_by_element(datatype value,datatype modify,Seqlist *list);  //实现任意元素修改
int insert_by_element(datatype value,datatype modify,Seqlist *list);  //实现任意元素插入
int delete_by_element(datatype value,Seqlist *list);  //实现任意元素删除
int delete_repeat(Seqlist *list);  //实现顺序表去重
int sort_list(Seqlist *list);  //实现顺序表排序
int combine_list(Seqlist *list,Seqlist *list_b,Seqlist *list_c);  //顺序表合并

#endif

自定义函数 fun.c

#include "head.h"

Seqlist *Request_space(void) //创建空间
{
	Seqlist *list=(Seqlist *)malloc(sizeof(Seqlist));
	if(NULL==list)
		return NULL;
	list->len=0;
	memset(list->data,0,sizeof(datatype)*MAXSIZE);
	return list;
}
int empty_list(Seqlist *list)  //判断顺序表长度是否为空
{	
	return list->len==0?-1:0;
}
int full_list(Seqlist *list)  //判断顺序表长度是否为满
{
	return list->len==MAXSIZE?-1:0;
}
int insert_rear(datatype value,Seqlist *list)  //实现尾插
{
	if(NULL==list||full_list(list))
		return -1;
	list->data[list->len]=value;
	list->len++;
	return 0;
}
void Output(Seqlist *list)  //实现输出
{
	if(NULL==list||empty_list(list))
		return ;
	for(int i=0;i<list->len;i++)
	printf("%d ",list->data[i]);
	puts("");
}
int delete_rear(Seqlist *list)  //实现尾删
{
	if(NULL==list||empty_list(list))
		return -1;
	list->len--;
	return 0;
}
datatype search_by_sub(int sub,Seqlist *list)  //实现任意下标查找
{
	if(NULL==list||empty_list(list)||sub<0||sub>=list->len)
		return -1;
	return list->data[sub];
}
int modify_list(int sub,datatype modify,Seqlist *list)  //实现任意下标修改
{
	if(NULL==list||empty_list(list)||sub<0||sub>=list->len)
		return -1;
	list->data[sub]=modify;
	return 0;
}
int insert_list(int sub,datatype value,Seqlist *list)  //实现任意下标插入
{
	if(NULL==list||full_list(list)||sub<0||sub>list->len)
		return -1;
	for(int i=list->len-1;i>=sub;i--)
	{
		list->data[i+1]=list->data[i];
	}
	list->data[sub]=value;
	list->len++;
	return 0;
}
int delete_list(int sub,Seqlist *list)  //实现任意下标删除
{
	if(NULL==list||empty_list(list)||sub<0||sub>=list->len)
		return -1;
	for(int i=sub;i<list->len-1;i++)
	{
		list->data[i]=list->data[i+1];
	}
	list->len--;
	return 0;
}
int modify_by_element(datatype value,datatype modify,Seqlist *list)  //实现任意元素修改
{
	if(NULL==list||empty_list(list))
		return -1;
	for(int i=0;i<list->len;i++)
	{
		if(list->data[i]==value)
		{
			list->data[i]=modify;
			return 0;
		}
	}
	printf("the value was not found\n");
	return -1;
}
int search_by_element(datatype value,Seqlist *list)  //实现任意元素查找
{
	if(NULL==list||empty_list(list))
		return -1;
	for(int i=0;i<list->len;i++)
	{
		if(value==list->data[i])
			return i;
	}
	printf("the value was not found\n");
	return -1;
}
int insert_by_element(datatype value,datatype modify,Seqlist *list)  //实现任意元素插入
{
	int sub=search_by_element(value,list);
	if(sub==-1)
		return -1;
	insert_list(sub,modify,list);
	return 0;
}
int delete_by_element(datatype value,Seqlist *list)  //实现任意元素删除
{
	int sub=search_by_element(value,list);
	if(sub==-1)
		return -1;
	delete_list(sub,list);
	return 0;
}
int delete_repeat(Seqlist *list)  //实现顺序表去重
{
	if(NULL==list||empty_list(list))
		return -1;
	for(int i=0;i<list->len-1;i++)
	{
		for(int j=i+1;j<list->len;j++)
		{
			if(list->data[i]==list->data[j])
			{
				delete_list(j,list);
				j--;  //防止漏删
			}
		}
	}
	return 0;
}
int sort_list(Seqlist *list)  //实现顺序表排序
{
	int count;
	if(NULL==list||empty_list(list))
		return -1;
	for(int i=1;i<list->len;i++)
	{
		count=0;
		for(int j=0;j<list->len-i;j++)
		{
			if(list->data[j]>list->data[j+1])
			{
				datatype temp=list->data[j];list->data[j]=list->data[j+1];list->data[j+1]=temp;
				count++;
			}
		}
		if(count==0)break;
	}
	return 0;
}
int combine_list(Seqlist *list,Seqlist *list_b,Seqlist *list_c)  //顺序表合并
{
	int p=0,q=0;
	while(p<list->len&&q<list_b->len)
	{
		if(list->data[p]<=list_b->data[q])
			list_c->data[list_c->len++]=list->data[p++];
		else
			list_c->data[list_c->len++]=list_b->data[q++];
	}
	while(p<list->len)
	{
		list_c->data[list_c->len++]=list->data[p++];
	}
	while(q<list_b->len)
	{
		list_c->data[list_c->len++]=list_b->data[q++];
	}
	return 0;
}

主函数 main.c

#include "head.h"
int main(int argc, const char *argv[])
{
	Seqlist *list=Request_space();
	int n;
	printf("please enter n:");
	scanf("%d",&n);
	datatype value;//定义变量--存储的值
	for(int i=0;i<n;i++)
	{
		printf("please enter a value:");
		scanf("%d",&value);
		insert_rear(value,list);
	}
	Output(list);
	int sub;//定义变量--下标

 	printf("please enter a sub:");
	scanf("%d",&sub);
	printf("%d\n",search_by_sub(sub,list));

	
	datatype modify;//定义变量--需要修改的值

	printf("please enter a sub you want to modify:");
	scanf("%d",&sub);
	printf("please enter a value you want to modify:");
	scanf("%d",&modify);
	modify_list(sub,modify,list);
	Output(list);

	printf("please enter a sub you want to insert:");
	scanf("%d",&sub);
	printf("please enter a value you want to insert:");
	scanf("%d",&value);
	insert_list(sub,value,list);
	Output(list);

	printf("please enter a sub you want to delete:");
	scanf("%d",&sub);
	delete_list(sub,list);
	Output(list);

	printf("please enter the value you want to find:");
	scanf("%d",&value);
	printf("please enter a value you want to insert:");
	scanf("%d",&modify);
	insert_by_element(value,modify,list);
	Output(list);

	printf("please enter the value you want to find:");
	scanf("%d",&value);
	delete_by_element(value,list);
	Output(list);

	delete_repeat(list);
	sort_list(list);
	Output(list);
	
	Seqlist *list_b=Request_space();
	printf("please enter n:");
	scanf("%d",&n);
	for(int i=0;i<n;i++)
	{ 
		printf("please enter a value:");
		scanf("%d",&value);
		insert_rear(value,list_b);
	}
	Output(list);
	Seqlist *list_c=Request_space();
	combine_list(list,list_b,list_c);
	Output(list_c);
	return 0;
}

小钱努力学C
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构-基于C语言实现线性顺序表的增删改查+排序，合表操作.rar
08-11
数据结构-基于C语言实现线性顺序表的增删改查+排序，合表操作
模拟通讯录-数据结构（顺序表实现基本功能）.doc
04-25
模拟通讯录，设计相关数据结构，用菜单选择方式实现：通讯录的建立、通讯联系人的插入、删除、修改、查找等功能。
数据结构之顺序表，实现顺序表的增删改查
jolly0514的博客
04-18 282
本文主要介绍了顺序表的结构，以及对顺序表的操作：增删改查等。如有错误请指正。
【数据结构】实现顺序表的增删查改
m0_51064412的博客
03-01 861
文章目录一.顺序表介绍二.动态顺序表增删查功能实现三.完整代码四.动态顺序表总结 一.顺序表介绍 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储，在数组上完成数据的增删查改。顺序表可分为静态顺序表和动态顺序表。 (1)静态顺序表：使用定长数组存储，适用于确定知道需要存多少数据的场景 #define N 100 typedef int SeqListDataType; typedef struct SeqList { SLDataType array[N]; // 定长
顺序表功能实现（增删查改）《数据结构(C语言版)》
m0_57859086的博客
03-12 3937
顺序表（增删查改）功能实现
数据结构 顺序表之增删改查
记录读博日常，记录一些零碎的东西，包括但不限于：工具分享、论文分享、读博心得
03-03 391
初识数据结构之顺序表，码上说话????。 #include<iostream> #define maxSize 100 using namespace std; typedef struct { int data[maxSize]; //存放数据 int length; //数组长度 }SqList; //构建一个结构体 void printList(SqLi...
【数据结构】顺序表的增删查改操作
wangduduniubi的博客
04-18 963
上一篇文章为大家介绍了对顺序表的简单的使用，本篇文章继续完善对顺序表增删查改的操作。上一篇写到了顺序表的，本篇将从继续完善；以下为本篇目录，方便阅读。
数据结构 - 顺序表(Contiguous-List)
10-23
在计算机内部存储一张线性表（线性结构的数表），最为方便简单的就是用一组连续的地址的内存单元来存储整张线性表。这种存储结构称为顺序存储结构。这种存储结构下的线性表就称为顺序表。
顺序表的基本操作（增删改查）
03-09
printf("\n\t\t\t* 1-------顺序表初始化 *"); printf("\n\t\t\t* 2-------录入初始数据 *"); printf("\n\t\t\t* 3-------插 入 *"); printf("\n\t\t\t* 4-------删 除 *"); printf("\n\t\t\t* 5-------求...
数据结构顺序表，链表，队列，栈，串，二叉树的存储结构，增删改查操作和主函数实现
03-10
适用于考研初试数据结构顺序表，链表，队列，栈，串，二叉树基础操作的代码练习，里面有实现函数和注释，可以通过运行程序来加深对数据结构的理解。顺序表包含静态存储和动态存储的结构体定义，初始化，插入和删除...
C语言实现顺序的建立、查找、插入、删除等基本操作
03-27
C语言实现顺序的建立、查找、插入、删除等基本操作
【数据结构】顺序表之增删查改操作（C语言）
shaoxiebug的博客
04-22 725
目录1.头部插入（SLpushfront）2.尾部删除（SLpopback）3.头部删除（SLpopfront）4.指定位置插入数据（SListInsert）5.指定位置删除数据（SLdelete）6.查找数据（SLFind）7.修改数据（SLModify）插入前我们调用容量检测函数对容量进行检测，函数内部已经写好了增容的程序。 那么插入数据就要挪动数据，尾插是从前向后挪动数据，那么头部插入就是从后向前挪动数据，也就是开辟空间后，将新添加的数据从顺序表头部向前移动。我们直接将size所再的位置减1即可
【数据结构】顺序表的增删查改（C语言实现）
shinan_1107的博客
02-22 1132
C语言数据结构顺序表不理解？增删查改不会做？那还不进来，保证你顺序表这一篇文章搞定！
【数据结构】顺序表的增删查改
StandDev的博客
08-10 73
线性表（linear list）是n个具有相同特性的数据元素的有限序列；线性表是一种在实际中广泛使用的数据结构，常见的线性表有：顺序表、链表、栈、队列、字符串…顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储，在数组上完成数据的增删查改。简单来说，顺序表就是数组，只是要求数组里面的元素必须连续存储而已
顺序表的增删查改
ll1175555的博客
04-22 650
SeqList.h #define _CRT_SECURE_NO_WARNINGS #pragma once #include<stdlib.h> #include<stdio.h> #include<assert.h> typedef int SLDateType; typedef struct SeqList { SLDateType* array; //指向动态开辟的数组 ...
C语言《数据结构》——顺序表的增，删，查，改。
qq_59931372的博客
04-16 3816
构建顺序表进行数据的查询，删除，增容等操作。
顺序表的插入，删除，修改和查找（详细解析）
weixin_69884785的博客
08-14 3234
顺序表的插入，删除，修改和查找（详细解析）相对基础，多看多理解多写
【数据结构】顺序表(SeqList)（增、删、查、改）详解
Elena's Blog
07-27 2871
在数据结构中，如果要访问或者修改数据结构中的数据不要直接访问，而是应该去调用它的函数来访问和修改，这样会更加规范和安全，也更方便检查出是否出现了越界等错误情况。数组越界是不一定报错的，系统对越界的检查是设岗检查。越界读（读了不属于自己的数据），一般是检查不出来的，往往并不会造成内存奔溃。越界写（缓冲区溢出）如果是修改到标志位才会被检查出来，会造成数据破坏，严重会造成内存奔溃。（系统在数组末尾后设的有标志位，越界写时，恰好修改到标志位了，就会被检查出来）
顺序表的查找，插入和删除
b312738566的博客
11-19 2834
【代码】顺序表的查找，插入和删除。
深圳大学数据结构oj顺序表
最新发布
09-09
深圳大学数据结构oj顺序表是指在深圳大学数据结构在线评测系统中使用的一种顺序表结构。顺序表是一种线性表的存储结构，通常是使用数组实现的。在顺序表中，元素按照一定的顺序依次存放在连续的内存空间中，通过数组的下标来访问和操作元素。顺序表的优点是随机访问元素快速，但插入和删除操作可能需要移动大量元素。 在深圳大学数据结构oj中，顺序表主要用于存储和操作线性表的元素。学生可以通过代码实现顺序表的各种基本操作，如插入元素、删除元素、查找元素等。顺序表的实现可以使用C++编程语言，通过数组和相关的方法来实现。 在代码中，可以看到使用了queue和stack来实现队列和栈的操作。此外，还使用了string类来处理字符串操作，如获取字符串长度、访问字符串中的字符等。代码中的数据结构“pot”是自定义的一个类，用于存储字符和位置信息。 总之，深圳大学数据结构oj顺序表是一种在深圳大学数据结构在线评测系统中使用的顺序表结构，用于存储和操作线性表的元素。通过实现各种基本操作，学生可以加深对顺序表的理解和应用。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值