1. Toy模板网首页
  2. > Toy博客

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

9月前 作者：小钱努力学C 分类：Toy博客 阅读(25) 违法举报

这篇具有很好参考价值的文章主要介绍了数据结构顺序表，实现增删改查。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

一、顺序表结构体定义

#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;
}

数据结构顺序表，实现增删改查,数据结构练习,# 数据结构练习（7月17）,数据结构文章来源地址https://www.toymoban.com/news/detail-579501.html

到了这里，关于数据结构顺序表，实现增删改查的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 趣说数据结构（练习2） —— 顺序表/链表力扣刷题（中等难度）

    趣说数据结构（练习2） —— 顺序表/链表力扣刷题（中等难度）

    力扣原题：https://leetcode.cn/problems/reverse-linked-list-ii/ 题目描述 给你单链表的头指针 head 和两个整数 left 和 right ，其中 left = right 。请你反转从位置 left 到位置 right 的链表节点，返回 反转后的链表 。 示例 1 输入：head = [1,2,3,4,5], left = 2, right = 4 输出：[1,4,3,2,5] 示例 2 输入：h

    2024年02月01日
    浏览(45)
  • 数据结构c语言版：顺序表oj题练习（原地移除元素、合并两个有序数组）

    数据结构c语言版：顺序表oj题练习（原地移除元素、合并两个有序数组）

    在单数组里面历遍找val，如果是val，就删除。不是就跳过。 时间复杂度O（n^2),最坏情况每个都是val。相当于一个等差数列。 比如 下标0开始找，0不是，不动数组 下标1，1不是，不动数组 下标2，2是，删除元素，变成【0，1，2，3，0，4，2】 下标2，2是，删除元素，变成【0，

    2024年01月23日
    浏览(63)
  • 数据结构双向链表，实现增删改查

    数据结构双向链表，实现增删改查

            在单链表中，查找直接后继结点的执行时间为O(1)，而查找直接前驱的执行时间为O(n)。为克服单链表这种单向性的缺点，可以用 双向链表 。         在双向链表的结点中有两个指针域，一个指向直接后继，另一个指向直接前驱。 2.1 双向链表结点创建 2.2 双向链表

    2024年02月16日
    浏览(41)
  • 【数据结构】实现顺序表

    【数据结构】实现顺序表

    顺序表是用一段 物理地址连续 的存储单元依次存储数据元素的线性结构，一般情况下 采用数组存储 。 顺序表与通讯录类似，可以完成 增删查改 等功能。在此基础上，还可以实现 头插、头删、尾插、尾删以及某位置的插入和删除 1.创建多文件 用多文件的好处在通讯录一文

    2024年02月12日
    浏览(53)
  • 【数据结构与算法】1、学习动态数组数据结构（基本模拟实现 Java 的 ArrayList 实现增删改查）

    【数据结构与算法】1、学习动态数组数据结构（基本模拟实现 Java 的 ArrayList 实现增删改查）

    🍃 数据结构是 计算机 存储 、 组织 数据的方式 🎉 线性 结构 线性表（数组、链表、栈、队列、哈希表） 🎉 树形 结构 二叉树 AVL 树 红黑树 B 树 堆 Trie 哈夫曼树 并查集 🎉 图形 结构 邻接矩阵 邻接表 🎁 线性表是具有 n 个 相同类型元素 的有限 序列 （n = 0） a1 是首节点

    2024年02月10日
    浏览(75)
  • 数据结构-二叉树·堆（顺序结构的实现）

    数据结构-二叉树·堆（顺序结构的实现）

    🎉个人名片： 🐼作者简介：一名乐于分享在学习道路上收获的大二在校生 🐻‍❄个人主页🎉：GOTXX 🐼个人WeChat ： ILXOXVJE 🐼本文由GOTXX原创，首发CSDN🎉🎉🎉 🕊系列专栏：零基础学习C语言----- 数据结构的学习之路 🐓每日一句：如果没有特别幸运，那就请特别努力！🎉

    2024年02月05日
    浏览(44)
  • 【数据结构】顺序队列模拟实现

    【数据结构】顺序队列模拟实现

    💐 🌸 🌷 🍀 🌹 🌻 🌺 🍁 🍃 🍂 🌿 🍄🍝 🍛 🍤 📃 个人主页 ：阿然成长日记 👈点击可跳转 📆 个人专栏： 🔹数据结构与算法🔹C语言进阶 🚩 不能则学，不知则问，耻于问人，决无长进 🍭 🍯 🍎 🍏 🍊 🍋 🍒 🍇 🍉 🍓 🍑 🍈 🍌 🍐 🍍 一、队列的基本概念

    2024年02月10日
    浏览(40)
  • 【数据结构】二叉树的顺序结构及实现

    【数据结构】二叉树的顺序结构及实现

    目录 1. 二叉树的顺序结构 2. 堆的概念及结构 3. 堆的实现 3.1 堆向下调整算法 3.2 堆的创建 3.3 建堆时间复杂度 3.4 堆的插入 3.5 堆的删除 3.6 堆的代码实现 4. 堆的应用 4.1 堆排序 4.2 TOP-K问题 普通的二叉树是不适合用数组来存储的，因为可能会存在大量的空间浪费。而完全二叉

    2024年02月08日
    浏览(40)
  • 【数据结构】结构实现：顺序存储模式实现堆的相关操作

    【数据结构】结构实现：顺序存储模式实现堆的相关操作

    🚩 纸上得来终觉浅， 绝知此事要躬行。 🌟主页：June-Frost 🚀专栏：数据结构 🔥该文章着重讲解了使用顺序结构实现堆的插入和删除等操作。  二叉树的顺序存储是指将二叉树中的所有节点按照一定的顺序（一层一层）存储到一个数组中。  我们可以通过数组下标来表示

    2024年02月08日
    浏览(46)
  • 数据结构：详解【顺序表】的实现

    数据结构：详解【顺序表】的实现

    顺序表是用一段 物理地址连续 的存储单元 依次存储数据元素 的线性结构，一般情况下采用数组存储。动态顺序表与数组的本质区别是—— 根据需要动态的开辟空间大小。 动态顺序表的功能一般有如下几个： 初始化顺序表 打印顺序表中的数据 检查顺序表的容量 顺序表头部

    2024年03月14日
    浏览(55)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包