数据结构与算法2---链表

线性表：1.有限的序列⒉.序列中的每一个元素都有唯一的前驱和后继，除了开头和结尾两个节点

顺序表：分配一块连续的内存去存放这些元素，例如编程语言中的数组

链表:内存是不连续的，元素会各自被分配一块内存，内存和内存之间用指针进行相连


1、单链表

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>  
#include <stdlib.h>   //开辟空间typedef struct Node {int data;struct Node* next;
}Node;//带头结点的初始化单链表
Node* initList() {Node* list = (Node*)malloc(sizeof(Node));list->data = 0;list->next = NULL;return list;
}//头插法
void headInsert(Node* list, int data) {Node* node = (Node*)malloc(sizeof(Node));node->data = data;node->next = list->next;list->next = node;list->data++;
}//尾插法
void tailInsert(Node* list, int data) {Node* head = list;Node* node = (Node*)malloc(sizeof(Node));node->data = data;node->next = NULL;list = list->next;while (list->next) {list = list->next;}	//找到最后的结点list->next = node;head->data++;
}//删除
void delete(Node* list, int data) {Node* pre = list;Node* current = list->next;while (current) {if (current->data == data) {pre->next = current->next;free(current);break;}pre = current;current = current->next;}list->data--;
}void printList(Node* list) {list = list->next;while (list) {printf("%d ", list->data);list = list->next;}printf("\n");
}int main() {Node* list = initList();headInsert(list, 1);headInsert(list, 2);headInsert(list, 3);printList(list);tailInsert(list, 4);tailInsert(list, 5);tailInsert(list, 6);printList(list);delete(list, 3);printList(list);return 0;
}

这里说一下，头插尾插的时候，都当作有很多的时候插入，最后处理开始会好很多

2、单循环链表

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>  
#include <stdlib.h>   //开辟空间typedef struct Node {int data;struct Node* next;
}Node;Node* initList() {Node* L = (Node*)malloc(sizeof(Node));L->data = 0;L->next = L;return L;
}//头插法
void headInsert(Node* L, int data) {Node* node = (Node*)malloc(sizeof(Node));node->data = data;node->next = L->next;L->next = node;L->data++;
}//尾插法
void tailInsert(Node* L, int data) {Node* n = L;Node* node = (Node*)malloc(sizeof(Node));node->data = data;while (n->next != L) {n = n->next;}node->next = L;n->next = node;L->data++;
}//删除
int delete(Node* L, int data) {Node* pre = L;Node* node = L->next;while (node != L) {if (node->data == data) {pre->next = node->next;free(node);L->data--;return 1;}pre = node;node = node->next;}return 0;
}void printList(Node* L) {Node* node = L->next;while (node != L) {printf("%d ", node->data);node = node->next;}printf("NULL\n");
}int main() {Node* L = initList();headInsert(L, 1);headInsert(L, 2);headInsert(L, 3);printList(L);tailInsert(L, 4);tailInsert(L, 5);tailInsert(L, 6);printList(L);delete(L, 3);printList(L);return 0;
}

3、双链表

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>  
#include <stdlib.h>   //开辟空间typedef struct Node {int data;struct Node* pre;struct Node* next;
}Node;//带头结点
Node* initList() {Node* L = (Node*)malloc(sizeof(Node));L->data = 0;L->pre = NULL;L->next = NULL;return L;
}void headInsert(Node* L, int data) {Node* node = (Node*)malloc(sizeof(Node));node->data = data;if (L->data == 0) {//链表为空node->next = L->next;	//NULLnode->pre = L;L->next = node;L->data++;}else {node->pre = L;node->next = L->next;L->next->pre = node;L->next = node;L->data++;}
}void tailInsert(Node* L, int data) {Node* node = L;Node* n = (Node*)malloc(sizeof(Node));n->data = data;while (node->next) {node = node->next;}	//找到最后一个n->next = node->next;	//NULLnode->next = n;n->pre = node;L->data++;
}int delete(Node* L, int data) {Node* node = L->next;while (node) {if (node->data == data && node->next != NULL) {node->pre->next = node->next;node->next->pre = node->pre;free(node);L->data--;return 1;}if (node->data == data && node->next == NULL) {node->pre->next = node->next;free(node);L->data--;return 1;}node = node->next;}return 0;
}void printList(Node* L) {Node* node = L->next;while (node) {printf("%d ", node->data);node = node->next;}printf("NULL\n");
}int main() {Node* L = initList();headInsert(L, 1);headInsert(L, 2);headInsert(L, 3);printList(L);tailInsert(L, 4);tailInsert(L, 5);tailInsert(L, 6);printList(L);delete(L, 1);printList(L);delete(L, 6);printList(L);return 0;
}

4、双循环链表

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>  
#include <stdlib.h>   //开辟空间typedef struct Node {int data;struct Node* pre;struct Node* next;
}Node;Node* initList() {Node* L = (Node*)malloc(sizeof(Node));L->data = 0;L->pre = L;L->next = L;return L;
}void headInsert(Node* L, int data) {Node* node = (Node*)malloc(sizeof(Node));node->data = data;if (L->data == 0) {//链表为空node->pre = L;node->next = L->next;L->next = node;L->pre = node;L->data++;}else {//链表不为空node->pre = L;node->next = L->next;L->next->pre = node;L->next = node;L->data++;}
}void tailInsert(Node* L, int data) {Node* node = L->pre;Node* n = (Node*)malloc(sizeof(Node));n->data = data;n->pre = node;n->next = L;node->next = n;L->pre = n;L->data++;
}int delete(Node* L, int data) {Node* node = L->next;while (node != L) {if (node->data == data) {node->pre->next = node->next;node->next->pre = node->pre;L->data--;return 1;}node = node->next;}return 0;
}void printList(Node* L) {Node* node = L->next;while (node != L) {printf("%d ", node->data);node = node->next;}printf("NULL\n");
}int main() {Node* L = initList();headInsert(L, 1);headInsert(L, 2);headInsert(L, 3);printList(L);tailInsert(L, 4);tailInsert(L, 5);tailInsert(L, 6);printList(L);delete(L, 1);printList(L);delete(L, 6);printList(L);return 0;
}

五、多项式相加

【问题描述】编写一个程序用单链表存储多项式，并实现两个一元多项式A与B相加的函数。A，B刚开始是无序的，A与B之和按降序排列。例如：
                        多项式A:  1.2X^0  2.5X^1  3.2X^3  -2.5X^5
                        多项式B:  -1.2X^0  2.5X^1  3.2X^3   2.5X^5   5.4X^10
                        多项式A与B之和：5.4X^10  6.4X^3  5X^1
【输入形式】第一行第一个数据n代表多项式的总项数，后面的2*n个数据，每一对代表对应的某一项的系数和指数，第二行类似，第三行的数据x要查询第几项
【输出形式】多项式中某一项的系数与指数，系数保留一位小数

【输入样例】
4 1.2 0 2.5 1 3.2 3 -2.5 5
5 -1.2 0 2.5 1 3.2 3 2.5 5 5.4 10
2

【输出样例】

6.4 3

【样例说明】
第一个多项式的系数与指数对，以空格隔开
第二个多项式的系数与指数对，以空格隔开
输出第２项的系数与指数，系数与指数间用空格隔开，系数保留一位小数

【评分标准】必须用链表实现

#include<stdio.h>
#include<stdlib.h>
typedef struct node* list;
struct node {float coef;int expon;list next;
};
list create()//最基本的构建其实是最好的方法 我也不多说了
{list q, r, head;int i;head = (list)malloc(sizeof(struct node));r = head;int n;scanf("%d", &n);for (i = 0; i < n; i++){q = (list)malloc(sizeof(struct node));scanf("%f %d", &q->coef, &q->expon);r->next = q;r = q;}r->next = NULL;return head;
}
list sort(list head)//这是一个排序的函数
{list p = head->next, q, r;if (p != NULL){r = p->next;p->next = NULL;p = r;while (p != NULL){r = p->next;q = head;while (q->next != NULL && q->next->expon > p->expon)q = q->next;p->next = q->next;q->next = p;p = r;}}return head;}
list add(list a, list b)//排好序的多项式相加
{list p, q, r, c, s;p = a->next;q = b->next;c = (list)malloc(sizeof(struct node));r = c;while (p && q) {if (p->expon < q->expon) {s = (list)malloc(sizeof(struct node));s->expon = q->expon;s->coef = q->coef;r->next = s;r = s;q = q->next;}else if (p->expon > q->expon) {s = (list)malloc(sizeof(struct node));s->expon = p->expon;s->coef = p->coef;r->next = s;r = s;p = p->next;}else {double sum = p->coef + q->coef;if (sum != 0) {s = (list)malloc(sizeof(struct node));s->coef = sum;s->expon = p->expon;r->next = s;r = s;p = p->next;q = q->next;}else {p = p->next;q = q->next;}}}if (p == NULL && q == NULL)r->next = NULL;if (p != NULL) {r->next = p;}if (q != NULL) {r->next = q;}return c;
}
void show(list l)//输出函数
{int n;list p = l;scanf("%d", &n);while (n--) {p = p->next;}printf("%.1f %d", p->coef, p->expon);//这个格式十分重要啊printf("\n");
}
int main()
{list a, b, c, d, e;a = create();b = create();d = sort(a);e = sort(b);c = add(d, e);show(c);return 0;}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/web/30261.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

【深度学习驱动流体力学】计算流体力学openfoam-paraview与python3交互

【深度学习驱动流体力学】计算流体力学openfoam-paraview与python3交互

目的1:配置 ParaView 中的 Python Shell 和 Python 交互环境 ParaView 提供了强大的 Python 接口，允许用户通过 Python 脚本来控制和操作其可视化功能。在 ParaView 中，可以通过 View > Python Shell 菜单打开 Python Shell 窗口，用于执行 Python 代码。要确保正确配置 …
阅读更多...
golang字符串拼接和strings.Builder

golang字符串拼接和strings.Builder

字符串拼接方法 在 Go 语言中&#xff0c;字符串是可以直接相加的。这意味着你可以使用 运算符来连接&#xff08;拼接&#xff09;两个或多个字符串&#xff1a; package mainimport "fmt"func main() {str1 : "Hello, "str2 : "World!"resu…
阅读更多...
比较日志性能：Glog、Spdlog 和 ofstream 在不同硬件上的表现（推荐Spdlog）

比较日志性能：Glog、Spdlog 和 ofstream 在不同硬件上的表现（推荐Spdlog）

文章目录 比较日志性能&#xff1a;Glog、Spdlog 和 ofstream 在不同硬件上的表现1. 引言2. 测试简介3. 硬件配置桌面电脑&#xff08;Ubuntu 18.04&#xff09;树莓派 5&#xff08;Ubuntu 24.04&#xff09; 4. 测试结果桌面电脑&#xff08;Ubuntu 18.04&#xff09;树莓派 …
阅读更多...
[Linux] vi编辑器

[Linux] vi编辑器

命令模式&文本模式 命令模式就输入命令然后执行&#xff0c;文本模式就是系统把你的输入都当成写进文件里的字符 切换模式&#xff1a; 刚进入默认是命令模式&#xff0c;按: i I a A o O 进入文本模式&#xff0c; 通过他们进入文本模式有什么不同&#xff1f; 然后按esc进…
阅读更多...
python 版本切换，更换当前默认版本

python 版本切换，更换当前默认版本

电脑可以安装多个版本&#xff0c;但是好像没有正规的维护python版本的工具&#xff0c;比如前端就有nvm切换node版本&#xff0c;但是python我没找到比较好的&#xff08;有大佬知道路过方便留言一下&#xff0c;跪谢。。&#xff09; 废话不多说&#xff0c;更改默认版本很简…
阅读更多...
字节跳动万卡集群网络分析

字节跳动万卡集群网络分析

从公开的信息披露，截至2023年9月，字节跳动已经建立超过一万张的英伟达Ampere架构GPU集群，目前正在建设Hopper架构的集群。英伟达Ampere架构主要包括A100和A800型号的芯片，Hopper架构相较前者则更新，主要包括H100和H800芯片 字节和北大公布的论文，关于网络拓扑的描述主要…
阅读更多...
DIVE INTO DEEP LEARNING 36-49

DIVE INTO DEEP LEARNING 36-49

文章目录 36. Data augmentation36.1 Training with enhanced data36.2 Enhancement measures36.3 Data augmentation summary 37. Fine tuning37.1 Fine tuning Introduce37.2 Fine tuning Step37.3 Fine tuning summary 38. Object detection38.1 Object detection38.2 Edge …
阅读更多...
[Linux] Shell

[Linux] Shell

chsh不是一种sh,而是一个命令行使用程序&#xff0c;用于更改默认shell CentOS是个开源软件&#xff0c;没有sh,sh是商业版的&#xff0c; 按ls /bin/*sh显示的sh实际上是个链接文件&#xff0c;连接的bash 在命令行输入新的sh名&#xff0c;会启动一个新的进程&#xff0c; 输…
阅读更多...
厂里资讯之app端文章搜索

厂里资讯之app端文章搜索

app端文章搜索 1) 内容介绍 文章搜索 ElasticSearch环境搭建 索引库创建 文章搜索多条件复合查询 索引数据同步 搜索历史记录 Mongodb环境搭建 异步保存搜索历史 查看搜索历史列表 删除搜索历史 联想词查询 联想词的来源 联想词功能实现 2) 搭建ElasticSearch环境 …
阅读更多...
MyBatis系列七: 一级缓存，二级缓存，EnCache缓存

MyBatis系列七: 一级缓存，二级缓存，EnCache缓存

缓存-提高检索效率的利器 官方文档 一级缓存基本介绍快速入门Debug一级缓存执行流程一级缓存失效分析 二级缓存基本介绍快速入门Debug二级缓存执行流程注意事项和使用细节 mybatis的一级缓存和二级缓存执行顺序小实验细节说明 EnCache缓存基本介绍配置和使用EhCache细节说明 My…
阅读更多...
SpringBoot整合Minio(支持公有及私有bucket)

SpringBoot整合Minio(支持公有及私有bucket)

&#x1f60a; 作者&#xff1a; 一恍过去 &#x1f496; 主页&#xff1a; https://blog.csdn.net/zhuocailing3390 &#x1f38a; 社区&#xff1a; Java技术栈交流 &#x1f389; 主题&#xff1a; SpringBoot整合Minio(支持公有及私有bucket) ⏱️ 创作时间&#xff1…
阅读更多...
java多版本管理

java多版本管理

一 java 多版本管理 使用 jenv, 地址&#xff1a;https://github.com/jenv/jenv mac 操作 brew install jenv# Shell: zsh echo export PATH"$HOME/.jenv/bin:$PATH" >> ~/.zshrc echo eval "$(jenv init -)" >> ~/.zshrc source ~/.zshrc需要…
阅读更多...
张大哥笔记：如何选择一个人就值得做的副业

张大哥笔记：如何选择一个人就值得做的副业

很多人喜欢把上班称为主业&#xff0c;把上班之外的工作称为副业&#xff0c;不管以哪种方式称呼都可以&#xff0c;只要能赚钱就行&#xff0c;上班的本质就是出卖时间&#xff0c;不管你是月入5000还是月入2万&#xff0c;都是给老板打工&#xff01; 但搞笑的就是月入2万的人…
阅读更多...
关于app爬虫的环境准备

关于app爬虫的环境准备

摘要 有些数据需要在手机应用中才能查看&#xff0c;没有网页版&#xff0c;所以学习移动端的爬虫是有必要的。 手机系统分为安卓和苹果两大系统&#xff0c;本次讲解主要以安卓手机为例 有安卓手机的可以使用手机&#xff0c;没有的可以使用模拟器&#xff0c;本次以夜神模…
阅读更多...
基于C++、MFC和Windows套接字实现的简单聊天室程序开发

基于C++、MFC和Windows套接字实现的简单聊天室程序开发

一、一个简单的聊天室程序 该程序由服务器端和客户端两个项目组成&#xff0c;这两个项目均基于对话框的程序。服务器端项目负责管理客户端的上线、离线状态&#xff0c;以及转发客户端发送的信息。客户端项目则负责向服务器发送信息&#xff0c;并接收来自服务器的信息&#…
阅读更多...
YAML 快速上手

YAML 快速上手

文章目录 1.语法2.历史版本3.数据结构对象数组复合结构标量 4.引用5.文本块6.显示指定类型7.单文件多文档8.解析9.完整示例参考文献 YAML&#xff08;YAML Ain’t a Markup Language&#xff09;是专门用来写配置文件的语言&#xff0c;简洁强大&#xff0c;相比于 JSON 和 XML…
阅读更多...
R包开发详细教程

R包开发详细教程

开发一个R包可以帮助你组织和共享代码。以下是一个详细的步骤教程&#xff0c;介绍如何开发一个R包。 步骤 1: 准备工作 确保你已经安装了以下R包&#xff1a; install.packages("devtools") install.packages("roxygen2") install.packages("test…
阅读更多...
[机器学习算法]决策树

[机器学习算法]决策树

1. 理解决策树的基本概念 决策树是一种监督学习算法&#xff0c;可以用于分类和回归任务。决策树通过一系列规则将数据划分为不同的类别或值。树的每个节点表示一个特征&#xff0c;节点之间的分支表示特征的可能取值&#xff0c;叶节点表示分类或回归结果。 2. 决策树的构建…
阅读更多...
基于深度学习的图像压缩

基于深度学习的图像压缩

基于深度学习的图像压缩 图像压缩是指将图像数据量减小的同时尽量保留其视觉质量的过程。传统的图像压缩方法&#xff08;如JPEG、PNG等&#xff09;已经广泛应用&#xff0c;但随着深度学习技术的发展&#xff0c;基于深度学习的图像压缩方法逐渐显现出其优越性。以下是一些关…
阅读更多...
【AI原理解析】— Kimi模型

【AI原理解析】— Kimi模型

目录 一、技术背景与基础 二、核心技术特点 深度学习与神经网络&#xff1a; 超长上下文学习&#xff1a; 多模态对齐&#xff1a; 个性化调优&#xff1a; 知识增强&#xff1a; 推理优化&#xff1a; 三、模型架构 一、技术背景与基础 Kimi模型是一种基于深度学习和…
阅读更多...
最新文章

Copyright @ 2022~2023