1201作业

news2024/12/5 2:21:36

思维导图

作业

头函数

#include <myhead.h>
#include"linklist.h"
int main(int argc, const char *argv[])
{
	//调用创建链表函数
	node_ptr L = list_create();
	if(NULL == L)
	{
		return -1;
	}

	//调用头插函数
	list_insert_head(L,'Q');
	list_insert_head(L,'W');
	list_insert_head(L,'R');
	list_insert_head(L,'R');
	list_insert_head(L,'E');
	list_insert_head(L,'R');
	list_insert_head(L,'R');
	list_insert_head(L,'R');
	
	//展示
	list_show(L);

	//调用任意位置插入函数
	list_insert_pos(L,1,'D');
	list_insert_pos(L,2,'F');
	list_insert_pos(L,L->len+1,'F');
	list_show(L);

	//调用单链表尾插函数
	list_insert_trail(L,'x');
	list_show(L);


	//单链表头删
	list_delete_head(L);
	list_show(L);

	//单链表任意位置删除
	list_delete_pos(L,1);
	//list_delete_pos(L,3);
	//list_delete_pos(L,L->len);
	list_show(L);

	//调用单链表尾删函数
	list_delete_trail(L);
	list_show(L);

	//调用值查找数据位置函数
	printf("该值的位置在第%d节点\n",list_update_key(L,'E'));

	//调用位置修改函数
	list_update_pos(L,2,'H');
	list_show(L);

	//调用按值修改函数
	list_update_num(L,'H','B');
	list_show(L);

	//调用反转函数
	list_reverse(L);
	list_show(L);

	//调转排序函数
	list_sort(L);
	list_show(L);

	//调用去重函数
	list_remove(L);
	list_show(L);
	printf("该单链表的长度为：%d\n",list_long(L));

	//调用清空函数
	list_all_empty(L);
	list_show(L);

	//调用长度函数
	printf("该单链表的长度为：%d\n",list_long(L));


	//调用销毁函数
	list_destroy(L);
	L=NULL;
	list_show(L);


	return 0;
}

源代码

#include"linklist.h"

//创建链表
node_ptr list_create()
{
	//在堆区申请一个头结点的空间
	node_ptr L = (node_ptr)malloc(sizeof(Node));
	if(NULL==L)
	{
		printf("链表创建失败\n");
		return NULL;
	}

	//程序执行至此，一个头节点申请成功
	//有了头结点，就有了一条链表
	//初始化操作
	L->len = 0;   //表示链表长度为0
	L->next = NULL; //防止野指针

	printf("链表创建成功\n");
	return L;
}

//链表判空操作
//如果链表为空，返回1，非空返回0
int list_empty(node_ptr L)
{
	//判断逻辑
	if(NULL==L)
	{
		printf("链表不合法\n");
		return -1;
	}

	return L->next==NULL?1:0;

}

//定义申请节点封装数据函数
node_ptr node_apply(datatype e)
{
	//在堆区申请一个节点的空间
	node_ptr p = (node_ptr)malloc(sizeof(Node));
	if(NULL==p)
	{
		printf("节点申请失败\n");
		return NULL;
	}

	//将数据封装进节点的数据域
	p->data = e;
	p->next = NULL;   //防止野指针

	return p;   //将封装好的节点地址返回
}

//单向链表头插
int list_insert_head(node_ptr L,datatype e)
{
	//判断逻辑
	if(NULL==L)
	{
		printf("链表不合法\n");
		return -1;
	}
	
	//申请节点封装数据
	node_ptr p = node_apply(e);
	if(NULL==p)
	{
		return -1;
	}
	//程序执行至此，表示节点申请成功，e已经封装进节点中
	//头插逻辑
	p->next = L->next;
	L->next = p;

	//表长变化
	L->len++;
	printf("插入成功\n");
	return 0;
}

//单向链表的按位置查找返回节点
node_ptr list_find_node(node_ptr L,int pos)
{
	//判断逻辑
	if(NULL==L || pos<0 || pos>L->len)
	{
		printf("查找失败\n");
		return NULL;
	}

	//查找逻辑
	node_ptr q = L;//定义遍历指针,从头结点出发
	for(int i=0;i<pos;i++)
	{
		q = q->next;  //将指针偏移到下一个节点位置
	}
	
	//返回节点
	return q;
}

//单向链表的遍历
int list_show(node_ptr L)
{
	//判断逻辑
	if(list_empty(L))
	{
		printf("遍历失败\n");
		return -1;
	}

	//展示逻辑
	printf("链表中的元素分别是：\n");
	node_ptr q = L->next;
	/*
	node_ptr q = L;
	for(int i=0;i<L->len;i++)
	{
		q = q->next;
		printf("%c\t",q->data);
	}
	*/

	while(q)
	{
		//当前节点不为空，输出数据域
		printf("%c\t",q->data);
		q = q->next;
	}
	putchar(10);
}

//单向链表任意位置插入
int list_insert_pos(node_ptr L,int pos,datatype e)
{
	//判断逻辑
	if(NULL==L || pos<1 || pos>L->len+1)
	{
		printf("插入失败\n");
		return -1;
	}

	//找到要插入位置的前一个节点
	node_ptr q = list_find_node(L,pos-1);

	//申请节点封装数据
	node_ptr p = node_apply(e);
	if(NULL==p)
	{
		return -1;
	}
	
	//插入逻辑
	p->next = q->next;
	q->next = p;

	//表长变化
	L->len++;
	printf("插入成功\n");
	return 0;
	
}

//单向链表的尾插
int list_insert_trail(node_ptr L,datatype e)
{
	//判断逻辑
	if(list_empty(L) || NULL==L)
	{
		printf("插入失败\n");
		return -1;
	}

	//申请新节点
	node_ptr p = node_apply(e);
	if(NULL==p)
	{
		return -1;
	}

	//插入逻辑
	node_ptr q = L;
	for(int i=0;i<L->len;i++)
	{
		q = q->next;
	}
	q->next = p;
	p->next = NULL;

	//表长变化
	L->len++;
	printf("插入成功\n");
	return 0;
}

//单链表头删
int list_delete_head(node_ptr L)
{
	//判断逻辑
	if(list_empty(L) || NULL==L)
	{
		printf("删除失败\n");
		return -1;
	}
	
	//删除逻辑
	node_ptr q = L->next;
	L->next = q->next;
	free(q);
	q = NULL;

	//表长变化
	L->len--;
	printf("删除成功\n");
	return 0;
}

//单向链表任意位置删除
int list_delete_pos(node_ptr L,int pos)
{
	//判断逻辑
	if(NULL==L || pos<1 || pos>L->len || list_empty(L))
	{
		printf("删除失败\n");
		return -1;
	}

	//找到删除位置的前一个节点
	node_ptr q = list_find_node(L,pos-1);

	//删除逻辑
	node_ptr p = q->next;
	q->next = p->next;
	free(p);
	p=NULL;

	//表长变化
	L->len--;
	printf("删除成功\n");
	return 0;
}

//单向链表的尾删
int list_delete_trail(node_ptr L)
{
	//判断逻辑
	if(list_empty(L) || NULL==L)
	{
		printf("删除失败\n");
		return -1;
	}

	//找到尾节点的前一节点
	node_ptr p = list_find_node(L,L->len-1);

	//删除逻辑
	p->next=NULL;
	free(p->next);
	p->next = NULL;

	//链表变化
	L->len--;
	printf("删除成功\n");
	return 0;
}

//单向链表按值查找返回位置
int list_update_key(node_ptr L,datatype e)
{
	//判断逻辑
	if(list_empty(L) || NULL==L)
	{
		return -1;
	}

	//查找逻辑
	node_ptr p = L;
	for(int i=0;i<L->len;i++)
	{
		p = p->next;
		if(p->data==e)
		{
			printf("查询成功\n");
			return i+1;
		}

	}
	printf("未查询到此值\n");
	return -1;
}

//单向链表按位置进行修改
int list_update_pos(node_ptr L,int pos,datatype e)
{
	//判断逻辑
	if(NULL==L || list_empty(L) || pos<1 || pos>L->len)
	{
		printf("修改失败\n");
		return -1;
	}

	//查找指定节点
	node_ptr p = list_find_node(L,pos);

	//进行修改
	p->data = e;

	printf("修改成功\n");
	return 0;
}

//单向链表按值进行修改
int list_update_num(node_ptr L,datatype old_e,datatype new_e)
{
	//判断逻辑
	if(NULL==L || list_empty(L))
	{
		printf("修改失败\n");
		return -1;
	}

	//查找指定的值
	node_ptr p = L;
	for(int i=0;i<L->len;i++)
	{
		p = p->next;
		if(p->data==old_e)
		{
			printf("查询成功\n");
			p->data = new_e;
			printf("修改成功\n");
			return 0;
		}
	}
	printf("修改失败\n");
	return -1;
}

//单向链表的反转
int list_reverse(node_ptr L)
{
	//判断逻辑
	if(NULL==L || list_empty(L) || L->len==1)
	{
		printf("反转失败\n");
		return -1;
	}

	//反转逻辑
	node_ptr H = L->next;
	L->next = NULL;

	while(H!=NULL)
	{
		node_ptr p = H;
		H = H->next;

		p->next = L->next;
		L->next = p;
	}

	printf("反转成功\n");
	return 0;
}

//单向链表的排序
int list_sort(node_ptr L)
{
	//判断逻辑
	if(list_empty(L) || NULL==L)
	{
		printf("排序失败\n");
		return -1;
	}

	//排序逻辑
	for(int i=1;i<L->len;i++)
	{
		node_ptr p = L->next;
		for(int j=0;j<L->len-i;j++)
		{
			if(p->data > p->next->data)
			{
				datatype t = p->next->data;
				p->next->data = p->next->next->data;
				p->next->next->data = t;
			}
			p = p->next;
		}
	}
	printf("排序成功\n");
	return 0;
}

//单向链表的去重
int list_remove(node_ptr L)
{
	//判断逻辑
	if(list_empty(L) || NULL==L)
	{
		printf("去重失败\n");
		return -1;
	}

	//去重逻辑
	node_ptr p = L->next;
	while(p!=NULL)
	{
		node_ptr q = p;
		node_ptr t = p;
		while(q->next!=NULL)
		{
			if(p->data == q->next->data)
			{
				node_ptr t = q->next;
				q->next = q->next->next;
				free(t);
				t=NULL;
				L->len--;
			}
			else
			{
				q= q->next;
			}
		}
		p = p->next;

	}
	printf("去重成功\n");
	return 0;
}

//单向链表的清空
int list_all_empty(node_ptr L)
{
	//判断逻辑
	if(NULL==L)
	{
		return -1;
	}

	//清空逻辑
	while(L->next!=NULL)
	{
		node_ptr p = L->next;
		L->next = p->next;
		free(p);
		p=NULL;
		L->len--;
	}

	printf("清空成功\n");
	return 0;

}

//返回单向链表的长度
int list_long(node_ptr L)
{
	//判断逻辑
	if(NULL==L)
	{
		return -1;
	}
	return L->len;
}

//单向链表的释放
void list_destroy(node_ptr L)
{
	//判断逻辑
	if(NULL==L)
	{
		printf("销毁失败\n");
		return ;
	}

	//释放逻辑
	//将所有普通节点释放
	while(!list_empty(L))
	{
		//调用头删函数
		list_delete_head(L);
	}

	//释放头结点
	free(L);
	L=NULL;
	printf("销毁成功\n");
}

头文件

#ifndef __LINKLIST_H__
#define __LINKLIST_H__
#include<myhead.h>
typedef char datatype; //数据元素类型

//定义节点类型
typedef struct Node
{
	union
	{
		int len;//头结点数据域
		datatype data;//普通节点数据域
	};
	struct Node *next;  //指针域
}Node,*node_ptr;

//创建链表
node_ptr list_create();

//链表判空操作
int list_empty(node_ptr L);

//定义申请节点封装数据函数
node_ptr node_apply(datatype e);

//单向链表头插
int list_insert_head(node_ptr L,datatype e);

//单向链表的按位置查找返回节点
node_ptr list_find_node(node_ptr L,int pos);

//单向链表展示
int list_show(node_ptr L);

//单向链表任意位置插入
int list_insert_pos(node_ptr L,int pos,datatype e);

//单向链表的尾插
int list_insert_trail(node_ptr L,datatype e);

//单链表头删
int list_delete_head(node_ptr L);

//单向链表任意位置删除
int list_delete_pos(node_ptr L,int pos);

//单向链表的尾删
int list_delete_trail(node_ptr L);

//单向链表按值查找返回位置
int list_update_key(node_ptr L,datatype e);

//单向链表按位置进行修改
int list_update_pos(node_ptr L,int pos,datatype e);

//单向链表按值进行修改
int list_update_num(node_ptr L,datatype old_e,datatype new_e);

//单向链表的反转
int list_reverse(node_ptr L);

//单向链表的排序
int list_sort(node_ptr L);

//单向链表的去重
int list_remove(node_ptr L);

//单向链表的清空
int list_all_empty(node_ptr L);

//返回单向链表的长度
int list_long(node_ptr L);

//单向链表的释放
void list_destroy(node_ptr L);

#endif

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

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

相关文章

【Code First】.NET开源 ORM 框架 SqlSugar 系列

【Code First】.NET开源 ORM 框架 SqlSugar 系列

.NET开源 ORM 框架 SqlSugar 系列 【开篇】.NET开源 ORM 框架 SqlSugar 系列【入门必看】.NET开源 ORM 框架 SqlSugar 系列【实体配置】.NET开源 ORM 框架 SqlSugar 系列【Db First】.NET开源 ORM 框架 SqlSugar 系列【Code First】.NET开源 ORM 框架 SqlSugar 系列【数据事务…
阅读更多...
大语言模型微调与 XTuner 微调实战

大语言模型微调与 XTuner 微调实战

1 大语言模型微调 1.1 什么是微调 大语言模型微调&#xff08;Fine-tuning of Large Language Models&#xff09;是指在预训练的大型语言模型基础上&#xff0c;使用特定任务的数据进一步训练模型&#xff0c;以使其更好地适应和执行特定任务的过程&#xff0c;用于使LLM&am…
阅读更多...
Vulnhub靶场 Matrix-Breakout: 2 Morpheus 练习

Vulnhub靶场 Matrix-Breakout: 2 Morpheus 练习

目录 0x00 准备0x01 主机信息收集0x02 站点信息收集0x03 漏洞查找与利用1. 文件上传2. 提权 0x04 总结 0x00 准备 下载连接&#xff1a;https://download.vulnhub.com/matrix-breakout/matrix-breakout-2-morpheus.ova 介绍&#xff1a; This is the second in the Matrix-Br…
阅读更多...
基于hexo框架的博客搭建流程

基于hexo框架的博客搭建流程

这篇博文讲一讲hexo博客的搭建及文章管理&#xff0c;也算是我对于暑假的一个交代 &#xff01;&#xff01;&#xff01;注意&#xff1a;下面的操作是基于你已经安装了node.js和git的前提下进行的&#xff0c;并且拥有github账号 创建一个blog目录 在磁盘任意位置创建一个…
阅读更多...
24.12.02 Element

24.12.02 Element

import { createApp } from vue // 引入elementPlus js库 css库 import ElementPlus from element-plus import element-plus/dist/index.css //中文语言包 import zhCn from element-plus/es/locale/lang/zh-cn //图标库 import * as ElementPlusIconsVue from element-plus/i…
阅读更多...
vxe-table 设置树表格斑马线条纹样式

vxe-table 设置树表格斑马线条纹样式

vxe-table 设置斑马线条纹样式&#xff0c;通过设置 stripe 参数 官网&#xff1a;https://vxetable.cn 表格 斑马线条纹&#xff0c;通过设置 stripe 参数 <template><div><vxe-grid v-bind"gridOptions"></vxe-grid></div> </…
阅读更多...
力扣3366.最小数组和

力扣3366.最小数组和

力扣3366.最小数组和 题目 题目解析及思路 题目要求对于数组进行两种操作&#xff0c;使最终数组和最小 注意&#xff1a;每个元素可以同时执行两种操作 考虑动归&#xff0c;暴力的遍历每种情况 代码 记忆化搜索 class Solution { public:// minArraySum 函数用于计算在…
阅读更多...
缓存穿透，缓存雪崩，缓存击穿

缓存穿透，缓存雪崩，缓存击穿

缓存穿透&#xff1a; 客户端请求的数据在缓存中和数据库中都不存在&#xff0c;这样的缓存永远不会生效&#xff0c;这些请求会直接打到数据库中&#xff0c;造成数据库压力过大 解决方法&#xff1a;1.缓存空对象 //TODO 此方法中解决了缓存穿透问题&#xff08;使用了缓存…
阅读更多...
【C++boost::asio网络编程】有关异步读写api的笔记

【C++boost::asio网络编程】有关异步读写api的笔记

异步读写api 异步写操作async_write_someasync_send 异步读操作async_read_someasync_receive 定义一个Session类&#xff0c;主要是为了服务端专门为客户端服务创建的管理类 class Session { public:Session(std::shared_ptr<asio::ip::tcp::socket> socket);void Conn…
阅读更多...
atcoder abc 382 lazy_tag线段树

atcoder abc 382 lazy_tag线段树

A Daily Cookie 代码&#xff1a; #include <bits/stdc.h> using namespace std;typedef long long ll;int main() {int n, d;cin >> n >> d;string s;cin >> s;int cnt d;for(auto t: s) if(t .) cnt ;cout << min(n, cnt); } B Daily Co…
阅读更多...
【NLP 8、normalization、sigmoid，softmax归一化函数】

【NLP 8、normalization、sigmoid，softmax归一化函数】

"燃尽最后的本能&#xff0c;意志力会带你杀出重围" —— 24.12.2 1. Normalization&#xff08;归一化&#xff09; 归一化是将数据转换为具有统一尺度的形式&#xff0c;通常用于数据预处理阶段。常见的归一化方法包括 Min-Max归一化、Z-Score 归一化和 L…
阅读更多...
深入学习指针（5）！！！！！！！！！！！！！！！

深入学习指针（5）！！！！！！！！！！！！！！！

文章目录 1.回调函数是什么&#xff1f;2.qsort使用举例2.1使用qsort函数排序整形数据2.2使用sqort排序结构数据 3.qsort函数的模拟实现 1.回调函数是什么&#xff1f; 回调函数就是⼀个通过函数指针调⽤的函数。 如果你把函数的指针&#xff08;地址&#xff09;作为参数传递…
阅读更多...
Matlab Simulink 电力电子仿真-单相电压型半桥逆变电路分析

Matlab Simulink 电力电子仿真-单相电压型半桥逆变电路分析

目录 一、单相电压型半桥逆变电路仿真模型 1.电路模型 2.电路模型参数 二、仿真分析 三、总结 1.优缺点 2.应用场景 一、单相电压型半桥逆变电路仿真模型 1.电路模型 单相电压型半桥逆变电路是一种常见的逆变电路&#xff0c;主要用于将直流电源转换为交流电源。 &…
阅读更多...
《Vue零基础入门教程》第十五课：样式绑定

《Vue零基础入门教程》第十五课：样式绑定

往期内容 《Vue零基础入门教程》第六课&#xff1a;基本选项 《Vue零基础入门教程》第八课&#xff1a;模板语法 《Vue零基础入门教程》第九课&#xff1a;插值语法细节 《Vue零基础入门教程》第十课&#xff1a;属性绑定指令 《Vue零基础入门教程》第十一课&#xff1a;事…
阅读更多...
做异端中的异端 -- Emacs裸奔之路5: 条件反射式移动

做异端中的异端 -- Emacs裸奔之路5: 条件反射式移动

移动命令使用频率非常之高&#xff0c;只要方法多一个小小的弯路&#xff0c;对使用体验影响都很大。 克服移动上的难度&#xff0c;离掌握Emacs就不远了。 在不安装其它包的情况下&#xff0c;Emacs就可以&#xff1a; 以行为单位移动&#xff1a; C-n/C-p以段落为单位移动&…
阅读更多...
基于单片机的WIFI、语音、储存、时钟、闹钟、定位系统

基于单片机的WIFI、语音、储存、时钟、闹钟、定位系统

所有仿真详情导航&#xff1a; PROTEUS专栏说明-CSDN博客 目录 一、主要功能 二、硬件资源 三、程序编程 四、实现现象 一、主要功能 基于51单片机&#xff0c;采用DS1302时钟模块&#xff0c;通过LCD1602显示实时时间&#xff0c;也可以储存时间在AT2DC02中&#xff0c…
阅读更多...
【阅读记录-章节4】Build a Large Language Model (From Scratch)

【阅读记录-章节4】Build a Large Language Model (From Scratch)

文章目录 4. Implementing a GPT model from scratch to generate text4.1 Coding an LLM architecture4.1.1 配置小型 GPT-2 模型4.1.2 DummyGPTModel代码示例4.1.3 准备输入数据并初始化 GPT 模型4.1.4 初始化并运行 GPT 模型 4.2 Normalizing activations with layer normal…
阅读更多...
[创业之路-158]：《BLM战略规划》BLM业务业务领先模型与从战略到执行-模型（DSTE)

[创业之路-158]：《BLM战略规划》BLM业务业务领先模型与从战略到执行-模型（DSTE)

目录 一、BLM业务业务领先模型 - 整体框架 1.1 战略制定 1.2 战略执行 二、战略领导力&#xff1a;洞察&#xff08;看的远、看得深&#xff09;、决断&#xff08;看得清&#xff09;、执行力&#xff08;做得快、做得好&#xff09; 2.1 基本框架&#xff1a;战略制定、…
阅读更多...
配置 Android Studio cursor/vscode 环境（切换 Flutter 版本）

配置 Android Studio cursor/vscode 环境（切换 Flutter 版本）

系统环境变量 Path Android Studio 配置 Java 系统变量 Path PS&#xff1a;
阅读更多...
Qt几何数据类型：QPoint类型详解（基础向）

Qt几何数据类型：QPoint类型详解（基础向）

目录 QPoint类 QPoint的构造 QPoint公有方法 isNull() rx() ry() setX() setY() toCGPoint() toPointF() transposed() x() y() manhattanLength() 各类重载运算符 QPoint的静态方法 dotproduct() QPoint类 在 Qt 框架中&#xff0c;QPoint 是一个简单且常用的类&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023