day3_顺序表

最新推荐文章于 2024-07-24 14:54:00 发布
最新推荐文章于 2024-07-24 14:54:00 发布
阅读量28 收藏
点赞数
文章标签： 算法 c语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_75804998/article/details/130255079
版权

1、合并

#include "head.h"
int main(int argc, const char *argv[])
{
	seqlist_a *list_a =space_a();
	seqlist_b *list_b =space_b();
	seqlist_c *list_c =space_c();
	int n,i;
	datatype e;
	printf("请输入要插入的元素个数");
	scanf("%d",&n);
	for(i=0;i<n;i++){
		printf("请输入要插入的元素");
		scanf("%d",&e);
		insert_rear(list_a,e);
	}
	output(list_a);
	printf("请输入要插入的元素个数");
	scanf("%d",&n);
	for(i=0;i<n;i++){
		printf("请输入要插入的元素");
		scanf("%d",&e);
		insert_rear(list_b,e);

	}
	output(list_b);
	sort_list(list_a);
	output(list_a);
	sort_list(list_b);
	output(list_b);
	hb(list_a,list_b,list_c);
	output_c(list_c);
	return 0;
}

fun.c

#include "head.h"
seqlist_a * space_a()
{
	seqlist_a *list_a=(seqlist_a *)malloc(sizeof(seqlist_a));
	if(list_a==NULL){
		return NULL;
	}
	list_a->len=0;
	return list_a;
}
seqlist_b * space_b()
{
	seqlist_b *list_b=(seqlist_b *)malloc(sizeof(seqlist_b));
	if(list_b==NULL){
		return NULL;
	}
	list_b->len=0;
	return list_b;
}
seqlist_c * space_c()
{
	seqlist_c *list_c=(seqlist_c *)malloc(sizeof(seqlist_c));
	if(list_c==NULL){
		return NULL;
	}
	list_c->len=0;
	return list_c;
}


int full_seqlist(seqlist_a * list_a)
{
	if(list_a->len==MAXSIZE){
		return -1;
	}
	
		return 0;
}


int insert_real(seqlist_a * list_a,datatype e)
{
	//判断顺序表创建是否成功
	if(list_a==NULL||full_seqlist(list_a))
	{
		printf("为不插入失败\n");
		return -1;
	}
	//在尾部插入
	list_a->data[list_a->len]=e;//在尾部插入
	list_a->len++;
	return 0;
}
int insert_rear(seqlist_b * list_b,datatype e)
{
	//判断顺序表创建是否成功
	if(list_b==NULL||full_seqlist(list_b))
	{
		printf("为不插入失败\n");
		return -1;
	}
	//在尾部插入
	list_b->data[list_b->len]=e;//在尾部插入
	list_b->len++;
	return 0;
}


void output(seqlist_a * list_a)
{
	//判断顺序表创建是否成功
	//判断顺序表是否为空
	if(list_a==NULL||list_a->len==0){
		printf("遍历失败\n");
		return;
	}
	//循环输出
	for(int i=0;i<list_a->len;i++){
		printf("%d\t",list_a->data[i]);
	}
	puts("");
}
void output_c(seqlist_c * list_c)
{
	//判断顺序表创建是否成功
	//判断顺序表是否为空
	if(list_c==NULL||list_c->len==0){
		printf("遍历失败\n");
		return;
	}
	//循环输出
	for(int i=0;i<list_c->len;i++){
		printf("%d\t",list_c->data[i]);
	}
	puts("");
}


//将顺序表进行排序
int sort_list(seqlist_a *list_a)
{
	if(list_a==NULL||list_a->len==0){
		printf("顺序表排序失败\n");
		return -1;
	}
	int temp;
	for(int i=1;i<list_a->len;i++)
	{
		for(int j=0;j<list_a->len-i;j++){
			if(list_a->data[j]>list_a->data[j+1]){
			
			temp=list_a->data[j];
			list_a->data[j]=list_a->data[j+1];
			list_a->data[j+1]=temp;
			}

		}
	}
	return 0;
}
//合并
int hb(seqlist_a *list_a,seqlist_b *list_b,seqlist_c *list_c)
{
	output(list_a);
	int p=0,q=0,r=0;
	while(p<list_a->len&&q<list_b->len){
		if(list_a->data[p]<=list_b->data[q]){
		list_c->data[r]=list_a->data[p];
		p++;
		r++;
		list_c->len++;
		}
		else{
			list_c->data[r]=list_b->data[q];
			q++;
			r++;
			list_c->len++;
		}
	}
	while(p<list_a->len){
		list_c->data[r]=list_a->data[p];
		p++;
		r++;
		list_c->len++;

	}
	while(q<list_b->len){
		list_c->data[r]=list_b->data[q];
		q++;
		r++;
		list_c->len++;

	}
	return 0;
}

head.h

#define MAXSIZE_Z 30
typedef int datatype;
typedef struct
{
	datatype data[MAXSIZE];
	int len;
}seqlist_a;
typedef struct
{
	datatype data[MAXSIZE];
	int len;
}seqlist_b;
typedef struct
{
	datatype data[MAXSIZE_Z];
	int len;
}seqlist_c;
int sort_list(seqlist_a *list_a);
void output(seqlist_a * list_a);
int insert_real(seqlist_a * list_a,datatype e);
int full_seqlist(seqlist_a * list_a);
seqlist_c * space_c();
seqlist_b * space_b();
seqlist_a * space_a();
int hb(seqlist_a *list_a,seqlist_b *list_b,seqlist_c *list_c);
void output_c(seqlist_c * list_c);












#endif


        

 2、

main.c

#include "head.h"
int main(int argc, const char *argv[])
{
	seqlist * list=space();
	int n,i;
	datatype e;
	printf("请输入要插入的元素个数");
	scanf("%d",&n);
	for(i=0;i<n;i++){
		printf("请输入插入的元素");
		scanf("%d",&e);
		insert_real(list,e);
	}
	output(list);
	//delete_rear(list);
	//delete_rear(list);
	//output(list);
	int sub;
	datatype w;
	printf("请输入要查找的下标");
	scanf("%d",&sub);
	search_sub(list,sub);
	printf("请输入想要修改的下标");
	scanf("%d",&sub);
	printf("请输入想要修改的元素");
	scanf("%d",&e);
	fix(list,sub,e);
	output(list);
	printf("请输入要插入的位置下标");
	scanf("%d",&sub);
	printf("请输入要插入的元素");
	scanf("%d",&e);
	insert_data(list,sub,e);
	output(list);
	printf("请输入要删除的下标");
	scanf("%d",&sub);
	delete_data(list,sub);
	output(list);
//	printf("请输入要修改的元素");
//	scanf("%d",&e);
//	printf("请输入修改后的元素");
//	scanf("%d",&w);
//	fix_rear(list,e,w);
//	output(list);
	
	printf("请输入想要查找的元素");
	scanf("%d",&e);

	int ret=lookup(list,e);
	if(ret==-1){
		return -1;
	}
	printf("请输入要修改的元素");
	scanf("%d",&e);
	printf("请输入修改后的元素");
	scanf("%d",&w);

	fix_data(list,e,w);
	output(list);
	repeat(list);
	output(list);
	printf("请输入要删除的元素");
	scanf("%d",&e);
	delete_sub(list,e);
	output(list);
	//顺序表按元素插入其后继位位置
	printf("请输入要在哪个元素后插入");
	scanf("%d",&e);
	printf("请输入要插入的元素");
	scanf("%d",&w);
	insert_sub(list,e,w);
	output(list);
	//顺序表冒泡排序
	sort_list(list);
	output(list);
	free_list(list); 

	return 0;
}

fun.c

#include "head.h"
seqlist * space()
{
	seqlist * list=(seqlist *)malloc(sizeof(seqlist));
	if(list==NULL)
		return NULL;

	list->len=0;//顺序表清空
	return list;
}
int full_seqlist(seqlist * list)
{
	if(list->len==MAXSIZE){
		return -1;
	}
	
		return 0;
}
int insert_real(seqlist * list,datatype e)
{
	//判断顺序表创建是否成功
	if(list==NULL||full_seqlist(list))
	{
		printf("为不插入失败\n");
		return -1;
	}
	//在尾部插入
	list->data[list->len]=e;//在尾部插入
	list->len++;
	return 0;
}
int empty_seqlist(seqlist * list)
{
	return list->len==0?-1:0;//-1为空，0为不空

}
void output(seqlist * list)
{
	//判断顺序表创建是否成功
	//判断顺序表是否为空
	if(list==NULL||empty_seqlist(list)){
		printf("遍历失败\n");
		return;
	}
	//循环输出
	for(int i=0;i<list->len;i++){
		printf("%d\t",list->data[i]);
	}
	puts("");
}
int delete_rear(seqlist * list)
{
	//判断创建表是否创建成功
	//判断表是否为空
	//删除尾部元素
	if(list==NULL||empty_seqlist(list)){
		return -1;
	}
	list->len--;
	return 0;
}
//根据终端输入的下标查找元素
int search_sub(seqlist * list,int sub)
{
	//判断表是否创建成功，并且是否为空
	//判断下标是否合理
	//查找下标对应的元素，输出该元素
	if(list==NULL||empty_seqlist(list)||sub<0||sub>=list->len){
		printf("查找下表失败");
		return -1;
	}
	printf("查找的元素为:%d\n",list->data[sub]);
	return 0;
}
//根据终端输入的下标修改元素
int fix(seqlist *list,int sub,datatype e)
{
	if(list==NULL||empty_seqlist(list)||sub<0||sub>=list->len){
		printf("修改失败\n");
		return -1;
	}
	list->data[sub]=e;
	return 0;
}
//根据终端输入的下标插入元素
int insert_data(seqlist *list,int sub,datatype e)
{
	if(list==NULL||full_seqlist(list)||sub<0||sub>list->len){
		printf("插入失败\n");
		return -1;

	}
	for(int i=list->len-1;i>=sub;i--){
		list->data[i+1]=list->data[i];
	}
	list->data[sub]=e;
	list->len++;
	return 0;
}
//根据终端输入的下标删除对应元素
int delete_data(seqlist * list,int sub){
	//
	if(list==NULL||empty_seqlist(list)||sub<0||sub>=list->len){
		printf("删除失败\n");
		return -1;
	}
	for(int i=sub;i<list->len;i++){
		list->data[i]=list->data[i+1];
	
	}
	list->len--;
	return 0;
}
//根据输入的元素来修改元素值
int fix_rear(seqlist *list,datatype e,datatype w){
	if(list==NULL||empty_seqlist(list)){
		printf("修改失败\n");
		return -1;
		
	}
	for(int i=0;i<list->len;i++){
		if(list->data[i]==e){
		list->data[i]=w;
		}
		else{
			printf("修改的元素不存在");
		}
	}	
	return 0;
}
//根据终端输入元素来查找顺序表中对应的元素
int lookup(seqlist *list,datatype e)
{
	if(list==NULL||empty_seqlist(list)){
		printf("查找失败\n");
		return -1;
		
	}
	for(int i=0;i<list->len;i++){
		if(e==list->data[i]){
			printf("查找元素的值为%d,对应下标为%d\n",list->data[i],i);
			return i;
		}
	}
	printf("查找的元素不存在");
	return -1;
}
//根据输入的元素来修改元素值
int fix_data(seqlist *list,datatype e,datatype w)
{
	if(list==NULL||empty_seqlist(list)){
		printf("修改失败\n");
		return -1;
		
	}
		int sub=lookup(list,e);
		if(sub==-1){
			printf("查找失败\n");
			return -1;
		}
			fix(list,sub,w);

		return 0;
}
//将顺序表中重复的元素删除
int repeat(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_data(list,j);
				j--;
			}
		}
	}
	return 0;
}
//根据输入的元素来删除对应的元素
int delete_sub(seqlist * list,datatype e)
{
	int sub=lookup(list,e);
	if(sub==-1){
		return -1;
	}
	delete_data(list,sub);
	return 0;
}
int insert_sub(seqlist *list,datatype e,datatype w)
{
	int sub=lookup(list,e);
	if(sub==-1){
		return -1;
	}
	
	insert_data(list,sub+1,w);
	return 0;
}
//将顺序表进行排序
int sort_list(seqlist *list)
{
	if(list==NULL||empty_seqlist(list)){
		printf("顺序表排序失败\n");
		return -1;
	}
	int temp;
	for(int i=1;i<list->len;i++)
	{
		for(int j=0;j<list->len-i;j++){
			if(list->data[j]>list->data[j+1]){
			
			temp=list->data[j];
			list->data[j]=list->data[j+1];
			list->data[j+1]=temp;
			}

		}
	}
	return 0;
}

//释放顺序表空间
seqlist *free_list(seqlist *list)
{
	if(list==NULL){
		return NULL;

	}
	free(list);
	list=NULL;
	return list;
}

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
{
	
	datatype data[MAXSIZE];
	int len;
}student;
typedef struct
{
	datatype data[MAXSIZE];	
	int len;
}seqlist;
void output(seqlist * list);
int empty_seqlist(seqlist * list);
int insert_real(seqlist * list,datatype e);
int full_seqlist(seqlist * list);
seqlist * space();
int delete_rear(seqlist * list);
int search_sub(seqlist * list,int sub);
int fix(seqlist *list,int sub,datatype e);
int insert_data(seqlist *list,int sub,datatype e);
int delete_data(seqlist * list,int sub);
int fix_rear(seqlist *list,datatype e,datatype w);
int lookup(seqlist *list,datatype e);
int fix_data(seqlist *list,datatype e,datatype w);
int repeat(seqlist *list);
int insert_sub(seqlist *list,datatype e,datatype w);

int delete_sub(seqlist*list,datatype e);
int sort_list(seqlist *list);
seqlist *free_list(seqlist *list);



#endif

2201_75804998
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
顺序表建立学生健康表参考程序
11-02
3. **删除学生信息**：当需要删除某条记录时，可以采用移动后续元素的方法来填补被删除的位置，以保持顺序表的连续性。 4. **读取和写入文件**：这两个功能涉及到文件操作，主要是通过读写文件的方式实现对学生健康...
day03_List、Set 每日作业卷1
08-08
1. **有序性**：List接口保证了元素的顺序，即插入元素时的位置。可以通过索引来访问和修改元素，索引从0开始。 2. **可重复性**：List接口允许元素重复，可以有多个相同的元素存在于列表中。 3. **线程安全性**：...
数据结构学习记录——Day1 顺序表
weixin_43240212的博客
04-08 1559
顺序表学习，以及8种操作的实现
【嵌入式学习】数据结构-Day2-顺序表
BH6AEV的博客
12-21 1484
在链式存储结构中，线性表的元素在内存中可以是不连续的，通过指针来连接各个元素。：数据元素之间存在一对一的逻辑关系(数组，地铁的座位)头节点无直接前驱，尾节点无直接后继，中间节点存储在唯一的前驱唯一的后继。：数据元素之间存在一对多的逻辑关系(族谱，公司架构)头结点无直接前驱，尾节点无直接后继，中间节点存在唯一的直接前驱，多个后继。线性结构是一种元素之间存在一对一的关系，即每个元素都有唯一的直接前驱和直接后继。线性表：顺序表，链表，数组，栈，队列，字符串。数据类型(整数，小数，字符，字符串，汉字)
每日一题Day06 顺序表查找
LiuLong0907的博客
06-29 8618
基于顺序存储结构的图书信息表的最爱图书的查找 题目描述 定义一个包含图书信息（书号、书名、价格）的顺序表，读入相应的图书数据来完成图书信息表的创建，然后根据指定的最爱图书的名字，查找最爱的图书，输出相应图书的信息。 输入描述 总计n+m+2 行。首先输入n+1 行，其中，第一行是图书数目n，后n 行是n 本图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，价格之后没有空格。其中书号和书名为字符串类型，价格为浮点数类型。然后输入m+1 行，其中，第一行是一个整数m，代表查找m 次
每日一题Day05 顺序表查找
LiuLong0907的博客
06-29 8771
基于顺序存储结构的图书信息表的最贵图书的查找 题目描述 定义一个包含图书信息（书号、书名、价格）的顺序表，读入相应的图书数据来完成图书信息表的创建，然后查找价格最高的图书，输出相应图书的信息。 输入描述 总计输入n+1 行，其中，第一行是图书数目n，后n 行是n 本图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，价格之后没有空格。其中书号和书名为字符串类型，价格为浮点数类型。 输出描述 总计输出m+1 行，其中，第一行是最贵图书的数目（价格最高的图书可能有多本），后m行是最贵
每日一题Day04 顺序表逆序
LiuLong0907的博客
06-29 9053
基于顺序存储结构的图书信息表的逆序存储 题目描述 定义一个包含图书信息（书号、书名、价格）的顺序表，读入相应的图书数据来完成图书信息表的创建，然后将读入的图书信息逆序存储，逐行输出逆序存储后每本图书的信息。 输入描述 输入n+1 行，第一行是图书数目n，后n 行是n 本图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，价格之后没有空格。其中书号和书名为字符串类型，价格为浮点数类型。 输出描述 总计n 行，第i 行是原有图书表中第n-i+1 行的图书的信息（书号、书名、价格），每
数据结构v1——顺序表的基本操作之插入操作
Vicky
11-30 2931
时，在函数体内不需要改变主调函数中的实参变量的值，只需读取主调函数中的实参变量的值，因此函数形参定义为变量，采用值传递。，i-1上的结点，依次后移到位置n，n-1，…C++语言中用引用作函数的形参，被调函数对形参做的任何操作都影响了主调函数中的实参变量值，而操作一个变量比操作一个指针要简单的多，为了便于算法描述，本书函数参数传递机制采用有两种方式：值传递和引用传递。如果需要将函数中变化的形式参数的值反映在实际参数中，在C语言的实现中，就需要通过指针变量作形式参数，接收变量的地址，达到修改实参变量值的目的。
数据结构【顺序表】
qq_67578580的博客
07-12 1583
我们需要创建一个seqlist.h头文件，seqlist.c文件存放函数，还有一个.c的测试文件。
每日一题Day09 顺序表删除
LiuLong0907的博客
06-30 4817
基于顺序存储结构的图书信息表的旧图书的出库 题目描述 定义一个包含图书信息（书号、书名、价格）的顺序表，读入相应的图书数据来完成图书信息表的创建，然后根据指定的待出库的旧图书的位置，将该图书从图书表中删除，最后输出该图书出库后的所有图书的信息。 输入描述 总计n+2 行。首先输入n+1 行，其中，第一行是图书数目n，后n 行是n 本图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，价格之后没有空格。其中书号和书名为字符串类型，价格为浮点数类型。之后输入第n+2 行，内容仅为一个
王道C导学班 中级day3作业
weixin_47248822的博客
02-18 937
中级day3作业 初始化顺序表（顺序表中元素为整型），里边的元素是1,2,3， 然后通过scanf读取一个元素（假如插入的是6）， 插入到第2个位置，打印输出顺序表，每个元素占3个空格，格式为1 6 2 3， 然后scanf读取一个整型数，是删除的位置（假如输入为1）， 然后输出顺序表 6 2 3，假如输入的位置不合法，输出false字符串。 提醒，Language一定要选为C++。 #define MaxSize 100 #include<stdio.h> #include<
数据结构（C++版）—— 顺序表Ⅰ
ygx0073的博客
07-26 1472
一、顺序表的定义顺序表——用顺序存储的方式实现线性表顺序存储把逻辑上相邻的元素存储在物理位置上也相邻的存储单元中，元素之间的关系由存储单元的邻接关系来体现，是具有相同数据类型的n(n>0)个数据元素的有限序列。二，要实现的代码功能主要操作其他常用操作三，具体代码实现。
实验04_单表查询1
08-08
2. **SQL语句的执行顺序**：通常遵循SQL的逻辑执行顺序：FROM -> WHERE -> GROUP BY -> HAVING -> SELECT -> ORDER BY。 3. **查询语句中的标点符号**：主要包括逗号(,)用于分隔列，WHERE用于条件筛选，AS用于设置...
day03_List、Set 每日作业卷答案1
08-08
1. **有序性**：List接口保证了元素的存取顺序，当元素被添加到List中时，它们会按照添加的顺序存储，因此可以通过索引来访问元素。 2. **索引操作**：List接口中的元素都有一个唯一的索引，类似于数组，可以通过...
day02_Collection、泛型每日作业卷答案 2
08-08
`HashSet`基于哈希表，插入和查找速度快，但无特定顺序；`TreeSet`则按照元素的自然排序或自定义比较器进行排序，保证了集合内部的有序性。 在给定的代码中，我们看到两个练习题目： 练习二：这个练习要求统计`...
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
最新发布
weixin_65180740的博客
07-24 833
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
cf场+线性dp
xxx_jsu的博客
07-23 297
令a[1]=x[1]+1后我们可以让a[i+1]=a[i]+x[i]，但是这样的话数可能会比较小，所以我们可以累加a[i]，因为是mod所以只要不大于x[i+1]可以一直加下去。2.n>b-a>0这种情况我们还需要考虑到使用到的a，在此之前我们按照等差数列出售了(b-a)个，那么剩下n-(b-a)个我们则需要按照a来出售。采用双指针，一个指向a的头部，一个指向b的头部，两者开始进行匹配，若相同则b往下走一位，否则就终止。题目的第一问其实就是让我们求最长不上升子序列，第二问就是求有多少段最长不上升序列。
算法-KMP字符串匹配
xx_xb的博客
07-23 236
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
【算法】字典序最小的 01 字符串
2301_79728896的博客
07-24 226
每次只能交换相邻的两个字符,从前向后遍历字符,如果遇到10组合的要交换,同时k–,注意交换后的情况是前面有可能会出现10组合,因此k>0时要回退,直到(用while)前面没有10组合或k==0为止。小红有一个 01 字符串，她可以进行最多 k 次提作，每次操作可以交换相邻的两个字符，问可以得到的字典序最小的字符串是什么。第一行包含两个整数，n（1 < n < 10^5）和 k（1 < k < 10^9），表示字符串的长度和可以进行的操作次数。输出一个长度为 n 的字符串，表示字典序最小的字符串。
HR_ABSENCE 表中CDAY字段类型是date 怎么改
06-10
如果您需要修改`HR_ABSENCE`表中的`CDAY`字段类型，可以按照以下步骤进行： 1. 备份数据 在修改字段类型之前，最好先对表中的数据进行备份，以便出现问题时可以恢复数据。 2. 修改字段类型 可以使用`ALTER TABLE...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值