单向链表的操作以及循环单向链表以及双向链表初步学习(7.19)

最新推荐文章于 2024-06-10 00:35:53 发布
最新推荐文章于 2024-06-10 00:35:53 发布
阅读量47 收藏
点赞数
文章标签： 链表 学习 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62318298/article/details/131817067
版权

一、单向链表完整操作

代码编写采用多文件编译方式：

主函数：main.c；头文件：head.h；封装函数：test.c；

head.h

#ifndef __HEAD_H
#define __HEAD_H


#include <stdio.h>
#include <string.h>
#include <stdlib.h>
//创建一个单链表
typedef int datatype;
typedef struct Node
{
	//数据元素
	int data;
	//指针域:存储下一个节点地址
	struct Node *next;
}*Linklist;
//申请空间
Linklist Creat_node();
//单链表头插
Linklist Insert_head(datatype e,Linklist L);
//循环遍历输出
int Output(Linklist L);
//单链表尾插
Linklist Insert_rear(datatype e,Linklist L);
//头删除
Linklist Delete_head(Linklist L);
//尾删除
Linklist Delete_rear(Linklist L);
//按任意位置插入
Linklist Insert_pos(int pos,datatype e,Linklist L);
//按任意位置查找
int Serach_pos(int pos,Linklist L);
//按任意位置修改
int Update_pos(int pos,datatype e,Linklist L);
//按任意位置删除
Linklist Delete_pos(int pos,Linklist L);
//按任意元素查找
int Serach_data(datatype data,Linklist L);
//按任意元素插入
Linklist Insert_data(datatype e,datatype data,Linklist L);
//按任意元素修改
int Update_data(datatype e,datatype data,Linklist L);
//按任意元素删除
Linklist Delete_data(datatype data,Linklist L);
//逆置
Linklist rev_Linklist(Linklist L);
//链表释放
Linklist free_space(Linklist L);
//冒泡排序
void Bubble(Linklist L);
//简单选择排序
void Simple(Linklist L);
#endif

main.c

#include "head.h"
int main(int argc, const char *argv[])
{
	//单链表的头插
	Linklist L=NULL;
	int n;
	datatype e;
	printf("请输入n的值:");
	scanf("%d",&n);

	for(int i=0;i<n;i++)
	{
		printf("请输入第%d个链表数据：",i+1);
		scanf("%d",&e);
		L=Insert_head(e,L);
	}

	//尾插
	for(int i=0;i<n;i++)
	{
		printf("请输入第%d个链表数据：",i+1);
		scanf("%d",&e);
		L=Insert_rear(e,L);
	}
	//循环链表
	Output(L);
	//头删除
	Delete_head(L);
	Output(L);
    //尾部删除
	L=Delete_rear(L);
	Output(L);

	//按任意位置插入
	int pos;
	printf("请输入要插入的位置：");
	scanf("%d",&pos);
	printf("请输入要插入的数据：");
	scanf("%d",&e);
	L=Insert_pos(pos,e,L);
	Output(L);

	//按任意位置查找
	printf("请输入要查找的位置：");
	scanf("%d",&pos);
	Serach_pos(pos,L);

	//按任意位置修改
	printf("请输入要修改的位置：");
	scanf("%d",&pos);
	printf("请输入修改后的数据：");
	scanf("%d",&e);
	Update_pos(pos,e,L);
	Output(L);

	//按任意位置删除
	printf("请输入要删除的位置：");
	scanf("%d",&pos);
	L=Delete_pos(pos,L);
	Output(L);


	//按元素查找
	datatype data;
	printf("请输入要查找的元素：");
	scanf("%d",&data);
	int data_pos=Serach_data(data,L);
	if(data_pos==-1)
		printf("查找失败\n");
	else
		printf("该元素在%d位置\n",data_pos);

	//任意元素插入
	printf("请输入要插入的元素：");
	scanf("%d",&data);
	printf("请输入插入元素的值：");
	scanf("%d",&e);
	L=Insert_data(e,data,L);
	Output(L);

	//任意元素修改
	printf("请输入要修改的元素：");
	scanf("%d",&data);
	printf("请输入修改后的元素：");
	scanf("%d",&e);
	Update_data(e,data,L);
	Output(L);
	
	//任意元素删除
	printf("请输入要删除的元素：");
	scanf("%d",&data);
	L=Delete_data(data,L);
	Output(L);

	//冒泡排序
	Bubble(L);

	//简单选择排序
	Simple(L);
	Output(L);

	//链表逆置
	L=rev_Linklist(L);
	Output(L);

	//链表释放
	L=free_space(L);


	return 0;
}

test.c

#include "head.h"
/*
 * function:    申请空间,创建节点
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist Creat_node()
{
	Linklist node=(Linklist)malloc(sizeof(struct Node));
	if(NULL==node)
		return NULL;
	node->data=0;
	node->next=NULL;
	return node;
}
/*
 * function:    头插
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist Insert_head(datatype e,Linklist L)
{
	Linklist node=Creat_node();
	node->data=e;
	node->next=L;
	L=node;
	return L;

}
/*
 * function:    循环遍历输出
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int Output(Linklist L)
{
	if(NULL==L)
	{
		printf("打印失败\n");
		return -1;
	}
	while(L!=NULL)
	{
		printf("%d\t",L->data);
		L=L->next;
	}
	puts("");
	return 0;
}
/*
 * function:    单链表尾插
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist Insert_rear(datatype e,Linklist L)
{
	//创建一个新节点
	Linklist s=Creat_node();
	s->data=e;
	if(NULL==L)
	{
		L=s;
	}
	else
	{
		//指向最后一个节点的地址
		Linklist rear=L;
		while(rear->next!=NULL)
		{
			rear=rear->next;
		}
		rear->next=s;
	}
	return L;
}
/*
 * function:    头删除
 * @param [ in] 
 * @param [out] 
 * @return   
 */
 Linklist Delete_head(Linklist L)
{
	if(NULL==L)
	{
		return L;
	}
	if(L->next==NULL)
	{
		free(L);
		L=NULL;
	}
	else
	{
		Linklist q=L->next;
		L->data=q->data;
		L->next=q->next;
		free(q);
		q=NULL;
	}
	return L;
}
/*
 * function:    尾部删除
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist Delete_rear(Linklist L)
{
	//判断是否存在链表
	if(L==NULL)
	{
		return NULL;
	}
	//判断链表中只有一个节点
	else if(L->next==NULL)
	{
		free(L);
		L=NULL;
	}
	else
	{
		//有多个节点
		//循环倒数第二个节点
		Linklist second=L;
		while(second->next->next!=NULL)
		{
			second=second->next;
		}
		free(second->next);
		second->next=NULL;
	}
	return L;
}
/*
 * function:    计算长度
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int Len_linklist(Linklist L)
{
	int count=0;
	while(L!=NULL)
	{
		L=L->next;
		count++;
	}
	return count;
}
/*
 * function:    单链表任意位置插入
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist Insert_pos(int pos,datatype e,Linklist L)
{
	int len=Len_linklist(L);
	if(NULL==L||pos<1||pos>len+1)
	{
		printf("插入失败\n");
		return L;
	}
	Linklist p=L;
	if(pos==len+1)
	{
		Insert_rear(e,L);
		return L;
	}
	for(int i=1;i<pos;i++)
	{
		p=p->next;
	}
	Linklist s=Creat_node();
	s->next=p->next;
	p->next=s;
	s->data=p->data;
	p->data=e;
	return L;
}
/*
 * function:    按任意位置查找
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int Serach_pos(int pos,Linklist L)
{
	int len=Len_linklist(L);
	if(NULL==L||pos<1||pos>len)
	{
		printf("查找失败\n");
		return -1;
	}
	Linklist p=L;
	for(int i=1;i<pos;i++)
	{
		p=p->next;
	}
	printf("查找的值为：%d\n",p->data);
}
/*
 * function:    按任意位置修改
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int Update_pos(int pos,datatype e,Linklist L)
{
	int len=Len_linklist(L);
	if(NULL==L || pos<1 || pos>len)
	{
		printf("修改失败\n");
		return -1;
	}
	Linklist p=L;
	for(int i=1;i<pos;i++)
	{
		p=p->next;
	}
	p->data=e;
	return 0;

	
}
/*
 * function:    按任意位置删除
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist Delete_pos(int pos,Linklist L)
{
	if(NULL==L||pos<1||pos>Len_linklist(L))
	{
		printf("删除失败\n");
		return L;
	}
	if(pos==1)
	{
		L=Delete_head(L);
		return L;
	}
	//找到pos的前一个位置
	Linklist p=L;
	for(int i=1;i<pos-1;i++)
	{
		p=p->next;
	}
	Linklist q=p->next;
	p->next=q->next;
	free(q);
	q=NULL;
	return L;

}
/*
 * function:    按元素查找
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int Serach_data(datatype data,Linklist L)
{
	if(NULL==L)
	{
		return -1;
	}
	int pos=0;
	while(L!=NULL)
	{
		pos++;
		if(L->data==data)
		{
			return pos;
		}
		L=L->next;
	}
	return -1;

}
/*
 * function:    按任意元素插入
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist Insert_data(datatype e,datatype data,Linklist L)
{
	if(NULL==L)
	{
		printf("插入失败\n");
		return L;
	}
	int pos=Serach_data(data,L);
	if(pos==-1)
		printf("插入失败\n");
	else
	L=Insert_pos(pos,e,L);
	return L;
}
/*
 * function:    任意元素修改
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int Update_data(datatype e,datatype data,Linklist L)
{
	if(NULL==L)
	{
		printf("修改失败\n");
		return -1;
	}
	int pos=Serach_data(data,L);
	if(pos==-1)
		printf("修改失败\n");
	else
		Update_pos(pos,e,L);
	return 0;
}
/*
 * function:    任意元素删除
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist Delete_data(datatype data,Linklist L)
{
	if(NULL==L)
	{
		printf("删除失败\n");
		return L;
	}
	int pos=Serach_data(data,L);
	if(pos==-1)
		return L;
	else
		L=Delete_pos(pos,L);
	return L;
}
/*
 * function:    链表逆置
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist rev_Linklist(Linklist L)
{
	if(NULL==L||L->next==NULL)
	{
		return L;
	}
	Linklist p=L->next;
	int len=Len_linklist(L)-1;
	L->next=NULL;
	for(int i=0;i<len;i++)
	{
		Linklist t=p;
		p=p->next;
		t->next=L;
		L=t;
	}
	return L;
}
/*
 * function:    链表释放
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist free_space(Linklist L)
{
	if(NULL==L)
	{
		return L;
	}
	int len=Len_linklist(L);
	for(int i=0;i<len;i++)
	{
		L=Delete_head(L);
	}
	return L;
}
/*
 * function:    冒泡排序
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void Bubble(Linklist L)
{
	if(NULL==L||L->next==NULL)
	{
		printf("排序失败\n");
		return;
	}
	int len=Len_linklist(L);
	int i,j;
	Linklist p=L;
	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;
			}
		}
	}
}
//简单选择排序
void Simple(Linklist L)
{
	if(NULL==L||L->next==NULL)
	{
		printf("无法排序\n");
		return ;
	}
	int len=Len_linklist(L);
	Linklist p,q;
	int i,j;
	for(i=0,p=L;i<len-1;i++,p=p->next)
	{
		Linklist min=p;
		for(j=i+1,q=p->next;j<len;j++,q=q->next)
		{
			if(min->data<q->data)
			{
				min=q;
			}
		}
		if(min!=p)
		{
			int t=min->data;min->data=p->data;
			p->data=t;
		}
	}
}
奕书想睡觉了。
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python单向链表和双向链表原理与用法实例详解
09-20
主要介绍了Python单向链表和双向链表原理与用法,结合实例形式详细分析了单向链表与双向链表的概念、原理以及创建、添加、删除等相关操作技巧,需要的朋友可以参考下
C语言实现单向链表及操作
03-24
数据结构，c语言实现的单向链表。代码分享 struct LinkNode { int data; struct LinkNode *next; }; typedef struct LinkNode *Lnode;
7.19 单向循环链表 双向链表 双向循环链表
kawayi_nie的博客
07-19 34
简单选择排序（大→小）
7.19 单链表的补充和思维导图 以及部分单向循环链表和双链表
cecillq的博客
07-19 35
1.单向链表简单排序。2.单向链表按值插入。3.单向链表按值修改。
2019《王道数据结构》算法题-循环链表C++实现
qq_17713905的博客
09-27 333
#include&lt;iostream&gt; using namespace std; template&lt;class T&gt; struct Node{ T data; Node&lt;T&gt;* next; Node(Node&lt;T&gt;* n = NULL) { next = n; } Node(const T&amp; item , Node&l...
数据结构第五天（7.19）单向链表简单选择，按元素插入，按元素修改，循环单向链表，双向链表
yymbxqdm的博客
07-19 28
单向链表按元素插入和按元素修改。
7.19 两数相加 c++【中等】
Luca的博客
07-19 205
【题目描述】 给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。 如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。 您可以假设除了数字 0 之外，这两个数都不会以 0 开头。 示例： 输入：(2 -> 4 -> 3) + (5 -> 6 -> 4) 输出：7 -> 0 -> 8 原因：342 + 465 = 807 【思路】 这道题难度一般，主要是几个特殊情况用例容易疏
7.19学习笔记
qq_43499489的博客
07-20 78
* Collection集合 * 集合概念 是java提供的一种容易可以存放数据,和数组不同,数组的长度是不可变的,集合的数组是可变的 * 集合体系结构 collection list set ArrayList LinkedLIst HashSet TreeSet * 单列集合顶层父接口Collection的通用方法 add(E e);把指定对象添入集合...
【数据结构与算法】填空练习题
四口鲸鱼爱吃盐的博客
09-24 5643
数据结构与算法；线性结构、非线性结构；树状结构、图状结构；时间复杂度；线性表、栈、队列、串；二叉树；图；排序
java 学习7.19 Set HashSet LinkedHashSet TreeSet 集合练习
haha9417的博客
07-20 236
17.08_集合框架(Set集合概述及特点)(掌握) A:Set集合概述及特点: 通过API查看即可 //Set：元素唯一 // HashSet 底层数据结构是哈希表（数组+链表 JDK1.7 JDK1.8 数组+链表+二叉树） //HashSet 元素无序（存取顺序不一致），且唯一（元素不能重复） //哈希表像新华字典 B: 案例演示:...
每日一练(day12&PriorityQueue)
`or 1 or 不正经の泡泡
01-22 480
文章目录题目删除链表中的节点回文链表正常解法递归数据流的中位数PriorityQueue 队列 「这是我参与2022首次更文挑战的第4天，活动详情查看：2022首次更文挑战」 本博文优先在掘金社区发布！ 题目 每日一练由原来的>=5道题目改>=三道题目，没办法,>=五道题有点多。 第一道先来个简单的 删除链表中的节点 输入： head = [4,5,1,9], node = 5 输出： [4,1,9] 解释： 指定链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4
04.单向链表以及单向链表的应用.ppt
03-02
04.单向链表以及单向链表的应用.ppt
python单向链表的基本操作细节（小白入门）
12-21
今天是人生第一次写博客，记录自己学习的每一步，有些写...且链表的长度不是固定的，链表数据的这一特点使其可以非常的方便地实现节点的插入和删除操作 什么意思呢，我们在使用python列表的时候，如果我们需要删除列表
如何学习Golang语言!
FengyangCoder的博客
06-09 390
起源与设计哲学：Go语言由Robert Griesemer、Rob Pike和Ken Thompson三位Google工程师设计，旨在解决现代编程中的一些常见问题，如编译速度、运行效率和并发编程。主要特点：Go语言的语法简单、编译速度快、运行效率高，支持静态类型和内存安全，具有垃圾回收功能，并且原生支持并发编程。
扩展学习|风险管理的文献综述汇总（持续更新向）
最新发布
weixin_63253486的博客
06-10 774
本片博客主要介绍风险管理领域本人所看到的一些有意思的文章，并就风险管理领域的相关内容进行一个分享。
[ue5]建模场景学习笔记（5）——必修内容可交互的地形，交互沙（3）
qq_40128113的博客
06-09 289
5.第一想法直接clear掉，但直接clear会把想要保留的痕迹一并去除，跑起来就没有痕迹！所以不行，要做一个转载，先把痕迹保留在一个载体上，清楚原来痕迹，用sandsave表示，再把这个载体的痕迹保存回原来rt，这样之前的痕迹被清空了，只留下了保存在载体上的部分，正好符合我们想要的部分。我们现在已经能够让这片地形出现在任意地方，只要角色走在这片地形上，就能够产生痕迹，但这片区域总是需要人工指定，又无法把这片区域无限扩大（显存爆炸），因此尝试使角色无论走到哪里都能产生痕迹。否则绘制不到画板上。
React的表单学习
qq_36935391的博客
06-08 384
react的表单的双向绑定。
【Spine学习01】之基本操作
qq_44684452的博客
06-08 131
Spine简单讲就是做动画的，跟PS配合使用。
单向循环链表改为双向循环链表
09-23
将单向循环链表改为双向循环链表需要对每个节点增加一个前驱指针，使得每个节点既有指向下一个节点的指针，也有指向前一个节点的指针。 具体步骤如下： 1. 在原有单向循环链表的节点结构中增加一个prev指针，用于...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值