嵌入式7-19作业

已于 2022-07-20 19:18:58 修改
阅读量542 收藏
点赞数
文章标签： 数据结构 算法
于 2022-07-19 18:12:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_59751955/article/details/125876360
版权

数据结构day1

seqlist.h （库文件）

下面展示 源代码。

#ifndef __SEQLIST_H__
#define __SEQLIST_H__
#define MAX 20

typedef int datatype;
typedef struct
{
	datatype data[MAX];
	int len;
}seqList;

//创建顺序表
seqList *listCreate();

//添加元素
int listAdd(seqList *S, datatype e);

//判空
int listempty(seqList *S);

//判满
int listFull(seqList *S);

//遍历
void listShow(seqList *S);

//任意位置插入
int listInsertPos(seqList *S, int pos, datatype e);

//删除
int listDeletePos(seqList *S, int pos);

//按值查找成功后返回下标
int listSearchValue(seqList *S, datatype e);

//按位置查找成功后返回值
datatype listSearchPos(seqList *S, int pos);

//按值修改
int listUpdateValue(seqList *S, datatype old_e, datatype new_e);

//按位置修改
int listUpdatePos(seqList *S, int pos, datatype new_e);

//排序
void listSort(seqList *S);

//去重
void listUnique(seqList *S);

//选择排序降序
void listChooseSort(seqList *S);

//释放表
void listFree(seqList **S);

#endif

seqlist.c （函数封装）

1、作业函数

1.1 按值修改。

//按值修改
int listUpdateValue(seqList *S, datatype old_e, datatype new_e)
{
	int i;
	if(listEmpty(S))
	{
		printf("修改失败，表为空\n");
		return -1;
	}
	for(i=0; i<S->len; i++)
	{
		if(S->data[i] == old_e)
		{
			S->data[i] = new_e;
			printf("修改成功\n");
			return 0;
		}
	}
	if(i == S->len)
	{
		printf("修改失败，旧值不存在\n");
		return -2;
	}
}

1.2按位置查找返回值

//按位置查找返回值
datatype listSearchPos(seqList *S, int pos)
{
	if(listEmpty(S))
	{
		return -1;			//判断为空返回-1
	}
	else if(pos<0 || pos>=S->len)
	{
		return -2;			//输入不合法返回-2
	}
	for(int i=0; i<S->len; i++)
	{
		if(pos == i)
		{
			return S->data[i];
		}
	}
}

主函数内容

	//按位置查找返回值
	res = listSearchPos(S, 8);
	if(res >= 0)
	{
		printf("查找成功，值为%d\n", res);
	}
	else if(res == -1)
	{
		printf("查找失败，表为空\n");
	}
	else if(res == -2)
	{
		printf("查找失败，输入位置不合法\n");
	}

1.3选择排序降序

//选择排序降序
void listChooseSort(seqList *S)
{
	int i, j;
	int max, temp, index;
	for(i=0; i<S->len; i++)
	{
		index = i;
		max = S->data[i];
		for(j=i+1; j<S->len; j++)
		{
			if(S->data[j] > max)
			{
				max = S->data[j];
				index = j;
			}
		}
		temp = S->data[i];
		S->data[i] = S->data[index];
		S->data[index] = temp;
	}
}

2、全部函数

下面展示 源代码。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include"seqlist.h"

//创建顺序表
seqList *listCreate()
{
	//在堆区申请一个顺序表的空间，将申请的地址给S	
	seqList *S = (seqList*)malloc(sizeof(seqList));
	if(NULL == S)
	{	
		printf("申请空间失败\n");
		return NULL;
	}

	memset(S->data, 0, sizeof(S->data));
	S->len = 0;
	printf("创建成功\n");
	return S;
}

//判空
int listEmpty(seqList *S)
{
	if(NULL == S)
	{
		printf("所给顺序表不合法\n");
		exit(0);
	}
	return S->len==0 ? 1:0;		//0表示非空，1表示空
}

//判满
int listFull(seqList *S)
{
	return S->len==MAX ? 1:0;		//0表示不满，1表示满
}

//添加元素
int listAdd(seqList *S, datatype e)
{
	//判断逻辑
	if(listFull(S))
	{
		printf("表满，添加失败\n");
		return -1;
	}

	//添加逻辑
	S->data[S->len] = e;
	
	//表的变化
	S->len++;
	printf("添加成功\n");
	return 0;
}

//遍历函数
void listShow(seqList *S)
{
	//判断逻辑
	if(listEmpty(S))
	{
		printf("表为空\n");
		return;
	}
	printf("目前顺序表中元素分别是：");
	for(int i=0; i<S->len; i++)
	{
		printf("%d\t", S->data[i]);
	}
	printf("\n");
}

//任意位置插入
int listInsertPos(seqList *S, int pos, datatype e)
{
	if(listFull(S))
	{
		printf("表已满\n");
		return -1;
	}
	else if(pos<0 || pos>S->len)
	{
		printf("输入的位置不合法\n");
		return -2;
	}
	for(int i=S->len-1; i>=pos; i--)
	{
		S->data[i+1] = S->data[i];
	}
	S->data[pos] = e;
	S->len++;
	printf("插入成功\n");
	return 0;
}

//删除
int listDeletePos(seqList *S, int pos)
{
	if(listEmpty(S))
	{
		printf("表为空\n");
		return -1;
	}
	else if(pos<0 || pos>S->len-1)
	{
		printf("输入位置不合法\n");
		return -2;
	}
	for(int i=pos; i<S->len; i++)
	{
		S->data[i] = S->data[i+1];
	}
	S->len--;
	printf("删除成功\n");
	return 0;
}

//按值查找返回下标
int listSearchValue(seqList *S, datatype e)
{
	if(listEmpty(S))
	{
		return -1;
	}
	for(int i=0; i<S->len; i++)
	{
		if(S->data[i] == e)
		{
			return i;
		}
	}
		return -2;
}

//按位置查找返回值
datatype listSearchPos(seqList *S, int pos)
{
	if(listEmpty(S))
	{
		return -1;
	}
	else if(pos<0 || pos>=S->len)
	{
		return -2;
	}
	for(int i=0; i<S->len; i++)
	{
		if(pos == i)
		{
			return S->data[i];
		}
	}
}

//按值修改
int listUpdateValue(seqList *S, datatype old_e, datatype new_e)
{
	int i;
	if(listEmpty(S))
	{
		printf("修改失败，表为空\n");
		return -1;
	}
	for(i=0; i<S->len; i++)
	{
		if(S->data[i] == old_e)
		{
			S->data[i] = new_e;
			printf("修改成功\n");
			return 0;
		}
	}
	if(i == S->len)
	{
		printf("修改失败，旧值不存在\n");
		return -2;
	}
}

//按位置修改
int listUpdatePos(seqList *S, int pos, datatype new_e)
{
	if(listEmpty(S))
	{
		printf("修改失败，表为空\n");
		return -1;
	}
	else if(pos<0 || pos>=S->len)
	{
		printf("修改失败，输入的位置不合法\n");
		return -2;
	}
	for(int i=0; i<S->len; i++)
	{
		if(i == pos)
		{
			S->data[i] = new_e;
			printf("修改成功\n");
			return 0;
		}
	}
}

//排序
void listSort(seqList *S)
{
	int i, j;
	datatype temp;
	if(listEmpty(S))
	{
		printf("排序失败，表为空\n");
	}
	for(i=1; i<S->len; i++)
	{
		for(j=0; j<S->len-i; j++)
		{
			if(S->data[j] > S->data[j+1])
			{
				temp = S->data[j];
				S->data[j] = S->data[j+1];
				S->data[j+1] = temp;
			}
		}
	}
}

//去重
void listUnique(seqList *S)
{
	int i, j, k;
	if(S->len<=1)
	{
		printf("去重失败\n");
	}
	for(i=0; i<S->len; i++)
	{
		for(j=i+1; j<S->len; j++)
		{
			if(S->data[i] == S->data[j])
			{
				listDeletePos(S, j);
				j--;
			}
		}
	}
	printf("去重成功\n");
}

//选择排序降序
void listChooseSort(seqList *S)
{
	int i, j;
	int index;
	int max, temp;
	for(i=0; i<S->len; i++)
	{
		index = i;
		max = S->data[i];
		for(j=1; j<S->len-i; j++)
		{
			if(S->data[j] > max)
			{
				max = S->data[j];
				index = j;
			}
		}
		temp = S->data[i];
		S->data[i] = S->data[index];
		S->data[index] = temp;
	}
}

//释放表
void listFree(seqList **S)
{
	if(NULL != *S)
	{
		free(*S);
	}
	*S = NULL;
	printf("释放成功\n");
}

main.c （主函数）

下面展示 源代码。

#include<stdio.h>
#include<stdlib.h>
#include"seqlist.h"

int main(int argc, const char *argv[])
{
	seqList *S = listCreate();
	if(NULL == S)
	{
		return -1;
	}

	//调用添加函数
	listAdd(S, 7);
	listAdd(S, 2);
	listAdd(S, 5);
	listShow(S);

	//任意位置插入
	listInsertPos(S, 3, 7);
	listInsertPos(S, 4, 7);
	listInsertPos(S, 5, 5);
	listInsertPos(S, 6, 7);
	listShow(S);

	//任意位置删除
	listDeletePos(S, 6);
	listShow(S);

	//按值查找
	int res = listSearchValue(S, 8);
	if(res>=0)
	{
		printf("查找成功，下标为%d\n", res);
	}
	else if(res == -1)
	{
		printf("表为空，查找失败\n");
	}
	else if(res == -2)
	{
		printf("查找失败，没有该值\n");
	}

	//按位置查找返回值
	res = listSearchPos(S, 8);
	if(res >= 0)
	{
		printf("查找成功，值为%d\n", res);
	}
	else if(res == -1)
	{
		printf("查找失败，表为空\n");
	}
	else if(res == -2)
	{
		printf("查找失败，输入位置不合法\n");
	}
	//按值修改
	listUpdateValue(S, 10, 100);
	listShow(S);
	
	//按位置修改
	listUpdatePos(S, 8, 10);
	listShow(S);
	
	//排序
	listSort(S);
	listShow(S);

	//去重
	listUnique(S);
	listShow(S);

	//选择排序降序
	listChooseSort(S);
	listShow(S);

	//释放表
	listFree(&S);

	return 0;
}

部分结果展示

在这里插入图片描述

xiaoin*
关注
嵌入式大作业
qq_45964335的博客
03-16 1289
一个常用的固件库的文件是：stm32f10x.h，这个文件是微控制器专用头文件，包含了STM32F10x全系列所有外设寄存器的定义（寄存器的基地址和布局）、位定义、中断向量表、存储空间的地址映射等，在程序设计中经常进行使用。其中特权级可以执行任何指令，可以访问所有范围的存储器（如果有MPU，需要在MPU规定禁区之外），所以异常服务程序必须在特权级下执行，用户级只能执行部分指令，不能对系统控制空间（SCS）中的寄存器（如NVIC、SYSTICK、MPU）进行操作。在该模式下，所有代码都是特权访问的。
链表线性表的c语言实现方式 seqlist.h 和 seqlist.c
chen1540524015的博客
07-09 2403
.h 文件#ifndef _SEQLIST_H_ #define _SEQLIST_H_ #include <stdio.h> #include <stdlib.h> #include <string.h> //线性表 //线性表顺序存储 类似于数组，存的元素节点,只有业务节点， //业务节点之间没有关系,线性关系不是链性关系，可以[]操作 typedef void List; typedef vo
实现一个顺序存储的线性表+实现一个链接存储的线性表
Bessie_Lee
09-21 1805
第一关：顺序存储的线性表 #include <stdio.h> #include <stdlib.h> #include "Seqlist.h" SeqList* SL_Create(int maxlen) // 创建一个顺序表 // 与SqLst_Free()配对 { SeqList* slist=(SeqList*)malloc(sizeof(SeqList)); slist->data = (T*)malloc(sizeof(T)*maxlen);
数据结构（C语言）—顺序表
D卡戎的博客
12-26 251
一、基本概念 数据结构（Data Structure）概念： 数据结构是研究组成数据的数据元素的关系的学科。 数据结构研究目的 ： 通过研究数据元素的关系，帮助我们在开发软件的时候更好的组件数据模型，让数据在内存中的操作更加的流畅高效。 数据 ->信息的载体，是能够输入到计算机中并且能被计算机识别、存储和处理的符号总称。 数据元素->数据的基本单位，又称之为记录（Record）。 ...
#include 「stdlib.h」
西红柿炒鸡蛋
07-04 1735
#include <stdlib.h> #include <stdio.h> /* */ void Lib_Text1() { char* Str_Number = "3,14"; double Digital_Number= atof(Number); printf("%lf", Digital_Number); } void STDLIB_TEXT() { //atof()使用方法 Lib_Text1(); }
循序表的（SeqList.c）（函数实现）
NF0102的博客
07-27 802
#include "SeqList.h" #include <stdlib.h> #include <stdio.h>SeqList *Create_List() { // 创建一个顺序表 SeqList* s = (SeqList*)malloc(sizeof(SeqList)/sizeof(char)); if (s == NULL) { retu
2.1实现一个顺序存储的线性表（educoder数据结构线性表实训题）
weixin_51575278的博客
07-26 9444
任务描述 本关任务：实现 step1/Seqlist.cpp 中的SL_InsAt、SL_DelAt和SL_DelValue三个操作函数，以实现线性表中数据的插入、删除与查找等功能。 相关知识 线性表是最基本、最简单、也是最常用的一种数据结构。线性表结构中，数据元素之间通过一对一首尾相接的方式连接起来。具体实现时，线性表可以采用不同的存储策略。下面给出了一种基于顺序存储的线性表实现方案： 该方案将线性表存储在一片连续空间里，并通过data、len和max三个属性元素。组织成为一个结构： dat
嵌入式初学-C语言-练习三
MaBaB的博客
08-03 1916
1 /*2 计算 1+1/(2*3)+1/(3*4)+...+1/(n*(n+1))=?直到最后一相值小于0.00001为至。
5嵌入式系统设计大作业题目.pdf
06-25
这些作业题目体现了嵌入式系统设计的多样性，从家用电器到工业控制，从通信到安全，都需要学生具备扎实的电子技术、单片机编程、系统集成和问题解决能力。通过这些实践项目，学生将不仅学习到理论知识，还能获得宝贵...
东师21春《嵌入式系统》在线作业2_2参考答案.docx
10-24
19. **嵌入式操作系统特点**：实时性、内核小和可裁剪是嵌入式操作系统的特征，而不包括不可移植性。 20. **嵌入式Linux基本元素**：基本元素包括系统引导程序、Linux内核和文件系统，不包括初始化过程。 21. **...
东师21春《嵌入式系统》在线作业1_2参考答案.docx
10-24
19. **嵌入式系统特性**：嵌入式系统通常具有专用性，针对特定应用而设计。 20. **ENTRY 与源文件**：一个程序可以有多个源文件和一个以上的 ENTRY，但一个源文件只能有一个 ENTRY（可无）。 21. **寄存器操作**：...
大学2021年2月嵌入式原理与开发作业考核试题6答案参考.docx
07-06
这篇文档包含了2021年2月大连理工大学《嵌入式原理与开发》课程的作业考核试题及答案，主要涉及嵌入式系统的基础知识，包括UART、PWM、嵌入式系统定义、ARM指令集、寄存器、内存管理、通信协议、微处理器特性等多个...
线性表(List)---顺序存储结构
StrugglingMice的博客
07-07 1188
线性表(List)—顺序存储结构的设计与实现线性表顺序结构的设计线性表顺序存储结构：用一段地址连续地存储单元依次存放 线性表的数据元素。 定义一个结构体用存储数据typedef struct _tag_SeqList { int Length;//长度 int Capacity;//容量 unsigned int **node; }TSeqList; int Capacit
数据结构-二叉树及其遍历
宁zz的博客
11-15 540
本篇文章咱们聊聊数据结构中的树，准确的说因该是只说一说二叉树以及相关的三种递归遍历、三种非递归遍历以及层次遍历。🍃二叉树 (BinaryTree) 是 n (n>0) 个结点所构成的集合，它或为空树(n-0)或为非空树，对于非空树(1) 有且仅有一个称之为根的结点:(2) 除根结点以外的其余结点分为两个互不相交的子集 TI 和 T2，分别称为 T 的左子树和右子树，且 T1 和 T2 本身又都是二叉树。🍃二叉树与树一样具有递归性质，二叉树与树的区别。
数据结构-递归函数的调用栈过程
qq_52291558的博客
11-12 211
这道题考察的是递归函数的调用栈过程。
数据结构-线性表-具有独立头节点的双向循环链表
最新发布
2301_76819732的博客
11-15 533
双向循环链表是一种在链表基础上拓展而来的数据结构。与普通链表不同的是，它的每个节点都有两个指针，一个指向前驱节点（prior），一个指向后继节点（next而且，它是循环的，即链表的尾节点的后继指针指向头节点，头节点的前驱指针指向尾节点，形成一个闭合的环。我们这里讨论的双向循环链表还有一个独立的头节点。这个独立头节点不存储数据，主要用于方便对链表的操作和维护。这种链表为空的条件是头节点的next和prior指针都指向NULL。在代码中，首先定义了链表节点的数据类型。} Node;这里，
数据结构——重排链表（经典题目，涉及三个知识点）
vavid的专栏
11-15 262
算法思想：将链表分成两半来处理，前半部分，和后半部分；针对后半部分进行逆序，再从前半部分和逆序后的后半部分分别取一个结点组成一个新的链表。本文采用的正向遍历，前面文章采用的递归，都要掌握。3、合并前半段链表和后半段链表。，采用了快慢指针的算法。
数据结构 ——— 层序遍历链式二叉树
weixin_55341642的博客
11-13 603
利用队列先进先出的性质实现层序遍历链式二叉树
【数据结构初阶】栈和队列的建立
twlw13的博客
11-15 697
是一种特殊的，它只允许一端进行操作，这一端被称为则另一端被称为而栈内的数据遵循后进后出，先进后出栈的插入操作被称为插入的数据在栈顶栈的删除操作被称为删除的数据也在栈顶那我们要如何实现栈这个特殊的线性表呢？在前面我们学过顺序表和链表，而栈的实现也可以使用顺序表或者链表来实现，那使用哪一种更好呢？用顺序表来实现栈本质上就是，根据栈的特性：后进后出，先进后出可知，而使用链表实现栈，则最好是，进行，但使用链表需要用到指针会比使用数组麻烦很多，所以我们大多数时候使用数组来实现栈，但链表也是可以的，
嵌入式主流操作系统深度对比与分析：Linux、Uc/os II、uCLinux等
本文由周江同学（学号104611193，专业计算机科学与技术，班级C19）针对2010年十一月提交的专业作业，对主流的嵌入式操作系统进行了深入分析。 首先，文章明确了嵌入式操作系统的定义，它是一种高度定制的系统软件，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值