2024.7.19 作业

最新推荐文章于 2024-07-19 22:17:56 发布
最新推荐文章于 2024-07-19 22:17:56 发布
阅读量103 收藏
点赞数 1
文章标签： windows
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_64434282/article/details/140554763
版权

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;
}

思维导图

黑夜〆白天151
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
作业2024.6.4.sql
06-25
作业2024.6.4.sql
信号大作业2024项目.7z
06-24
信号大作业2024项目.7z
2024高频作业题答案.zip
06-25
2024高频作业题答案.zip
2023-04-06-项目笔记 - 第七十七阶段 - 4.4.2.75全局变量的作用域-75 -2024.03.19
03-19
2023-04-06-项目笔记-第七十七...写代码注意代码风格 4.3.1变量的使用 4.4变量的作用域与生命周期 4.4.1局部变量的作用域 4.4.2全局变量的作用域 4.4.2.1全局变量的作用域_1 4.4.2.75全局变量的作用域_75 - 2024-03-19
2023-04-06-项目笔记 - 第一百六十九阶段 - 4.4.2.167全局变量的作用域-167 -2024.06.19
06-19
2023-04-06-项目笔记-第一百六...写代码注意代码风格 4.3.1变量的使用 4.4变量的作用域与生命周期 4.4.1局部变量的作用域 4.4.2全局变量的作用域 4.4.2.1全局变量的作用域_1 4.4.2.169全局变量的作用域_167- 2024-06-19
【入门基础】java泛型和通配符详解
杰叔叔不是个好叔叔的博客
07-19 443
Java泛型（Generics）是JDK 5中引入的一个新特性，它提供了编译时类型安全检测机制，允许程序员在编译时检测到非法的类型。泛型的主要目的是在编译期间对类型进行检查，使得类型错误能在编译时而不是运行时被捕获，从而提高程序的稳定性和安全性。同时，它也消除了类型转换的代码，使得代码更加简洁和易于维护。需要注意的是，上述非主流用法并非推荐的做法，它们可能增加代码的复杂性和出错的风险。在大多数情况下，应优先考虑使用泛型和通配符的主流用法来编写清晰、简洁、易于维护的代码。
C++基础语法:STL之容器(5)--序列容器中的list(二)
最新发布
jllws1的博客
07-19 729
"打牢基础,万事不愁" .C++的基础语法的学习。
共享模型之无锁
快乐的小三菊的博客
07-19 500
共享模型之无锁
RK3328 Debian安装OpenMediaVault
阿xin*的嵌入式AI
07-19 161
在RK3328板卡上运行Debian系统，安装OpenMediaVault套件的全过程，用于NAS服务。
list容器
MXZSL的博客
07-19 473
学习笔记
cephrgw lifecycle理解
yueyingshaqiu01的博客
07-19 224
看代码是WriteOP）3，cls_rgw_lc_get_entry 获取entry，因为entry的状态是processing。3，cls_rgw_lc_get_entry 获取entry，成功，但是为empty。2，cls_rgw_lc_get_head 获取对象的head，成功。2，cls_rgw_lc_get_head 获取对象的head，成功。2，cls_rgw_lc_get_head 获取对象的head，成功。3，cls_rgw_lc_get_entry 获取entry，成功。
Linux文件和目录常用命令
loongnoy的博客
07-19 219
可以理解为现实生活中的管子，管子的一头塞东西进去，另一头取出来，这里 | 的左右分为俩端，左端塞东西（写），右端取东西（读）ls 是英文单词 list 的简写，其功能为列出目录的内容，是用户最常用的命令之一，类似于 DOs 下的dir 命令。-r 若给出的源文件是目录文件，则cp将递归复制该目录下的所有子目录和文件，目标文件必须为一个目录名。·cp 命令的功能是将给出的文件或目录复制到另一个文件或目录中，相当于DOS下的copy命令。的简写，其功能为更改当前的工作目录，也是用户最常用的命令之一。
cephrgw元数据和数据布局
yueyingshaqiu01的博客
07-19 169
提示：每个rados object有如下几个组成部分，分别是omap（omapheader、omapkey、omapval）、xattr、data，相关的CLI command。如storage_class、mtime、size、etag、content_type、存放的pool。part、stripe（每个part最大15MB，每个stripe最大4MB，stripe是基本单元）[4MB, 15MB]的对象，有head、tail radosobject。bucket中对象的布局信息。
自动化文档的魔法：Conda中包依赖的文档生成指南
2401_85762266的博客
07-16 622
在Python项目开发中，管理和记录包依赖是至关重要的一步。Conda不仅是一款强大的包管理器，还能够帮助我们自动生成依赖文档，这对于项目的维护和分享至关重要。本文将详细介绍如何在Conda环境中使用包依赖自动文档生成工具，让你的依赖管理更加高效和专业。在任何软件开发项目中，清晰地记录和管理依赖关系对于以下方面至关重要：Conda提供了多种工具来生成依赖文档，其中最常用的是和。命令可以列出当前环境中安装的所有包及其版本信息。你可以将这个命令的输出保存到一个文本文件中，作为依赖列表的记录。 conda env
0711springNews新闻系统管理 实现多级评论
weixin_45939821的博客
07-19 640
实现链表，通过一个父评论可以找到它对应的所有子孙评论。
【C语言】 作业11 链表+实现函数封装
2301_77133426的博客
07-19 105
链表，创建链表，申请节点，判空，头插，遍历输出，通过位置查找节点，任意位置插入，头删，任意位置删除，安置查找返回位置，按位置进行修改，按值进行修改，翻转链表，释放链表，链表的排序，反转链表（递归实现）
掌握Conda环境管理：使用conda env remove命令的精要
2401_85742452的博客
07-16 674
命令是Conda环境管理中一个非常有用的工具，它提供了灵活的方式来删除不再需要的环境。通过本文的详细介绍，你应该已经了解了如何使用命令来管理你的Conda环境。希望本文能够帮助你更有效地管理你的Python项目环境，确保开发环境的整洁和一致性。以上就是关于如何在Conda中使用命令删除环境的详细介绍。如果你有任何疑问或需要进一步的指导，请随时与我们联系。
Java中的Stream流
炭烤玛卡巴卡的博客
07-15 633
注意1：中间方法，返回新的Stream流，原来的Stream流只能使用一次，建议使用链式编程。需求：按照下面的要求完成集合的创建和遍历创建一个集合，存储多个字符串元素。2.统计 打印 终结方法：最后一步，调用完毕之后，不能调用其他方法。注意2：修改Stream流中的数据，不会影响原来集合或者数组中的数据。1.过滤 转换 中间方法：方法调用完毕之后，还可以调用其他方法。①先得到一条Stream流（流水线），并把数据放上去。结合Lambda表达式，简化集合、数组的操作。
JAVA基础--lambda表达式
2301_79659699的博客
07-19 642
通过一系列的流操作（如map、filter、sorted等），我们可以以声明性的方式构建复杂的数据处理管道，实现数据的转换和聚合。通过使用Lambda表达式，我们可以将算法的实现作为参数传递给方法，从而实现算法的灵活配置和替换。Lambda表达式作为一种匿名函数的简洁表示方式，在多种编程语言中都有广泛的应用，尤其在Java 8及更高版本中得到了广泛的支持和使用。综上所述，Lambda表达式在Java编程中具有广泛的用途，它可以提高代码的可读性、可维护性和灵活性，使得Java编程更加简洁和高效。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值