【Day3】数据结构顺序表

最新推荐文章于 2024-09-13 17:05:05 发布
最新推荐文章于 2024-09-13 17:05:05 发布
阅读量49 收藏
点赞数
文章标签： 数据结构 c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46036277/article/details/130784053
版权

在这里插入图片描述
main.c:

#include "head.h"
int main(int argc, const char *argv[])
{
	int n,e;
	//创建顺序表
	seqlist *l = create();
	printf("请输入你要插入的数据个数：");
	scanf("%d",&n);
	for(int i = 0;i<n;i++){
		printf("请输入你要插入的数据：");
		scanf("%d",&e);
		//顺序表的尾插
		insert_rear(e,l);
	}
	//输出
	output(l);
	//顺序表的尾删
	delete_rear(l);
	output(l);
	//顺序表的判满
	int len = full(l);
	if(len==1)
		printf("顺序表已满\n");
	else if(len==0)
		printf("顺序表未满\n");

	len = empty(l);
	if(len==1)
		printf("顺序表为空\n");
	else if(len==0)
		printf("顺序表不为空\n");	
	//顺序表按下标插入
	printf("请输入插入位置：");
	scanf("%d",&n);
	printf("请输入插入元素：");
	scanf("%d",&e);
	insert_sub(l,n,e);
	output(l);
	printf("请输入删除元素位置:");
	scanf("%d",&n);
	//顺序表按下标删除
	delete_sub(l,n);
	output(l);
	//顺序表按下标修改	
	printf("请输入修改位置：");
	scanf("%d",&n);
	printf("请输入修改元素：");
	scanf("%d",&e);
	update_sub(l,n,e);
	output(l);
	//顺序表按下标查找
	printf("请输入查找位置：");
	scanf("%d",&n);
	n = find_sub(l,n);
	printf("该位置元素为：%d\n",n);
	//顺序表按元素插入
	printf("请输入查找元素：");
	scanf("%d",&n);
	printf("请输入插入元素：");
	scanf("%d",&e);
	insert_data(l,n,e);
	output(l);
	//顺序表按元素删除
	printf("请输入删除元素：");
	scanf("%d",&n);
	delete_data(l,n);
	//顺序表按元素修改
	printf("请输入修改元素：");
	scanf("%d",&n);
	printf("请输入修改值：");
	scanf("%d",&e);
	update_data(l,n,e);
	//冒泡升序
	bubble(l);
	output(l);
	//顺序表去重
	delete_re(l);
	l = free_space(l);
	l = NULL;
	return 0;
}

test.c:


#include "head.h"
/*
 * function:    顺序表堆空间的创建
 * @param [ in] 
 * @param [out] 
 * @return      失败返回NULL，成功返回顺序表指针
 */
seqlist *create()
{
	seqlist *list = (seqlist *)malloc(sizeof(struct Seq));
	//判断是否创建成功
	if(list==NULL)
		return NULL;
	//初始化顺序表
	list->len = 0;
	return list;
}
/*
 * function:    顺序表的尾部插入
 * @param [ in] 待插数据 顺序表
 * @param [out] 
 * @return      无
 */
void insert_rear(datatype e,seqlist *l)
{
	//判断创建成功或顺序表满
	if(l->len==MAXSIZE||l==NULL){
		printf("插入失败\n");
		return ;
	}
	//插入
	l->data[l->len] = e;
	l->len++;
}
/*
 * function:    顺序表的遍历
 * @param [ in] 顺序表
 * @param [out] 
 * @return      无
 */
void output(seqlist *l)
{
	//判断创建成功或顺序表空
	if(l==NULL||l->len==0){
		puts("顺序表为空\n");
		return ;
	}
	//循环遍历
	for(int i = 0;i<l->len;i++){
		printf("%d\t",l->data[i]);
	}
	puts(" ");
}
/*
 * function:    顺序表的尾部删除
 * @param [ in] 顺序表
 * @param [out] 
 * @return      无
 */
void delete_rear(seqlist *l)
{
	//判断创建成功或顺序表空
	if(l==NULL||l->len==0){
		printf("删除失败\n");
		return ;
	}
	//删除
	printf("被删除的元素是：%d\n",l->data[l->len]);
	l->len--;
}
/*
 * function:    顺序表的判满
 * @param [ in] 顺序表
 * @param [out] 
 * @return      满返回1，不满返回0
 */
int full(seqlist *l){
	return l->len==MAXSIZE?1:0;
}
/*
 * function:    顺序表的判空
 * @param [ in] 顺序表
 * @param [out] 
 * @return      空返回1，不空返回0
 */
int empty(seqlist *l){
	return l->len==0?1:0;
}
/*
 * function:    顺序表的按下标插入
 * @param [ in] 顺序表 位置 插入元素
 * @param [out] 
 * @return      无
 */
void insert_sub(seqlist *l,int sub,datatype e)
{
	//判断创建成功或顺序表满
	//判断下标是否合法
	if(l==NULL||l->len==MAXSIZE||sub<0||sub>MAXSIZE){
		printf("插入失败\n");
		return ;
	}
	//插入
	//循环后移
	for(int i = l->len-1;i>=sub;i--){
		l->data[i+1] = l->data[i];//后移
	}
	//插入
	l->data[sub]=e;
	l->len++;
}
/*
 * function:    顺序表按下标删除
 * @param [ in] 顺序表 删除位置
 * @param [out] 
 * @return      无
 */
void delete_sub(seqlist *l,int sub)
{
	//判断创建成功或顺序表空
	//判断下标是否合法
	if(l==NULL||l->len==0||sub<0||sub>MAXSIZE){
		printf("删除失败\n");
		return ;
	}
	//删除
	//循环前移
	for(int i = sub+1;i<l->len;i++){
		l->data[i-1]=l->data[i];//前移
	}
	l->len--;
}
/*
 * function:    顺序表按下标修改
 * @param [ in] 顺序表 修改位置 修改元素
 * @param [out] 
 * @return      无
 */
void update_sub(seqlist *l,int sub,datatype e)
{
	//判断创建成功或顺序表空
	//判断下标是否合法
	if(l==NULL||l->len==0||sub<0||sub>l->len){
		printf("修改失败\n");
		return ;
	}
	//修改
	l->data[sub]=e;
}
/*
 * function:    按下标查找
 * @param [ in] 顺序表 位置
 * @param [out] 
 * @return      成功返回该下标对应的值，失败返回-1
 */
int find_sub(seqlist *l,int sub)
{
	//判断创建成功或顺序表空
	//判断下标是否合法
	if(l==NULL||l->len==0||sub<0||sub>l->len){
		printf("查找失败\n");
		return -1;
	}
	return l->data[sub];
}
/*
 * function:    按元素查找
 * @param [ in] 顺序表 查找元素
 * @param [out] 
 * @return     存在返回下标 不存在返回-1 
 */
int find_data(seqlist *l,datatype key)
{
	//判断创建成功或顺序表空
	if(l==NULL||l->len==0)
		return -1;
	for(int i =0;i<l->len;i++){
		if(l->data[i]==key)
			return i;
	}
	return -1;
}
/*
 * function:    顺序表按元素插入
 * @param [ in] 顺序表 查找元素 插入元素
 * @param [out] 
 * @return      成功返回0，失败返回-1
 */
int insert_data(seqlist *l,datatype key,datatype e)
{
	int sub=-1;
	//根据key查下标
	for(int i = 0;i<l->len;i++){
		if(l->data[i]==key){
			sub = i;
			break;
		}
	}
	if(sub==-1){
		printf("查找失败\n");
		return -1;
	}
	insert_sub(l,sub,e);
	return 0;
}
/*
 * function:    顺序表按元素删除
 * @param [ in] 顺序表 元素值key
 * @param [out] 
 * @return      成功返回0，失败返回-1
 */
int delete_data(seqlist *l,datatype key)
{
	int sub = find_data(l,key);
	if(sub==-1)
		return -1;
	//根据下标删除
	delete_sub(l,sub);
	return 0;
}
/*
 * function:    顺序表按元素修改
 * @param [ in] 顺序表 查找值key 修改值e
 * @param [out] 
 * @return      成功返回0，失败返回-1
 */
int update_data(seqlist *l,datatype key,datatype e)
{
	int sub = find_data(l,key);
	if(sub==-1)
		return -1;
	update_sub(l,sub,e);
	return 0;
}
/*
 * function:    冒泡升序
 * @param [ in] 顺序表
 * @param [out] 
 * @return      无
 */
void bubble(seqlist *l)
{
	//判断创建成功或顺序表空
	if(l==NULL||l->len==0)
		return ;
	for(int i = 1;i<l->len;i++){
		int count = 0;
		for(int j = 0;i<l->len-i;j++){
			if(l->data[j]>l->data[j+1]){
				datatype t = l->data[j];
				l->data[j] = l->data[j+1];
				l->data[j+1] = t;
				count++;
			}
		}
		if(count==0)
			break;
	}
}
void select_sort(seqlist *list)
{
    //2 4 6 3 7 1
    //1,判断顺序表创建是否成功
    //2，判断顺序表是否空
    if(list==NULL || list->len==0)
    {
        printf("排序失败\n");

    }
    //3,简单选择排序
    for(int i=0;i<list->len-1;i++)//轮数
    {
        int min=i;//默认第一个下表是最值下表
        for(int j=i+1;j<list->len;j++)
        {
            if(list->data[min] > list->data[j])
            {
                min=j;
            }
        }
        if(min!=i)
        {
            datatype t=list->data[min];
            list->data[min]=list->data[i];
            list->data[i]=t;

        }
    }
}
void delete_re(seqlist *list)
{
	 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_sub(list,j);  
                 j--;  //防止连续的且重复元素漏删       
            }                    
        }
    }
}
seqlist *free_space(seqlist *l)
{
	//删掉所有元素
	l->len=0;
	free(l);
	l = NULL;
	return l;
}

head.h

#ifndef Head_H
#define Head_H
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAXSIZE 10
typedef int datatype;
//顺序表结构体的定义
typedef struct Seq
{
	//数据元素
	datatype data[MAXSIZE];
	//顺序表长度
	int len;
}seqlist;
void output(seqlist *l);
void insert_rear(datatype e,seqlist *l);
seqlist *create();
void delete_rear(seqlist *l);
int full(seqlist *l);
int empty(seqlist *l);
void insert_sub(seqlist *l,int sub,datatype e);
void delete_sub(seqlist *l,int sub);
void update_sub(seqlist *l,int sub,datatype e);
int insert_data(seqlist *l,datatype key,datatype e);
int find_sub(seqlist *l,int sub);
int find_data(seqlist *l,datatype key);
int update_data(seqlist *l,datatype key,datatype e);
int delete_data(seqlist *l,datatype key);
void bubble(seqlist *l);
void select_sort(seqlist *list);
seqlist *free_space(seqlist *l);
void delete_re(seqlist *list);
#endif
qq_46036277
关注
408_数据结构_顺序表_Day6
weixin_45880844的博客
03-21 912
目录相关知识插入数据删除数据修改元素查找元素 相关知识 线性表在物理结构上可以分为：顺序存储结构和链表存储结构，前者是随机存取的存储结构，后者是顺序存取的存储结构。 插入数据 在哪个顺序表上的哪个位置插入哪个数据值 bool InsertList (SqList &L, int loca, ElemType dat) 因为要修改顺序表，所以用引用 ret = InsertList (L, 2, 20); 顺序表中已经存满了时，不可以插入 时间复杂度：最好：O(1); 最坏：O(n); 平均：O(n
数据结构复习-day01-SqList顺序表
SKINB0Y的博客
12-28 521
数据结构复习-day01SqList顺序表 SqList顺序表 //SKinBoy #include<bits/stdc++.h> using namespace std; #define MAXSIZE 20 #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 typedef int ElemType; typedef int Status; //以上定义看似繁琐，但如果在VScode等编辑器中打代码你会发现，会有关键字提
数据结构【顺序表】
qq_67578580的博客
07-12 1963
我们需要创建一个seqlist.h头文件，seqlist.c文件存放函数，还有一个.c的测试文件。
数据结构（C++版）—— 顺序表Ⅰ
ygx0073的博客
07-26 1603
一、顺序表的定义顺序表——用顺序存储的方式实现线性表顺序存储把逻辑上相邻的元素存储在物理位置上也相邻的存储单元中，元素之间的关系由存储单元的邻接关系来体现，是具有相同数据类型的n(n>0)个数据元素的有限序列。二，要实现的代码功能主要操作其他常用操作三，具体代码实现。
数据结构v1——顺序表的基本操作之插入操作
Vicky
11-30 3043
时，在函数体内不需要改变主调函数中的实参变量的值，只需读取主调函数中的实参变量的值，因此函数形参定义为变量，采用值传递。，i-1上的结点，依次后移到位置n，n-1，…C++语言中用引用作函数的形参，被调函数对形参做的任何操作都影响了主调函数中的实参变量值，而操作一个变量比操作一个指针要简单的多，为了便于算法描述，本书函数参数传递机制采用有两种方式：值传递和引用传递。如果需要将函数中变化的形式参数的值反映在实际参数中，在C语言的实现中，就需要通过指针变量作形式参数，接收变量的地址，达到修改实参变量值的目的。
【嵌入式学习】数据结构-Day2-顺序表
BH6AEV的博客
12-21 1521
在链式存储结构中，线性表的元素在内存中可以是不连续的，通过指针来连接各个元素。：数据元素之间存在一对一的逻辑关系(数组，地铁的座位)头节点无直接前驱，尾节点无直接后继，中间节点存储在唯一的前驱唯一的后继。：数据元素之间存在一对多的逻辑关系(族谱，公司架构)头结点无直接前驱，尾节点无直接后继，中间节点存在唯一的直接前驱，多个后继。线性结构是一种元素之间存在一对一的关系，即每个元素都有唯一的直接前驱和直接后继。线性表：顺序表，链表，数组，栈，队列，字符串。数据类型(整数，小数，字符，字符串，汉字)
数据结构学习记录——Day1 顺序表
weixin_43240212的博客
04-08 1614
顺序表学习，以及8种操作的实现
数据结构复习-day02-LinkList顺序表
SKINB0Y的博客
01-04 622
数据结构复习-day02LinkList顺序表 LinkList顺序表 //SKinBoy #include<bits/stdc++.h> using namespace std; #define MAXSIZE 20 #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 typedef int ElemType; typedef int Status; //以上定义看似繁琐，但如果在VScode等编辑器中打代码你会发现，会有
Day02 顺序表与顺序表的实现
qq_59111928的博客
06-13 494
满足这种数学关系的一组元素，逻辑关系就是线性结构，并且逻辑关系是一对一的，比如一个教室学生的学号、一个排队的队伍、一摞堆好的盘子.....都属于线性结构，当然线性结构和存储方式是无关的，简单理解：只有逻辑关系是一对一的，就是线性结构。顺序表的特点：数据元素之间的逻辑关系是相邻的，并且内存地址也是相邻的，所以只要知道存储线性表的第一个数据元素的内存地址，就可以对线性表中的任意一个元素进行随机访问。顺序表指的是使用一组内存地址连续的内存单元来依次存储线性表中的数据元素，使用这种存储结构的线性表就被称为顺序表。
【Python数据结构与算法笔记day13】2.2. 顺序表的结构与实现+顺序表的结构 +顺序表的两种基本实现方式+ 元素存储区替换 +元素存储区扩充
汪雯琦的博客
02-01 448
文章目录2.2. 顺序表的结构与实现顺序表的结构与实现顺序表的结构顺序表的两种基本实现方式元素存储区替换元素存储区扩充 2.2. 顺序表的结构与实现 顺序表的结构与实现 顺序表的结构 一个顺序表的完整信息包括两部分，一部分是表中的元素集合，另一部分是为实现正确操作而需记录的信息，即有关表的整体情况的信息，这部分信息主要包括元素存储区的容量和当前表中已有的元素个数两项。 顺序表的两种基本实现方式...
21_动态规划与数据结构结合
刘炫320的博客
09-11 564
老鸟：假设你有一个数组arr，你需要多次查询某个子数组arr[i:j]的和。直接计算会很慢，我们可以用动态规划预处理，再用一种数据结构来快速查询。菜鸟：听起来不错，但具体怎么做呢？老鸟：我们可以先构建一个数组prefixSum，其中表示数组arr从起始位置到i的和。这样每次查询arr[i:j]的和时，可以用来快速计算。菜鸟：这样确实能减少计算量，但构建prefixSum数组需要什么操作呢？老鸟：好问题。我们来看看代码示例。老鸟：今天我们讨论了动态规划与数据结构结合的应用，通过prefixSum。
数据结构 Java DS——分享部分链表题目 (2)
cjejwe的博客
09-10 971
关于JAVA的链表,笔者已经写了两篇博客来介绍了,今天给笔者们带来第三篇,也是分享了一些笔者写过的,觉得挺好的题目,链接也已经挂上了,笔者们可以去看看。
浙大数据结构：05-树7 堆中的路径
qq_74924951的博客
09-11 679
int size;}* Heap;int size;} *Heap;return H;int i;for (;for (;x;i < n;int f = 0;i < l;f = 1;return 0;
数据结构之红黑树的 “奥秘“
robin_suli的博客
09-09 1092
红黑树在经常进行增删的结构中性能比 AVL树更优，而且红黑树实现比较简单，所以实际运用中红黑树更多。红黑树不追求绝对平衡，其只需保 证最长路径不超过最短路径的2倍(相对平衡)每个结点上增加一个存储位表示结点的颜色。红黑树和AVL树都是高效的平衡二叉树。没有一条路径会比其他路径长出俩倍。先grandParent右旋。围绕红黑树上面的几条性质。
数据结构 - 栈
最新发布
kaneki_lh的博客
09-13 486
/指向栈的指针int maxlen;//表示栈的最大长度int top;//栈顶元素的下标，用来指明栈顶的位置}s//数据域名//指针，指向栈下一个元素。
0基础跟德姆（dom）一起学AI Python进阶10-算法和数据结构
chrisfanallin的博客
09-11 1296
AI全流程带你玩 0基础带你学人工智能相关软件，讲解机器学习、深度学习、大模型等人工智能领域核心知识。 帮助想了解，或者正在AI赛道成长的你。
从零开始学数据结构系列之第六章《排序简介》
铁匠匠匠的博客
09-12 1058
​所谓排序，就是使一串数据，按照其中的某个或某些关键字的大小，递增或递减排列起来的操作。
数据结构应用实例(三)——赫夫曼编码
Blogs of zcy1221
09-10 1106
如果其有父节点，如果为父节点的左孩子，编码尾部添加 ‘0’，如果为右孩子，尾部添加 ‘1’，然后向根节点移动：当前节点变为其父节点，父节点变为父节点的父节点，进行相同操作。4、 进行 Huffman 编码时，由于是从叶子节点开始向前回溯到根节点，所以编码时从后向前进行，这样就避免了逆置编码；(2)在 F 中选取两棵根节点权值最小的树作为左右子树构造一棵新二叉树，其根节点的权值为两棵子树根节点权值之和；如果 num<=1，进行相关信息的显示，不进行 Huffman 编码；然后，统计出现过的字母个数 num；
《C++位域：在复杂数据结构中的精准驾驭与风险规避》
xy520521的博客
09-10 656
通过明确位域的用途和限制、避免跨平台依赖、小心赋值和读取、谨慎使用指针操作以及考虑内存对齐和布局等方法，可以正确地使用位域，发挥其优势，同时确保程序的正确性和稳定性。在 C++的广阔编程世界中，位域作为一种强大的工具，可以在复杂数据结构中实现高效的内存利用和特定的数据表示。只有这样，我们才能在复杂的数据结构中精准驾驭位域，避免未定义行为，为开发高质量的 C++程序奠定坚实的基础。例如，在图像编码中，可以使用位域来表示像素的颜色值，将红、绿、蓝三个颜色通道的值压缩到较少的位数中。尽量避免使用指针操作位域。
使用顺序表实现学生健康管理系统
顺序表是一种常见的数据结构，它将所有元素存储在一个连续的内存区域中，可以通过数组索引来直接访问任意位置的元素，具有高效访问和简单实现的特点。 首先，系统定义了一个名为`Sstudent`的结构体，用于存储每个...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值