嵌入式学习-数据结构

已于 2022-07-22 00:51:20 修改
阅读量120 收藏
点赞数
文章标签： c语言 数据结构 链表
于 2022-07-20 23:08:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huang_caitou/article/details/125902214
版权

数据结构day2-链表

Linklist.h

#ifndef __LINKLIST__           
#define __LINKLIST__           
typedef char datatype;//定义数据类型                                
typedef struct Node //定义链表数据类型           
{                             
    union                      
    {                          
    datatype data;//数据域     
    int len;                   
    };                         
    struct Node *next;//指针域                            
}Linklist;                                                                               
//创建                         
Linklist *list_create();       
//判空                         
int list_empty(Linklist *L);   
//遍历                      
void listshow(Linklist *L); 
//按位置查找节点指针
Linklist *find_node(Linklist *L,int pos);
//尾删1                         
int list_delete_tail(Linklist *L);
//尾删2
int list_delete_tail2(Linklist *L);                            
//按位置修改                                                        
int list_update_pos(Linklist *L, int pos,datatype e);                                                                                 
//按值修改                                                          
int list_update_value(Linklist *L, datatype old_e, datatype new_e);                                                                   
//链表反转函数                                                      
void list_reverse(Linklist *L);

Linklist.c

#include<stdio.h>    
#include"Linklist.h" 
#include<stdlib.h>   
//尾删                                         
int list_delete_tail(Linklist *L)              
{                                              
    //判断                                     
    if(NULL==L||list_empty(L))                 
    {printf("链表为空，删除失败\n");return -1;}
    // 找到倒数第二个节点                      
    Linklist *p=L;                             
    while(p->next->next!=NULL)                 
    {p=p->next;}                               
    //标记要删除的节点                         
    Linklist *q=p->next;                       
    //置空                                     
    p->next=NULL;                              
    //释放最后节点的空间                       
    free(q);                                   
    q=NULL;                                    
    L->len--;                                  
    printf("尾删成功\n");                      
    return 0;                                  
}                                              
//尾删2                                        
int list_delete_tail2(Linklist *L)             
{                                              
    //判断                                     
    if(NULL==L||list_empty(L))                 
    {printf("链表为空，删除失败\n");return -1;}                                       
    // 找到倒数第二个节点                      
    Linklist *p=find_node(L,L->len-1);         
    //标记要删除的节点                         
    Linklist *q=p->next;                       
    //置空                                     
    p->next=NULL;                              
    //释放最后节点的空间                       
    free(q);                                   
    q=NULL;                                    
    L->len--;                                  
    printf("尾删成功\n");                      
    return 0;                                  
}     
  //按位置修改链表                                   
int list_update_pos(Linklist *L,int pos,datatype e)
{                                                  
    if(L==NULL||list_empty(L)||pos<1||pos>L->len)  
    {printf("链表为空，修改失败\n");}              
    Linklist *p=find_node(L,pos);                  
    p->data=e;                                     
    printf("位置%d修改成功\n",pos);                                                             
}         
                                         
 //按值修改链表                                                                                                                    
int list_update_value(Linklist *L, datatype old_e, datatype new_e)
{                                                                 
    if(L==NULL||list_empty(L))                                    
    {printf("链表为空，修改失败\n");}                             
    Linklist *p=L;int flag=1;                                     
    for(int i=1;i<L->len+1;i++)                                   
    {                                                             
        p=p->next;                                                
        if(p->data==old_e)                                        
        {p->data=new_e;flag=1;}                                   
    }                                                             
    if(flag==1)                                                   
    {                                                             
        printf("修改成功\n");                                     
    }                                                             
    else                                                          
    {                                                             
        printf("无重复值\n");                                     
    }                                                             
}                                                                 
//链表反置函数                                  
void list_reverse(Linklist *L)                  
{                                               
    if(NULL==L||list_empty(L))                  
    {printf("链表为空，无法排序\n");return -1;} 
    if(L->len==1)                               
    {                                           
        printf("无需排序\n",return 0;);         
    }                                           
                                                
    Linklist *p=NULL;                           
    Linklist *q=NULL;                           
    Linklist *n=NULL;                           
    for(int i=2;i<L->len+1;i++)                 
    {                                           
        p=find_node(L,i-1);                     
        q=L->next;                              
        L->next=p->next;                        
        if(i<L->len)                            
        {n=p->next->next;}                      
        else                                    
        {n=NULL;}                               
        p->next->next=q;                        
        p->next=n;                              
    }                                           
    printf("排序成功\n");                       
    return 0;                                   
}  
//反置函数第二种方法           
void list_reverse2(Linklist *L)
{                              
    Linklist *s=L->next;       
    Linklist *p=s->next;       
    L->next=NULL;              
    while(s!=NULL)             
    {                          
        p=s;                   
        s=s->next;             
                               
        p->next=L->next;       
        L->next=p;             
    }                          
return;                        
}                              
//创建链表表头（火车头）                                                                                                                         
Linklist *list_create()                              
{                                                    
    Linklist *L=(Linklist*)malloc(sizeof(Linklist)); 
    if(NULL==L)                                      
    {                                                
        printf("创建失败\n");                        
        return NULL;                                 
    }                                                
    //初始化                                         
    L->len=0;                                        
    L->next=NULL;                                    
    printf("创建成功\n");                            
    return L;                                        
}                                                    
                                                     
//判空                                               
int list_empty(Linklist *L)                          
{                                                    
    return NULL==L->next?1:0;                        
}                                                    
   //遍历函数：显示链表结果                         
void listshow(Linklist *L)      
{                               
    if(NULL==L || list_empty(L))
    {                           
        printf("链表为空\n");   
        return;                 
    }                           
    //遍历逻辑                  
    printf("链表结果为;\n");    
    Linklist *q =L->next;       
    while(q!=NULL)              
    {                           
        printf("%c\t",q->data); 
        q=q->next;              
    }                           
    printf("\n");               
    return;                     
}                               
   //按位置查找返回查找到的节点                
Linklist *find_node(Linklist *L,int pos)    
{                                           
    if(NULL==L||pos<0||pos>L->len)//判断逻辑
    {printf("查找失败\n");return NULL;}     
    //查找节点                              
    Linklist *q=L;                          
    for(int i=1;i<pos+1;i++)                
    {                                       
        q=q->next;                          
    }                                       
    return q;                               
}

main.c

#include<stdio.h>
#include"Linklist.h"
int main(int argc, const char *argv[])
{
	Linklist *L = list_create();
	if(NULL==L)
	{
	return -1;
	}
	//调用头插函数
	list_insert_head(L,'w');
	list_insert_head(L,'e');
	list_insert_head(L,'l');
	list_insert_head(L,'l');
	list_insert_head(L,'d');
	list_insert_head(L,'o');
	list_insert_head(L,'n');
	list_insert_head(L,'e');
	
	printf("尾删1测试\n");
	list_delete_tail(L);
	listshow(L);
	printf("尾删2测试\n");
	list_delete_tail2(L);
	listshow(L);
	printf("按位置修改测试\n");
	list_update_pos(L,2,'Y');
	listshow(L);
	printf("按值修改测试\n");
	list_update_value(L,'Y','L');
	listshow(L);
	printf("反置测试\n");
	list_reverse(L);
	listshow(L);
}

results

ubuntu@ubuntu:02_day$ gcc *.c
Linklist.c: In function ‘add_test’:
Linklist.c:184:6: warning: comparison of distinct pointer types lacks a cast
if(p==&p->data)
^~
ubuntu@ubuntu:02_day$ ./a.out
创建成功
头插成功
头插成功
头插成功
头插成功
头插成功
头插成功
头插成功
头插成功
尾删1测试
尾删成功
链表结果为;
e n o d l l e
尾删2测试
尾删成功
链表结果为;
e n o d l l
按位置修改测试
位置2修改成功
链表结果为;
e Y o d l l
按值修改测试
修改成功
链表结果为;
e L o d l l
反置测试
排序成功
链表结果为;
l l d o L e

运行结果输出

大黄菜头
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
嵌入式学习-02-数据结构和算法 (链表)
03-15
嵌入式学习-02-数据结构和算法 (链表)
嵌入式常见的数据结构
Zhupeizhao的博客
05-10 3627
0 引言1 线性表1.1 顺序表1.1.1 定义类型1.1.2 相关操作1.1.3 相关操作的实现1.2 链表1.2.1 定义类型1.2.2 相关操作1.2.3 相关操作的实现2 栈2.1 顺序栈2.1.1 定义类型2.1.2 相关操作2.1.3 相关操作的实现2.2 链栈2.2.1 定义类型2.2.2 相关操作2.2.3 相关操作的实现3 队列3.1 顺序队列3.1.1 定义类型3.1.2 相关操作3.1.3 相关操作的实现3.2 链队列3.2.1 定义类型3.2.2 相关操作3.2.3 相.
数据结构（一）（嵌入式学习）
JiaYu的博客
03-04 798
队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。队列是一种先进先出（First In First Out）的线性表，简称FIFO。允许插入的一端称为队尾，允许删除的一端称为队头。队头（Front）：允许删除的一端，又称队首。队尾（Rear）：允许插入的一端。空队列：不包含任何元素的空表。
c++数据结构代码整理_嵌入式：经典数据结构
weixin_39721924的博客
11-25 188
1.什么是数据结构？如果我们现在要整理图书，有一堆书， 怎么整理呢？最简单一种一个挨着一个放；或者给图书分类，按照大分类再细分类整合；或者直接细分拆成很多类，每一类之间肯定会有很多的关系；但是有没有想过这个书是要放在哪里的？要在什么环境下保存？这就需要给每种整理方法换个角度考虑，是都放在一个书架的一层呢，还是放在不同的书架隔层，又或者是放在图书馆里不同的书架上；这个提到的整理图书讨论的东西，就是数...
嵌入式培训经验分享——数据结构
x2751961352的博客
08-16 328
嵌入式培训经验分享——数据结构
嵌入式学习-02-数据结构和算法 (数组)
03-15
嵌入式学习-02-数据结构和算法 (数组)
嵌入式数据结构基础学习
08-26
嵌入式数据结构是指将一个数据结构嵌入到另一个...嵌入式数据结构的应用：学习如何使用嵌入式数据结构表示硬件寄存器、设备驱动程序和网络协议等实际应用场景。掌握读写操作以及与硬件或其他系统组件进行交互的方法。
嵌入式C与数据结构实战入门
07-27
嵌入式C与数据结构实战入门
嵌入式软件中的数据结构
09-27
我们在嵌入式开发中常用的几种数据结构，非常适合嵌入式开发者学习，内容也很实用。
【嵌入式学习历程8】数据结构之链表
華仔的博客
12-02 373
记得以前上C语言课的时候，只要提到链表，脑海里就只有两个词，一是高大上，二是难。今天让我们来看看链表到底是何方神圣。高手还请多多指教！ （注：今主要讨论单链表。链表分为单链表、静态链表、循环链表和双向链表） 一、定义：链表是线性表的链接存储表示 二、特点：每个元素(表项)由结点(Node)构成。 1. 结点可以连续，可以不连续存储 2. 结点的逻辑顺序与物理顺序可以不一致 3. 表
嵌入式系统的数据结构与算法
YellowMax
01-13 4753
嵌入式系统数据结构
FourLeafCloverLLLS的博客
10-13 1294
由于操作系统具有与普通软件不同的任务, 因此它就有些不同的特点, 包括一些不同的数据结构, 常用数据结构如下 一. 程序控制块 typedef struct tcb { char* code_name; //代码名称 int p; //重要性级别 int V_num; //版本号 void (*fun)(void); //指向被管理代码的函数指针 }TCB; 为了把这...
如何学习嵌入式软件
热门推荐
一个人要像一支队伍
02-03 2万+
什么是嵌入式？ 嵌入式分为广义和狭义两种。广义的嵌入式就是片上系统(system on a chip)，包括单片机、PSOC、NIOS、Microblaze等。而狭义的嵌入式就是ARM9、cortex A8等特定的跑操作系统的芯片。这里主要介绍狭义嵌入式的学习路线。 还是主流的方法，先学会使用它，再深入研究底层。 常用的嵌入式操作系统有Linu...
嵌入式学习之路（十九）——数据结构（1）
紫瞳标的专栏
01-06 1123
嵌入式学习之路（十九）——数据结构（1） 今天我们先来看一下数据结构吧,C语言就先讲到这里，以后还有很多机会深入学习的 毕竟C语言在嵌入式的学习过程中是很重要的 今天我们先来看看 1.冒泡排序 2.插入排序 3.选择排序 4.快速排序 一。冒泡排序 算法思路：     1.从第一个元素开始，相邻的两个做比较，如果前面大于后面，交换位置到最后     第一轮结束，最大的在最
linux驱动-CCF-1 provider 注册时钟
2401_83458819的博客
04-24 418
struct clk_hw_onecell_data onecell 填充到struct of_clk_provider *cp 中的data。struct clk_hw 组成 struct clk_hw_onecell_data onecell。b. 调用 of_clk_add_hw_provider 根据 进一步生成of_clk_provider ，并添加到全局列表。void *data;//对应 clk_hw_onecell_data（包含clk provider 注册的所有数组）
【数据结构】三、栈和队列：2.顺序栈&共享栈（顺序栈的初始化，判空，进栈，出栈，读取栈顶，顺序栈实例）
来csdn只办三件事：开源！开源！还是***开源！
04-23 1150
因为顺序栈的缺点是栈的大小不可变，所以引出共享栈，两个栈共享一片空间。这片存储空间不单独属于任何一个栈，某个栈需要的多一点，它就可能得到更多的存储空间。两个栈的栈底在这片存储空间的两端，当元素入栈时，两个栈的栈顶指针相向而行。当他们下一个指针的位置在一起时，说明这个栈已经放满元素。C++是一门面向对象的高级语言，在我们编写代码中，常常离不开对对象的创建和清理对象资源。指向栈顶元素，一般存储的是数组的下标。top当前指向的位置是栈顶上面的一个没有元素的空位置。如果有abcde，5个元素，那么满栈top=4。
【Redis 开发】(Feed流的模式，GEO数据结构，BitMap,HyperLogLog)
最新发布
weixin_62513677的博客
04-27 565
如果我们需要统计UV值，我们可以使用HyperLogLog，它是从LogLog算法中派生出来的概率算法，用于确定非常大的集合的基数，但是它的单个存储的统计内存永远小于16kb，但是代价就是统计是概率性的有小于0.81%的误差，不过可以忽略。也叫做写扩散，发布的消息不需要写入到发件箱中，直接推送到被关注人的收件箱中并通过时间戳进行排序，延时低，但是比如说微博中的一些大V，粉丝人特别多，这样就会写很多。范围可以是圆形或矩形。:指定圆心、半径，找到该圆内包含的所有member，并按照与圆心之间的距离排序后返回。
数据结构中的串（String）：概念、操作和实际应用
JAZJD的博客
04-24 945
在计算机科学中，串 是由零个或多个字符组成的有限序列，是数据结构中常见的一种基本类型。它可以为空串，也可以是由字符组成的非空串。串通常用于表示文本数据，如文件内容、用户输入等，因此在算法和程序设计中占据着重要的地位。一个串可以是由字母、数字、符号等任意字符组成，字符的种类和个数没有固定限制。例如，"Hello, World!@#$%" 都是串的例子。串的重要性在于它是对文本数据进行处理和操作的基础，涉及字符串匹配、文本编辑、编译器设计等多个领域。因此，深入理解串的特性和操作对于程序设计人员至关重要。
单片机嵌入式学习路线
04-03
单片机嵌入式学习路线可以分为以下几个阶段： 1. 基础知识学习阶段： - 学习数字电路和模拟电路的基础知识，了解逻辑门、集成电路等基本概念。 - 学习C语言编程基础，包括语法、数据类型、控制结构等。 - 学习...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值