2024.7.19 作业

news2024/9/20 16:57:56

1.链表的排序

int list_sort(NodePtr L)
{
	    if(NULL==L || L->len<=1)
    	{
	 	    printf("排序失败");
        	return -1;
    	}
   
    	int len=L->len+1;
    	NodePtr p;
    	int i,j;
    	for( i=1;i<len;i++)
    	{
        	for( j=0,p=L;j<len-i;j++,p=p->next)
        	{
            		if( p->data > p->next->data )
            		{
                		datatype t=p->data;
                		p->data=p->next->data;
                		p->next->data=t;
            		}
        	}
    	}
	    printf("排序成功\n");
	    return 0;
}

2.链表的反转（递归实现）

// 递归反转链表  
NodePtr list_fz(NodePtr L) 
{  
	    // 基础情况：空链表或只有一个节点  
    	if (L == NULL || L->next == NULL) 
	    {  
        	return L;  
    	}  

   	    NodePtr new_L = list_fz(L->next);  

   	    L->next->next = L;  
    	L->next = NULL;

    	return new_L; 
}

3.链表去重


// 去重函数
int list_dr(NodePtr L) 
{
	 NodePtr current = L;
     NodePtr prev = NULL;

   	 while (current != NULL) 
	 {
        	NodePtr runner = L;
        	prev = NULL;
        	int flag = 0;

        	// 查找当前节点的重复项
        	while (runner != current) 
		    {
            		if (runner->data == current->data) 
			        {
                		flag = 1;
                		break;
            		}
            		prev = runner;
            		runner = runner->next;
        	}

        	if (flag) 
		    {
            		// 如果是重复节点，删除当前节点
            		NodePtr temp = current;
            		if (prev != NULL) 
			        {
                		prev->next = current->next;
            		} 
			        else 
			        {
                		L = current->next; // 更新头节点
            
			        }
            		current = current->next;
            		free(temp);
        	} 	
		    else 	
		    {
            		current = current->next;
        	}
    	}
}

linklist.h

#ifndef LINKLIST_H

#define LINKLIST_H
#include <myhead.h>

typedef int datatype;

typedef struct Node
{
	union
	{
		int len;
		datatype data;
	};

	struct Node *next;
}Node,*NodePtr;

//创建链表
NodePtr list_create();

//申请节点封装数据函数
NodePtr apply_node(datatype e);

//链表判空
int list_empty(NodePtr L);

//头插
int list_insert_head(NodePtr L,datatype e);

//链表遍历函数
int list_show(NodePtr L);

//通过位置查找节点
NodePtr list_search_pos(NodePtr L,int pos);

//任意位置插入
int list_insert_pos(NodePtr L,int pos,datatype e);

//链表头删
int list_delete_head(NodePtr L);

//任意位置删除
int list_delete_pos(NodePtr L,int pos);

//通过值查找返回位置
int list_search_value(NodePtr L,datatype e);

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

//链表按值进行修改
int list_update_value(NodePtr L,datatype old_e,datatype new_e);

//将链表进行翻转
void list_reverse(NodePtr L);

//释放链表
void list_destroy(NodePtr L);

//链表排序
int list_sort(NodePtr L);

// 去重函数
int list_dr(NodePtr head);

// 递归反转链表 
NodePtr list_fz(NodePtr L);


#endif

linklist.c

#include "linklist.h"

NodePtr list_create()
{
	NodePtr L=(NodePtr)malloc(sizeof(Node));
	if(NULL==L)
	{
		printf("创建失败\n");
		return NULL;
	}
	L->len=0;
	L->next=NULL;
	printf("链表创建成功\n");
	return L;
}

//申请节点封装数据函数
NodePtr apply_node(datatype e)
{
	NodePtr p=(NodePtr)malloc(sizeof(Node));
	if(NULL==p)
	{
		printf("申请失败\n");
		return NULL;
	}
	p->data = e;
	p->next = NULL;
	return p;
}

//链表判空
int list_empty(NodePtr L)
{
	return L->next ==NULL;
}

//头插
int list_insert_head(NodePtr L,datatype e)
{
	if(NULL==L)
	{
		printf("链表不合法\n");
		return -1;
	}
	NodePtr p = apply_node(e);
	if(NULL==p)
	{
		return -1;
	}
	p->next=L->next;
	L->next=p;
	
	L->len++;
	printf("头插成功\n");
	return 0;

}

//链表遍历函数
int list_show(NodePtr L)
{
	if(NULL==L || list_empty(L))
	{
		printf("遍历失败\n");
		return -1;
	}	

	NodePtr q = L->next;
	while(q!=NULL)
	{
		printf("%d\t",q->data);
		q=q->next;
	}
	putchar(10);
}

//通过位置查找节点
NodePtr list_search_pos(NodePtr L,int pos)
{
	if(NULL==L || list_empty(L) || pos<0 || pos>L->len)
	{
		printf("查找失败\n");
		return NULL;
	}
	NodePtr q= L;
	for(int i=0;i<pos;i++)
	{
		q=q->next;
	}
	return q;
}

//任意位置插入
int list_insert_pos(NodePtr L,int pos,datatype e)
{
	if(NULL==L || pos<=0 ||pos>L->len+1)
	{
		printf("插入失败\n");
		return -1;
	}
	NodePtr p = apply_node(e);
	if(NULL==p)
	{
		return -1;
	}
	NodePtr q =list_search_pos(L,pos-1);

	p->next=q->next;
	q->next=p;
	
	L->len++;
	printf("插入成功\n");
	return 0;
}


//链表头删
int list_delete_head(NodePtr L)
{
	if(NULL==L || list_empty(L))
	{
		printf("删除失败\n");
		return -1;
	}
	NodePtr p=L->next;
	L->next=p->next;
	free(p);
	p=NULL;

	L->len--;
	printf("头删成功\n");
	return 0;
}

//任意位置删除
int list_delete_pos(NodePtr L,int pos)
{
	if(NULL==L || list_empty(L) || pos<1 || pos>L->len)
	{
		printf("删除失败\n");
		return -1;
	}
	NodePtr q=list_search_pos(L,pos-1);
	NodePtr p=q->next;
	q->next =p->next;
	free(p);
	p=NULL;

	L->len--;
	printf("删除成功\n");
	return 0;
}

//通过值查找返回位置
int list_search_value(NodePtr L,datatype e)
{
	if(NULL==L || list_empty(L))
	{
		printf("查找失败\n");
		return -1;
	}

	NodePtr q=L->next;
	for(int index=1;index<=L->len;index++)
	{
		if(q->data==e)
		{
			return index;
		}
		q=q->next;
	}
	printf("没找到\n");
	return -1;
}

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

	list_search_pos(L,pos)->data = e;
	printf("修改成功\n");
	return 0;
}

//链表按值进行修改
int list_update_value(NodePtr L,datatype old_e,datatype new_e)
{
	if(NULL==L || list_empty(L))
	{
		printf("修改失败\n");
		return -1;
	}
	int res = list_search_value(L,old_e);
	if(res == -1)
	{
		printf("没有要修改的值\n");
		return -1;
	}
	list_update_pos(L,res,new_e);
	printf("修改成功\n");
	return 0;

}

//将链表进行翻转
void list_reverse(NodePtr L)
{
	if(NULL==L || L->len<=1)
	{
		printf("翻转失败\n");
		return;
	}
	NodePtr H = L->next;
	L->next = NULL;
	NodePtr p = NULL;
	while(H!=NULL)
	{
		p=H;
		H=H->next;
		p->next =L->next;
		L->next =p;
	}
	printf("翻转成功\n");
	return;
}

//释放链表
void list_destroy(NodePtr L)
{
	//判断逻辑
    	if(NULL == L)
    	{
        	return;
    	}

    	//将所有结点进行释放
    	while(!list_empty(L))
    	{
        	//头删
        	list_delete_head(L);
    	}

    	//释放头结点
    	free(L);
    	L = NULL;

    	printf("释放成功\n");
}




//链表排序
int list_sort(NodePtr L)
{
	if(NULL==L || L->len<=1)
    	{
	 	printf("排序失败");
        	return -1;
    	}
   
    	int len=L->len+1;
    	NodePtr p;
    	int i,j;
    	for( i=1;i<len;i++)
    	{
        	for( j=0,p=L;j<len-i;j++,p=p->next)
        	{
            		if( p->data > p->next->data )
            		{
                		datatype t=p->data;
                		p->data=p->next->data;
                		p->next->data=t;
            		}
        	}
    	}
	printf("排序成功\n");
	return 0;
}


// 递归反转链表  
NodePtr list_fz(NodePtr L) 
{  
	// 基础情况：空链表或只有一个节点  
    	if (L == NULL || L->next == NULL) 
	{  
        	return L;  
    	}  

   	NodePtr new_L = list_fz(L->next);  

   	L->next->next = L;  
    	L->next = NULL;

    	return new_L; 
} 




// 去重函数
int list_dr(NodePtr L) 
{
	NodePtr current = L;
    	NodePtr prev = NULL;

   	 while (current != NULL) 
	 {
        	NodePtr runner = L;
        	prev = NULL;
        	int flag = 0;

        	// 查找当前节点的重复项
        	while (runner != current) 
		{
            		if (runner->data == current->data) 
			{
                		flag = 1;
                		break;
            		}
            		prev = runner;
            		runner = runner->next;
        	}

        	if (flag) 
		{
            		// 如果是重复节点，删除当前节点
            		NodePtr temp = current;
            		if (prev != NULL) 
			{
                		prev->next = current->next;
            		} 
			else 
			{
                		L = current->next; // 更新头节点
            
			}
            		current = current->next;
            		free(temp);
        	} 	
		else 	
		{
            		current = current->next;
        	}
    	}
}

main.c

#include"linklist.h"

int main(int argc, const char *argv[])
{
    
	//调用函数创建一个链表
    	NodePtr L = list_create();
    	if(NULL == L)
    	{
        	return -1;
    	}

    	//调用头插函数
    	list_insert_head(L, 520);
    	list_insert_head(L, 1314);
    	list_insert_head(L, 666);
    	list_insert_head(L, 999);
    
    	//调用遍历函数
    	list_show(L);

    	//调用任意位置插入函数
    	list_insert_pos(L, 1, 100);
   	    list_insert_pos(L, 3, 100);
    	list_insert_pos(L, L->len+1, 100);
    	list_show(L);
	    printf("排序: ");
	    list_sort(L);
	    list_show(L);
	    printf("去重：");
	    list_dr(L);
	    list_show(L);
	    printf("反转：");
	    L->next=list_fz(L->next);
	    list_show(L);
    	return 0;
}

思维导图

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

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

相关文章

基于51单片机的步进电机控制系统proteus仿真

基于51单片机的步进电机控制系统proteus仿真

地址&#xff1a;https://pan.baidu.com/s/1jFlIJ9I5qxjW8sYKd6vrBQ?pwd9d6q 提取码&#xff1a;1234 仿真图&#xff1a; 芯片/模块的特点&#xff1a; AT89C52/AT89C51简介&#xff1a; AT89C52/AT89C51是一款经典的8位单片机&#xff0c;是意法半导体&#xff08;STMic…
阅读更多...
阿里开源的音频模型_原理与实操

阿里开源的音频模型_原理与实操

英文名称: FunAudioLLM: Voice Understanding and Generation Foundation Models for Natural Interaction Between Humans and LLMs 中文名称: FunAudioLLM: 人与LLMs之间自然互动的语音理解和生成基础模型 论文地址: http://arxiv.org/abs/2407.04051v3 相关论文&#xff1a;…
阅读更多...
1、springboot3 vue3开发平台-后端-项目构建

1、springboot3 vue3开发平台-后端-项目构建

文章目录 1. 创建项目1.1 前置环境条件1.2 项目创建 2. 模块配置2.1 父工程配置概述2.2 配置启动模块2.3 父工程相关依赖管理 1. 创建项目 1.1 前置环境条件 idea2023, jdk17 1.2 项目创建 创建父工程并删除不需要的文件目录&#xff1a; 右键父工程依次创建其他模块 最…
阅读更多...
Java | Leetcode Java题解之第260题只出现一次的数字III

Java | Leetcode Java题解之第260题只出现一次的数字III

题目&#xff1a; 题解&#xff1a; class Solution {public int[] singleNumber(int[] nums) {int xorsum 0;for (int num : nums) {xorsum ^ num;}// 防止溢出int lsb (xorsum Integer.MIN_VALUE ? xorsum : xorsum & (-xorsum));int type1 0, type2 0;for (int n…
阅读更多...
vue2.0结合使用 el-scrollbar 和 v-for实现一个横向滚动的元素列表，并且能够自动滚动到指定元素（开箱即用）

vue2.0结合使用 el-scrollbar 和 v-for实现一个横向滚动的元素列表，并且能够自动滚动到指定元素（开箱即用）

效果图&#xff1a; 代码&#xff1a; <div class"gas-mode-item-body"><el-scrollbar style"width: 300px;height: 100%;" wrap-style"overflow-y:hidden" ref"scrollbarRef"><div style"display: flex&quo…
阅读更多...
python-最小公倍数(PythonTip)

python-最小公倍数(PythonTip)

[题目描述] 编写一个程序&#xff0c;找出能被从1到给定数字n&#xff08;包括n&#xff09;的所有数字整除的最小正数(即最小公倍数)。 定义函数smallest_multiple()的函数&#xff0c;参数为n。 在函数内&#xff0c;返回能被从1到给定数字n&#xff08;包括n&#xff09;的…
阅读更多...
珈和科技完成全国首个农险服务类数据产品入表，实现数据资产化

珈和科技完成全国首个农险服务类数据产品入表，实现数据资产化

近日&#xff0c;珈和科技与东湖大数据合作&#xff0c;完成全国首个保险服务类数据产品入表&#xff0c;标志着我国商业卫星遥感应用领域迈出了数据资产化的关键一步。 此次入表的数据产品为“华北农业保险服务数据集数据产品”&#xff0c;是珈和科技融合卫星遥感与无人机等…
阅读更多...
数据结构----栈

数据结构----栈

前言 Hello&#xff0c;小伙伴们&#xff0c;今天我们继续数据结构的学习&#xff0c;前面我们学习了顺序表和链表的实现&#xff0c;今天的栈知识也是和前面的知识相辅相成。 如果你喜欢我的内容的话&#xff0c;就请不要吝啬自己手中的三连哟&#xff0c;万分感谢&#xff…
阅读更多...
# Redis 入门到精通（七）-- redis 删除策略

# Redis 入门到精通（七）-- redis 删除策略

Redis 入门到精通&#xff08;七&#xff09;-- redis 删除策略 一、redis 删除策略–过期数据的概念 1、Redis 中的数据特征 Redis 是一种内存级数据库&#xff0c;所有数据均存放在内存中&#xff0c;内存中的数据可以通过TTL指令获取其状态。 XX &#xff1a;具有时效性…
阅读更多...
Android Studio引入ndk编译的so库, 通过jni给Java程序使用

Android Studio引入ndk编译的so库, 通过jni给Java程序使用

前言 工作要求将一个C老项目的函数用ndk打包成库给安卓同事的java程序调用。 这个任务我debuff拉满&#xff1a; 自己之前从来没接触过安卓开发&#xff0c;问了老板为什么不让安卓开发来干&#xff0c;老板说安卓开发不懂c&#xff0c;公司就我一个是懂c的。。。项目开发年…
阅读更多...
【STM32嵌入式系统设计与开发---拓展】——1_10矩阵按键

【STM32嵌入式系统设计与开发---拓展】——1_10矩阵按键

这里写目录标题 1、矩阵按键2、代码片段分析 1、矩阵按键 通过将4x4矩阵按键的每一行依次设为低电平&#xff0c;同时保持其它行为高电平&#xff0c;然后读取所有列的电平状态&#xff0c;可以检测到哪个按键被按下。如果某列变为低电平&#xff0c;说明对应行和列的按键被按下…
阅读更多...
day2 单机并发缓存

day2 单机并发缓存

文章目录 1 sync.Mutex2 支持并发读写3 主体结构 Group3.1 回调 Getter3.2 Group 的定义3.3 Group 的 Get 方法 4 测试 本文代码地址&#xff1a; https://gitee.com/lymgoforIT/gee-cache/tree/master/day2-single-node 本文是7天用Go从零实现分布式缓存GeeCache的第二篇。 …
阅读更多...
go 实现websocket以及详细设计流程过程，确保通俗易懂

go 实现websocket以及详细设计流程过程，确保通俗易懂

websocket简介&#xff1a; WebSocket 是一种网络传输协议&#xff0c;可在单个 TCP 连接上进行全双工通信&#xff0c;位于 OSI 模型的应用层。WebSocket 协议在 2011 年由 IETF 标准化为 RFC 6455&#xff0c;后由 RFC 7936 补充规范。 WebSocket 使得客户端和服务器之间的数…
阅读更多...
昇思学习打卡-21-生成式/Diffusion扩散模型

昇思学习打卡-21-生成式/Diffusion扩散模型

文章目录 Diffusion扩散模型介绍模型推理结果 Diffusion扩散模型介绍 关于扩散模型&#xff08;Diffusion Models&#xff09;有很多种理解&#xff0c;除了本文介绍的离散时间视角外&#xff0c;还有连续时间视角、概率分布转换视角、马尔可夫链视角、能量函数视角、数据增强…
阅读更多...
《样式设计003：布局-自定义view模块》

《样式设计003：布局-自定义view模块》

描述&#xff1a;在开发小程序过程中&#xff0c;发现一些不错的案例&#xff0c;平时使用也比较多&#xff0c;稍微总结了下经验&#xff0c;以下内容可以直接复制使用&#xff0c;希望对大家有所帮助&#xff0c;废话不多说直接上干货&#xff01; 一、布局-自定义view模块 …
阅读更多...
el-popover嵌套select弹窗点击实现自定义关闭

el-popover嵌套select弹窗点击实现自定义关闭

需求 el-popover弹窗内嵌套下拉选择框&#xff0c;点击el-popover弹出外部区域需关闭弹窗&#xff0c;点击查询、重置需关闭弹窗&#xff0c; 实现 根据需求要自定义弹窗的关闭和显示&#xff0c;首先想到的是visible属性&#xff0c;在实现过程中经过反复的测验&#xff0…
阅读更多...
服务级别协议SLA与运营水平协议OLA

服务级别协议SLA与运营水平协议OLA

使用美团或饿了么在线订餐时&#xff0c;您将体验到即时的送餐提醒服务。首先&#xff0c;选择您想要的食品。系统会根据餐厅与您的位置、所选食品的种类&#xff0c;以及下单的具体时间&#xff0c;计算预计的等待时间和送餐费用&#xff0c;并将这些信息与您共享。这种信息的…
阅读更多...
剖析SGI-STL二级空间配置器

剖析SGI-STL二级空间配置器

概述 SGI-STL与C标准库提供的STL一样&#xff0c;都通过空间配置器allocator来申请或释放容器的空间。空间配置器的作用可以参考&#xff1a;浅谈C空间配置器allocator及其重要性 // C标准库的vector template < class T, class Alloc allocator<T> > class vec…
阅读更多...
混淆专题一——简单AA,JJ,JSFuck混淆处理办法

混淆专题一——简单AA,JJ,JSFuck混淆处理办法

以AA混淆为例 网址&#xff1a;Scrape | NBA 想要获取球员的信息&#xff0c;但找不到包。 刷新页面&#xff0c;main.js中找到混淆的代码&#xff0c;这串混淆代码就是球员信息。 如何处理&#xff1a; 复制下来&#xff0c;去除最后的笑脸 (_)&#xff0c;然后在控制台打…
阅读更多...
启智集装箱箱号识别技术，更高效快捷

启智集装箱箱号识别技术，更高效快捷

在当今这个信息技术高速发展的时代&#xff0c;集装箱箱号识别技术在全球物流领域扮演着至关重要的角色。随着物流行业的不断壮大和复杂化&#xff0c;对集装箱箱号识别的准确性、效率性和便捷性提出了更高的要求。启智集装箱箱号识别技术应运而生&#xff0c;以其高效快捷的特…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023