上官Linux学习第二天

最新推荐文章于 2024-09-05 11:40:28 发布
最新推荐文章于 2024-09-05 11:40:28 发布
阅读量380 收藏 5
点赞数 5
分类专栏： 上官学习笔记 文章标签： 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64879837/article/details/141752094
版权

一、链表

1.简介

        链表是物理存储单元上非连续的、非顺序的存储结构，数据元素的逻辑顺序是通过链表的指针地址实现，有一系列结点（地址）组成，结点可动态的生成。

2.与数组的区别

（1）数组

        使用一块连续的内存空间地址去存放数据。

（2）链表

        使用多个不连续的内存空间去存储数据， 可以 节省内存资源（只有需要存储数据时，才去划分新的空间），对数据的增删比较方便。

        代码：

#include <stdio.h>

struct Test
{
        int data;
        struct Test *next;
};

int main()
{
        int arr[3]={1,2,3};
        int i;
        for(i=0;i<sizeof(arr)/sizeof(arr[0]);i++)
        {
                printf("%d  ",arr[i]);
        }
        printf("\n");
        struct Test t1 = {1,NULL};
        struct Test t2 = {2,NULL};
        struct Test t3 = {3,NULL};
        t1.next = &t2;
        t2.next = &t3;
        printf("use t1 to print three num \n");
        printf("%d %d %d\n",t1.data,t1.next -> data,t1.next->next -> data);
        return 0;
}
运行结果：

3.链表的静态添加和动态遍历

如果需要加一项内容，数组需要重新进行合适的数组，而链表可以直接进行链接即可

代码：
#include <stdio.h>

struct Test
{
        int data;
        struct Test *next;
};

void printlink(struct Test *head)
{
        while(head != NULL)
        {
                printf("%d  ",head->data);
                head = head->next;
        }
        putchar('\n');
}

int main()
{
        int arr[3]={1,2,3};
        int i;
        for(i=0;i<sizeof(arr)/sizeof(arr[0]);i++)
        {
                printf("%d  ",arr[i]);
        }
        printf("\n");
        struct Test t1 = {1,NULL};
        struct Test t2 = {2,NULL};
        struct Test t3 = {3,NULL};

        struct Test t4 = {4,NULL};
        struct Test t5 = {5,NULL};
        struct Test t6 = {6,NULL};

        t1.next = &t2;
        t2.next = &t3;
        t3.next = &t4;
        t4.next = &t5;
        t5.next = &t6;
        printf("use t1 to print three num \n");
        printlink(&t1);
        //printf("%d %d %d\n",t1.data,t1.next -> data,t1.next->next -> data);
        return 0;
}
运行结果：

4.链表的节点个数与查找

代码：
#include <stdio.h>

struct Test
{
        int data;
        struct Test *next;
};

void printlink(struct Test *head)
{
        while(head != NULL)
        {
                printf("%d  ",head->data);
                head = head->next;
        }
        putchar('\n');
}

int getlinkcount(struct Test *head)
{
        int cnt = 0;
        while(head != NULL)
        {
                cnt++;
                head = head->next;
        }
        return cnt;
}

int searchlink(struct Test *head,int data)
{
        while(head != NULL)
        {
                if(head->data = data)
                {
                        return 1;
                }
                head = head->next;
        }
        return 0;
}


int main()
{
        int arr[3]={1,2,3};
        int i;
        for(i=0;i<sizeof(arr)/sizeof(arr[0]);i++)
        {
                printf("%d  ",arr[i]);
        }
        printf("\n");
        struct Test t1 = {1,NULL};
        struct Test t2 = {2,NULL};
        struct Test t3 = {3,NULL};

        struct Test t4 = {4,NULL};
        struct Test t5 = {5,NULL};
        struct Test t6 = {6,NULL};

        t1.next = &t2;
        t2.next = &t3;
        t3.next = &t4;
        t4.next = &t5;
        t5.next = &t6;
        printf("use t1 to print three num \n");
        printlink(&t1);
        int ret = getlinkcount(&t1);
        printf("total number is:%d\n",ret);
        ret = searchlink(&t1,1);
        if(ret == 1)
        {
                printf("have 1\n");
        }else{
                printf("no 1\n");
        }

        //printf("%d %d %d\n",t1.data,t1.next -> data,t1.next->next -> data);
        return 0;
}
运行结果：

5.链表从指定节点后方插入

        通过将插入值（new）插入到前一个（3）的后端，让前一个（3）的下一个节点（4）赋给插入值（new），再将插入值（new）的节点赋给前一个（3）

代码：
#include <stdio.h>

struct Test
{
        int data;
        struct Test *next;
};

void printlink(struct Test *head)
{
        struct Test *p = head;
        while(p != NULL)
        {
                printf("%d  ",p->data);
                p = p->next;
        }
        putchar('\n');
}

int getlinkcount(struct Test *head)
{
        struct Test *p = head;
        int cnt = 0;
        while(p != NULL)
        {
                cnt++;
                p = p->next;
        }
        return cnt;
}

int searchlink(struct Test *head,int data)
{
        struct Test *p = head;
        while(p != NULL)
        {
                if(p->data = data)
                {
                        return 1;
                }
                p = p->next;
        }
        return 0;
}

int insertlink(struct Test *head,int data,struct Test *new)
{
        struct Test *p = head;
        while(p != NULL)
        {
                if(p->data == data ){
                        new->next = p->next;
                        p->next = new;
                        return 1;
                }
                p = p->next;
        }
        return 0;

}


int main()
{
        int arr[3]={1,2,3};
        int i;
        for(i=0;i<sizeof(arr)/sizeof(arr[0]);i++)
        {
                printf("%d  ",arr[i]);
        }
        printf("\n");
        struct Test t1 = {1,NULL};
        struct Test t2 = {2,NULL};
        struct Test t3 = {3,NULL};

        struct Test t4 = {4,NULL};
        struct Test t5 = {5,NULL};
        struct Test t6 = {6,NULL};

        t1.next = &t2;
        t2.next = &t3;
        t3.next = &t4;
        t4.next = &t5;
        t5.next = &t6;
        printf("use t1 to print three num \n");
        printlink(&t1);
        int ret = getlinkcount(&t1);
        printf("total number is:%d\n",ret);
        ret = searchlink(&t1,1);
        if(ret == 1)
        {
                printf("have 1\n");
        }else{
                printf("no 1\n");
        }
        struct Test new={100,NULL};
        insertlink(&t1,6,&new);
        puts("after insert is:");
        printlink(&t1);
        //printf("%d %d %d\n",t1.data,t1.next -> data,t1.next->next -> data);
        return 0;
}
运行结果：

6.链表删除节点

删除链表节点两种类型：

（1）删除头

 换头，直接指向下一个节点，以下一个节点作为头

（2）删除其他

  直接越过需要删除的这个链表节点，例如1，2，3；直接1，3

代码：
#include <stdio.h>

struct Test
{
        int data;
        struct Test *next;
};

void printlink(struct Test *head)
{
        struct Test *p = head;
        while(p != NULL)
        {
                printf("%d  ",p->data);
                p = p->next;
        }
        putchar('\n');
}

int getlinkcount(struct Test *head)
{
        struct Test *p = head;
        int cnt = 0;
        while(p != NULL)
        {
                cnt++;
                p = p->next;
        }
        return cnt;
}

int searchlink(struct Test *head,int data)
{
        struct Test *p = head;
        while(p != NULL)
        {
                if(p->data = data)
                {
                        return 1;
                }
                p = p->next;
        }
        return 0;
}

int insertlink(struct Test *head,int data,struct Test *new)
{
        struct Test *p = head;
        while(p != NULL)
        {
                if(p->data == data ){
                        new->next = p->next;
                        p->next = new;
                        return 1;
                }
                p = p->next;
        }
        return 0;

}

struct Test* deletNode(struct Test *head,int data)
{
        struct Test *p = head;
        if(p->data == data){
                head = head->next;
                //free()p;
                return head;
        }
        while(p->next != NULL)
        {
                if(p->next->data == data)
                {
                        //strct Test *tmp = p;
                        p->next = p->next->next;
                        //free(tmp);
                        return head;
                }
                p = p->next;
        }
        return head;
}
int main()
{
        struct Test *head = NULL;

        struct Test t1 = {1,NULL};
        struct Test t2 = {2,NULL};
        struct Test t3 = {3,NULL};

        struct Test t4 = {4,NULL};
        struct Test t5 = {5,NULL};
        struct Test t6 = {6,NULL};

        t1.next = &t2;
        t2.next = &t3;
        t3.next = &t4;
        t4.next = &t5;
        t5.next = &t6;

        head = &t1;

        printlink(head);

        head = deletNode(head,6);
        printlink(head);

        return 0;
}

运行结果：

7.动态创建

(1)头插法

代码：
#include <stdio.h>
#include <stdlib.h>

struct Test
{
        int data;
        struct Test *next;
};

void printlink(struct Test *head)
{
        struct Test *p = head;
        while(p != NULL)
        {
                printf("%d  ",p->data);
                p = p->next;
        }
        putchar('\n');
}

int getlinkcount(struct Test *head)
{
        struct Test *p = head;
        int cnt = 0;
        while(p != NULL)
        {
                cnt++;
                p = p->next;
        }
        return cnt;
}

int searchlink(struct Test *head,int data)
{
        struct Test *p = head;
        while(p != NULL)
        {
                if(p->data = data)
                {
                        return 1;
                }
                p = p->next;
        }
        return 0;

}

struct Test* deletNode(struct Test *head,int data)
{
        struct Test *p = head;
        if(p->data == data){
                head = head->next;
                //free()p;
                return head;
        }
        while(p->next != NULL)
        {
                if(p->next->data == data)
                {
                        //strct Test *tmp = p;
                        p->next = p->next->next;
                        //free(tmp);
                        return head;
                }
                p = p->next;
        }
        return head;
}

struct Test* insertFromHead(struct Test *head,struct Test *new)
{
        if(head == NULL)
        {
                head = new;
        }else{
                new->next = head;
                head = new;
        }
        return head;
}

struct Test *creatLink(struct Test *head)
{
        struct Test *new;
        while(1){
                new = (struct Test *)malloc(sizeof(struct Test));
                printf("input your new node data:\n");
                scanf("%d",&(new->data));
                if(new->data == 0)
                {
                        printf("0 quit\n");
                        free(new);
                        return head;
                }
                head = insertFromHead(head,new);
        }
}
int main()
{
        struct Test *head = NULL;
        head = creatLink(head);
        printlink(head);
        struct Test t1 = {100,NULL};
        head = insertFromHead(head,&t1);
        printlink(head);
    return 0;
}
运行结果：

(2)尾插法

通过尾部链表节点的特性 t5 = NULL就可以从尾部进行插入

 

代码：
#include <stdio.h>
#include <stdlib.h>

struct Test
{
        int data;
        struct Test *next;
};

void printlink(struct Test *head)
{
        struct Test *p = head;
        while(p != NULL)
        {
                printf("%d  ",p->data);
                p = p->next;
        }
        putchar('\n');
}

int getlinkcount(struct Test *head)
{
        struct Test *p = head;
        int cnt = 0;
        while(p != NULL)
        {
                cnt++;
                p = p->next;
        }
        return cnt;
}

int searchlink(struct Test *head,int data)
{
        struct Test *p = head;
        while(p != NULL)
        {
                if(p->data = data)
                                               
                {
                        return 1;
                }
                p = p->next;
        }
        return 0;
}

int insertlink(struct Test *head,int data,struct Test *new)
{
        struct Test *p = head;
        while(p != NULL)
        {
                if(p->data == data ){
                        new->next = p->next;
                        p->next = new;
                        return 1;
                }
                p = p->next;
        }
        return 0;

}

struct Test* deletNode(struct Test *head,int data)
{
        struct Test *p = head;
        if(p->data == data){
                head = head->next;
                //free()p;
                return head;
        }
        while(p->next != NULL)
        {
                if(p->next->data == data)
                {
                        //strct Test *tmp = p;
                        p->next = p->next->next;
                        //free(tmp);
                        return head;
                }
                p = p->next;
        }
        return head;
}

struct Test* insertFromHead(struct Test *head,struct Test *new)
{
        if(head == NULL)
        {
                head = new;
        }else{
                new->next = head;
                head = new;
        }
        return head;
}

struct Test *creatLink(struct Test *head)
{
        struct Test *new;
        while(1){
                new = (struct Test *)malloc(sizeof(struct Test));
                printf("input your new node data:\n");
                scanf("%d",&(new->data));
                if(new->data == 0)
                {
                        printf("0 quit\n");
                        free(new);
                        return head;
                }
                head = insertFromHead(head,new);
        }
}
struct Test* insertFromBehind(struct Test *head,struct Test *new)
{
        struct Test *p = head;
        if(p == NULL)
        {
                head = new;
                return head;

        }
        while(p->next != NULL){
                p = p->next;
        }
        p->next = new;
        return head;
}

struct Test *creatLink2(struct Test *head)
{
        struct Test *new;
        while(1){
                new = (struct Test *)malloc(sizeof(struct Test));
                printf("input your new node data:\n");
                scanf("%d",&(new->data));
                if(new->data == 0)
                {
                        printf("0 quit\n");
                        free(new);
                        return head;
                }
                head = insertFromBehind(head,new);
        }
}

int main()
{
        struct Test *head = NULL;
        head = creatLink(head);
        printlink(head);
        struct Test t1 = {100,NULL};
        head = insertFromHead(head,&t1);
        printlink(head);

        struct Test t2 = {200,NULL};
        head = insertFromBehind(head,&t2);
        printlink(head);
        return 0;
}
运行结果：

1为第一种创建链表方式

2为第二种创建链表方式

在努力啦~
关注
  • 5
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
百度飞桨学院小白课程第二天深度解析（小白系列）
三岁学编程的博客
04-24 1603
飞桨课堂第二天解析，小白专场！
认真开始学习C语言的2天总结（师承上官可编程----老陈）
Paulcharles1的博客
03-27 1349
说是来总结，其实也算是是给自己一个复盘的时间，把自己所学的东西回顾一下 前面先是跟着老师了解计算机程序的基础知识，程序可以理解为传统电脑软件我们在电脑上使用的各种软件（QQ、word、游戏等），然后还有其他的OS内核和服务器代码也属于电脑程序。 ...
上官Linux学习第一天
m0_64879837的博客
08-30 1147
linux是一个开源、免费的操作系统，其稳定、安全性、处理多并发已经得到业界的认可，目前很多企业级项目（java/php/python...）都会部署到linux/unix系统上。常见的操作系统（windows、IOS、Android、MacOS、Linux、Unix）Linux创始人Linus Torvalds（林纳斯·托瓦兹），同时也是Git的创作者，是世界著名黑客Linux主要发行版：Ubuntu(乌班图)------嵌入式开发RedHat(红帽)CentOS-------Web服务器。
python学习—第一步—Python小白逆袭大神（第二天）
静心学习，开心生活
09-24 4208
python进阶
java中常用的linux命令_常用Linux命令，让你的工作事半功倍
weixin_36257554的博客
02-25 208
作为运维人员，这些常用命令不得不会，掌握这些命令，工作上会事半功倍，提高工作效率。一.文件和目录1. cd命令，用于切换当前目录，它的参数是要切换到的目录的路径，可以是绝对路径，也可以是相对路径。cd/home进入'/home'目录cd..返回上一级目录cd../..返回上两级目录cd进入个人的主目录cd...
新员工试用期总结上官修武.pptx
03-09
上官修武是一名在 Inspur Group 任职的售后工程师，他在2014年度的工作总结中分享了他在试用期内的学习成果、工作成就和对未来工作规划的思考。他的工作总结主要围绕以下几个方面展开： **1. 学习成果** 在企业...
如何从零开始写一套自己的FOC矢量控制程序-上官致远.pdf
05-23
6. FOC核心算法实现：Clarke变换和Park变换用于将三相电流转换为二维平面坐标下的直流分量，而SVPWM用于生成PWM波形。这些都是实现精确电机控制的关键步骤。 7. 控制环路调试：电流环、速度环和位置环的调试是确保...
Linux系统快速装机配置教程1
08-08
Linux系统——快速装机配置Linux系统——快速装机配置 详细教程上官羽墨整理QQ交流群：274313939E-mail:wangbobochn@gmail
Linux客户端 Xshell7 Xftp7 免费版(home/school)
05-05
Linux客户端Xshell7和Xftp7是两款在Windows操作系统上广泛使用的强大工具，主要用于与Linux服务器进行远程交互和文件传输。...对于学习和探索Linux系统的用户，尤其是运维人员，这两款软件是非常实用的助手。
【学习笔记】卫星通信NTN 3GPP标准化进展分析（六）- 参考标准
u011376987的博客
09-01 1136
本文总结了NTN标准化进程以及后续的研究计划，是学习NTN协议的入门。本文来自3GPP Joern Krause, 3GPP MCC。
iomuxc、pinctrl子系统、gpio子系统（学习总结）
weixin_61385844的博客
09-04 845
IOMUXC是SOC设计中实现引脚复用的关键组件，它通过动态切换引脚功能，提高了IO资源的利用率，满足了不同外设和功能的IO需求。在配置和使用IOMUXC时，需要参考芯片使用手册和设备树文档，确保引脚功能的正确设置。
Datawhale X 李宏毅苹果书AI夏令营 学习笔记
m0_61049596的博客
08-31 1294
今天，我继续学习了深度学习中的优化算法，并且着重理解了如何利用。等高级优化器来提高模型训练的效率和效果。2024年8月30日。
学习项目1
m0_62803606的博客
09-03 1599
这篇文章主要记录你最近入手的无线串口模块的配置情况，这是个很好的习惯，尤其是在你以后需要重复操作或排查问题时，会非常有帮助。- **DL_20无线串口模块**：这是一个常见的无线串口通信模块，通常基于nRF24L01+等无线通信芯片，支持点对点或多点通信，适合短距离的无线数据传输。是的，如果你按照步骤成功配置了两个模块并将它们连接到单机和电脑，当你在上位机软件（如SSCOM）上能稳定地接收到从单片机发送的数据（例如每秒输出的T值），就说明两个无线模块之间的通信已经配置成功。
Web3开发与安全：6个月高效学习路径
weixin_47075747的博客
08-30 1859
这份计划应该能帮助你系统地学习智能合约开发和安全审计技能，同时克服英语的障碍。
算法的学习笔记—把数字翻译成字符串
业精于勤，荒于嬉
08-31 959
通过动态规划的方法，我们可以高效地计算出一个数字字符串有多少种不同的翻译方法。这个问题不仅考察了我们对动态规划的理解，还让我们熟悉了如何处理字符串中的边界情况和状态转移。希望通过这个例子的讲解，能够帮助你更好地理解动态规划的应用。😁热门专栏推荐想学习vue的可以看看这个java基础合集数据库合集redis合集nginx合集linux合集手写机制微服务组件spring_尘觉springMVCmybit欢迎大家加入我的社区尘觉社区文章到这里就结束了，如果有什么疑问的地方请指出，诸佬们一起来评论区一起讨论
网络编程学习：TCP/IP协议
kkbbaaii的博客
09-01 1598
网络编程学习：TCP/IP协议
IP学习——Fiveday
最新发布
qq_52973916的博客
09-05 378
设备排错：注意黑洞路由
2024.8.30 学习记录
sdhdhdhdh的博客
08-30 192
思维导图：
Android第一行代码第二版
07-29
- *1* *2* *3* [《第一行代码 第二版》Android studio java开发学习笔记+源码](https://blog.csdn.net/Caiyii530/article/details/119700694)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630",...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值