day3单链表

最新推荐文章于 2024-11-12 15:39:48 发布
最新推荐文章于 2024-11-12 15:39:48 发布
阅读量40 收藏 1
点赞数
文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47495369/article/details/129867256
版权
本文提供了一组C语言函数，用于实现链表的基本操作，包括创建头结点、创建节点、头插、尾插、遍历、头删、尾删、按位置插入、按位置删除、按元素查找、按元素删除、按位置修改和按元素更新。这些函数覆盖了链表操作的核心功能。
摘要由CSDN通过智能技术生成

test.c

#include "head.h"
/*
 * function:    创建头结点
 * @param [ in] 无参数
 * @param [out] 
 * @return      成功返回地址 失败返回NULL
 */
linklist create_head()
{
	//是头节点：len next
	//struct Node：是节点结构体类型
	linklist L=(linklist)malloc(sizeof(struct Node));
	if(L==NULL)
		return NULL;
	L->len=0;          //为单链表清零
	L->next=NULL;      //防止地址为野指针
}
/*
 * function:    创建节点
 * @param [ in] 
 * @param [out] 
 * @return      成功返回地址 失败返回NULL
 */
linklist create_node()
{
	linklist p=(linklist)malloc(sizeof(struct Node));
	if(p==NULL){
		return NULL;
	}
	p->data=0;
	p->next=NULL;
	return p;
}
/*
 * function:    头插
 * @param [ in] 链表 
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int insert_head(linklist L,datatype e)
{
	//判断头结点是否存在
	if(L=NULL)
		return -1;
	//插入 在头结点后面
	linklist p=create_node();
	if(p==NULL)
		return -1;
	//连接
	//p的数据域
	p->data=e;
	//P的指针域
	p->next=L->next;
	L->next=p;
	L->len++;
}
/*
 * function:    链表遍历
 * @param [ in] 头结点
 * @param [out] 
 * @return      无返回
 */
void output(linklist L)
{
	//判断头结点是否存在
	//判断链表是否为空
	if(L==NULL||L->len==0){
		printf("遍历失败\n");
		return ;
	}
	linklist p = L;
#if 0	
	int n=L->len;
	for(int i=0;i<n;i++)  //因为使用长度，所以头结点不能动
	{
		p=p->next;
		printf("%d\t",p-data);
	}
#else
	//遍历
	while(L->next!=NULL)//等价于 while(L->next)
	{
		L=L->next;
		printf("%d\t",L->data);
	}
#endif
	puts("");
}
/*
 * function:    尾插
 * @param [ in] 头结点 插入的值
 * @param [out] 
 * @return      成功返回0 失败-1
 */
int insert_rear(linklist L,datatype e)
{
	//判断头结点是否存在
	if(L==NULL){
		printf("插入失败\n");
		return -1;
	}
	//循环到最后一个节点
	linklist p=L;
	for(int i=0;i<L->len;i++)
	{
		p=p->next;
	}
	//在p节点后面插入
	linklist s=create_node();
	if(s==NULL)
		return -1;
	//s的数据域
	s->data=e;
	//连接
	p->next=s;
	L->len++;
}
/*
 * function:    头删
 * @param [ in] 头结点
 * @param [out] 
 * @return      成功返回0 失败返回-1
  */
int delete_head(linklist L)
{
	//判断头结点是否存在
	//判断链表是否为空 
	if(L==NULL||L->len==0){
		printf("删除失败");
		return -1;
	}
	//删除头节点的后继节点
		linklist q=L->next;
	L->next=q->next;
	free(q);
	q=NULL;
	L->len--;

}
/*
 * function:    尾删
 * @param [ in] 头结点
 * @param [out] 
 * @return      
 */
int delete_rear(linklist L)
{
	//判断头结点是否存在
	//判断链表是否为空
	if(L==NULL||L->len==0){
		printf("删除失败");
		return-1;
	}
	//循环移动到len-1位置
	linklist p=L;
	for(int i=0;i<L->len-1;i++){
		p=p->next;
	}
	free(p->next);
	p->next=NULL; //防止野指针
	L->len--;
}
/*
 * function:    按位置插入
 * @param [ in] 头节点  要插入的位置，插入的值
 * @param [out] 
 * @return      
 */
int insert_pos(linklist L, int pos,datatype e)
{
	if(L==NULL||pos<1,pos>L->len+1){
		printf("插入失败");
		return -1;
	}
	//找到pos-1.起名字；
	linklist p=L;
	for(int i=0;i<pos-1;i++){
		p=p->next;
	}
	//插入节点s；
	linklist s =create_node();
	if(s==NULL)
		return -1;
	//s的数据域
	s->data=e;
	//s的指针域
	s->next=p->next;
	p->next=s;
	L->len++;
	return 0;

}
/*
 * function:    按位置删除
 * @param [ in] 头结点  位置
 * @param [out] 
 * @return      
 */
int delete_pos(linklist L,int pos)
{
	if(L==NULL||L->len==0||pos<1||pos>L->len)
	{
		printf("删除失败");
		return -1;
	}
	linklist p=L;
	for(int i=0;i<pos-1;i++){
		p=p->next;
	}
	linklist q=p->next;
	p->next=q->next;
	free(q);
	q=NULL;
	L->len--;
}
/*
 * function:    
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int search_pos(linklist L,int pos)
{
	if(L==NULL||L->len==0||pos<1||pos>L->len){
		printf("查找失败");
		return -1;
	}
		linklist p=L;
		for(int i=0;i<pos;i++){
			p=p->next;
		}
		printf("查找的值%d\n",p->data);
}
/*
 * function:    按元素查找
 * @param [ in] 头结点 查找的值
 * @param [out] 
 * @return      
 */
int search_data(linklist L,datatype key)
{
	if(L==NULL||L->len==0){
		printf("按元素查找失败");
			return -1;
	}
	linklist p=L;
	int count=0;
	while(p->next!=NULL){
		p=p->next;
		count++;
		if(p->data==key){
			return count;
		}
	}
	return -1;
}
/*
 * function:    按元素删除
 * @param [ in] 头结点 删除的元素
 * @param [out] 
 * @return      
 */
int delete_data(linklist L,datatype key)
{
	int pos=search_data(L,key);
		if(pos==-1){
			printf("删除元素失败");
			return -1;
		}
	//根据元素位置删除
	delete_pos(L,pos);
	return 0;
}
/*
 * function:    按位置修改
 * @param [ in] 链表 位置 修改的值
 * @param [out] 
 * @return      
 */
int revise_pos(linklist L,int pos,datatype e)
{ 
	if(L==NULL||L->len==0||pos<1||pos>L->len){
		printf("修改失败\n");
		return -1;
	}
	linklist p=L;
	for(int i=0;i<pos;i++){
		p=p->next;
	}
	p->data=e;
	return 0;
}
int updata_data(linklist L,datatype key,datatype e)
{
		int temp=search_data(L,key);
		if(temp==-1){
			printf("失败");
			return -1;
		}
		revise_pos(L,temp,e);
		return 0;
}
void free_space(linklist L)
{

	for(int i=0;i<L->len;i++){
		delete_head(L);
	}
	free(L);
	L=NULL;
}

main.c

#include "head.h"

int main(int argc, const char *argv[])
{
	 linklist L=create_head();
#if 0
	 //循环头插：在头结点后面插入
		int n;
		datatype e;
		printf("请输入插入的个数")；
		scanf("%d",&n);
		for(int i=0;i<n;i++)
		{
			printf("请输入插入的值");
			scanf("%d",&e);
			insert_head(L,e);
		}
		output(L);
#else 
		//尾部插入：永远在尾部插入
		int n;
		datatype e;
		printf("请输入插入的个数");
		scanf("%d",&n);
		for(int i=0;i<n;i++){
			printf("请输入插入的值：");
			scanf("%d",&e);
			insert_rear(L,e);
		}
		output(L);
#endif
#if 0
		//头删
		delete_head(L);

		delete_head(L);
		output(L);

#else 
		//尾删
		//delete_rear(L);
		//delete_rear(L);
		output(L);
#endif
		//按位置插入
		int pos;
		printf("请输入要插入的位置：");
		scanf("%d",&pos);
		printf("请输入要插入的值：");
		scanf("%d",&e);
		insert_pos(L,pos,e);
		output(L);

		//按位置删除
		printf("请输入删除的位置：");
		scanf("%d",&pos);
		delete_pos(L,pos);
		output(L);

		//按元素查找
		datatype key;
		printf("请输入查找的值：");
		scanf("%d",&key);
		int flag=search_data(L,key);
	
		if(flag==-1){
			printf("查找的元素不存在\n");
		}else{
			printf("%d位置出现\n",flag);
		}
			
		//按元素删除
		printf("请输入删除的元素：");
		scanf("%d",&key);
		delete_data(L,key);
		output(L);

		printf("输入要修改值的位置：");
		scanf("%d",&pos);
		printf("输入修改的值：");
		scanf("%d",&e);
		revise_pos(L,pos,e);
		output(L);
		puts("");

		printf("请输入要修改的元素");
		scanf("%d",&key);
		printf("请输入要修改的值");
		scanf("%d",&e);
		updata_data(L,key,e);
		output(L);
		free_space(L);
	return 0;
}

head.h

#ifndef __HEAD_H__
#define __HEAD_H__
#include<string.h>
#include<stdio.h>
#include<stdlib.h>

typedef int datatype;
typedef struct Node
{
	//数据域
	union{
		int len;      //头结点的数据域：链表长度
		datatype data;  //其他节点的数据域：数据元素
	};
	//指针域
	struct Node *next;
}*linklist;

linklist create_head();
linklist create_node();
int insert_head(linklist L,datatype e);
void output(linklist L);
int insert_rear(linklist L,datatype e);
int delete_head(linklist L);
int delete_rear(linklist L);
int insert_pos(linklist L, int pos,datatype e);
int delete_pos(linklist L,int pos);
int search_pos(linklist L,int pos);
int search_data(linklist L,datatype key);
int delete_data(linklist L,datatype key);
int revise_pos(linklist L,int pos,datatype e);
int updata_data(linklist L,datatype key,datatype e);
void free_space(linklist L);

#endif

 

三只小鸹貔
关注
408_数据结构_单链表_Day7
weixin_45880844的博客
03-22 771
目录初始头插法新建链表尾插法新建链表增加在第i个位置插入新结点删除删除在第i个位置的结点查找根据序号查找数据值根据数据值查找序号 初始 头插法新建链表 LNode* 等价于 LinkList 都表示结构体指针，可以在下面的代码里替换。 #include<stdio.h> #include<stdlib.h> typedef int ElemType; typedef struct LNode{ ElemType data; struct LNode *next; }LNod
day7单链表
BTELL的博客
10-21 559
今天主要学习了部分单链表的知识点，包括其基本概念，定义，头节点，初始化，头插法。
DAY TWO 单链表
qq_64154426的博客
04-29 68
1.创建 typedef struct LinkNode{ char data; struct LinkNode *next; } LNode, *LinkList, *NodePtr; 2.初始化有头结点的链表 LinkList initLinkList(){ NodePtr tempHeader = (NodePtr)malloc(sizeof(LNode)); tempHeader->data = '\0'; tempHeader->next...
Day04单链表学习
hello_world_juns的博客
10-24 848
单链表使用
Day03单链表学习
发发的博客
12-30 545
单链表 一、链表介绍 链表是有序的列表，但是它在内存中是存储如下 小结: 1)链表是以节点的方式来存储,是链式存储 2)每个节点包含 data 域， next 域：指向下一个节点. 3)如图：发现链表的各个节点不一定是连续存储. 4)链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定 二、单链表 2.1、单链表介绍 单链表(带头结点) 逻辑结构示意图如下 2.2、单链表的应用实例 使用带head头的单向链表实现 –水浒英雄排行榜管理 1)完成对英雄人物的增删改查操作， 注: **删除和修改,查
day06 单链表相关操作
qq_31842777的博客
05-27 161
涉及： 链表创建、计算链表长度、遍历打印链表、插入、删除结点、链表反转、合并两个有序链表结果仍为有序链表、从尾到头打印链表。 直接上代码（含测试）： import java.util.Stack; /* *链表基本操作 *面试算法题 */ public class MyLinkedList { //定义头结点 public Node head; //定义结点类 publi...
数据结构day4单链表
qq_44707357的博客
06-13 119
Two Day 单链表
qq_60459642的博客
04-29 754
1）定义理解（自我乱说） 定义： 单向的连接的数据存储结构。 特点： 由多个节点通过指针连接而成；只有一个方向；（如图所示） 每个节点分为俩个部分，及数据域和指针域；（如图所示） 数据域：存储数据，比如放一个或多个整数类型，放一个或多个不同类型数据都行（这里代码演示只放一个int类型，为了方便）。 指针域：存放一个指针，用于指向下一个节点，我愿称它为单链表的脊髓。 地址存储特点：一个节点的数据域和指针域是存储在一个连续的空间上的，一个单链表的不同节点的空间是随机分配的，一般不是连..
day6 单链表的操作实现
m0_58066972的博客
03-21 83
功能：设两单链表A、B按data值（设为整型）递增有序，将表A和B合并成一表A，且表A也按data值递增有序。功能：设结点data域为整型，求链表中相邻两结点data值之和为最大的第一结点的指针。（2）若p->data ≤q->data则p结点进入结果表，否则q结点进入结果表。（2）求p->data+q->data为最大的那一组值，返回其相应的指针p即可。算法思路：依次取原链表中各结点，将其作为新链表首结点插入H结点之后，如下图。（1）设指针p、q分别指向表A和B中的结点，功能：将单链表H倒置。
单链表day06
小詹子的博客
07-24 302
根据 min 的位置（是否是头节点的下一个节点），相应地更新 minpre 或头节点的 link 指针，使其跳过 min 节点。①初始化指针：pre 指向头节点**（不存储数据）**，**p 指向第一个数据节点（存储数据）。**同时，minpre指向头节点（不存储数据） ， min 也初始化为指向第一个数据节点（存储数据）。当前记录的最小值 min，即【p->element < min->element】，更新 min 和 minpre 指向当前节点和它的前一个节点。三、完整的可执行代码。
数据结构-单链表的实现（删除和释放）day5（复杂操作的实现）day6
楚子航
04-08 3139
一、链表的删除 链表的删除：即实现DeleteLinklist(h, i)， 算法对应的链表结构如图所示。 算法思路：同插入法，先调用函数GetLinklist(h, i-1),找到结点ai的前驱，然后将结点ai删除之。 1.用q指向要被删除的节点，2.将被删除节点前方的箭头直接指向下一个节点。3.释放q指向节点的空间。 二、把整个链表释放 H指针往后走，p指针负责删除，H =NULL时结束。 三、代码 1.linklist.h: 2.linklist.c: 3....
数据结构（数据表之单链表）（Day4）
楚子航
04-06 1760
一、线性表的链式存储结构（什么是链表及其原理） 将线性表L=(a0,a1,……,an-1)中各元素分布在存储器的不同存储块，称为结点，通过地址或指针建立元素之间的联系 。 结点的data域存放数据元素ai，而next域是一个指针，指向ai的直接后继ai+1所在的结点。 举例： 结点类型描述： typedef struct node { data_t data; //结点的数据域// struct node *next; ...
m数据结构 day3 线性表List（二）静态链表（用一维数组实现的单链表，专为没有指针的语言设计）
wulimmya的博客
07-31 540
文章目录静态链表：用数组描述的链表（游标实现法）双向链表循环链表 静态链表：用数组描述的链表（游标实现法） 双向链表 循环链表
单链表-----带头结点的单链表
dayday_upyy
08-11 1114
线性表 优点：无需为表中元素之间逻辑关系而增加额外的存储空间；可以快速的存储表中任意位置的元素。 缺点：插入和删除需要移动大量数据；（因为相邻两元素的存储位置也具有邻居关系，它们在内存中的位置也是挨着的，中间没有空隙 ，当然就无法快速地介入，而删除后中间留有空隙，自然需要弥补）   解决这一缺陷思路： 所有元素不考虑相邻位置，哪里有空位就在哪里，而只是让每个元素知道它下一个元素的位置在...
C 语言冒泡排序算法详解
licy__的博客
11-09 338
冒泡排序是一种简单的排序算法，它通过重复地遍历要排序的列表，比较相邻的元素并根据需要交换它们的位置来实现排序。尽管冒泡排序的时间复杂度较高（O(n²)），但它因其简单易懂而常用于教学目的。本文将详细介绍冒泡排序的工作原理，并提供一个用 C 语言实现的示例。冒泡排序的基本思想是通过多次遍历待排序的列表，每次遍历时比较相邻的两个元素，如果前一个元素大于后一个元素，则交换它们的位置。这样，每遍历一次，最大的元素就会像气泡一样“浮”到列表的末尾。这个过程会重复进行，直到整个列表变得有序。
C++研发笔记12——C语言程序设计初阶学习笔记10
Lbs_gemini0603的博客
11-09 590
C++研发笔记12——C语言程序设计初阶学习笔记10
数据结构（1）
m0_71616132的博客
11-09 653
数据结构
C语言第十一周课——函数的调用
最新发布
qq_58156721的博客
11-12 144
学习函数的调用:通过调用函数来实现二分法。通过调用函数来实现冒泡法。
数据结构合并两个有序链表
weixin_60489641的博客
11-09 248
循环条件为list1与list2均不为null，开始比较list1和list2中的大小，如果是最小值将其放入nextHead的数组中，然后list1走到下一个节点继续与list2匹配，每次都将最小值或相等值放入合并的链表中。这里我们可以创建一个新的对象作为合并后的新链表newHead，而NewHead.next就是我们要返回的头部的位置。在创建一个对象来获取nextHead.next下一个节点来作为我们新链表的起始位置防止我们的头部位置找不到。然后将list2的目标节点放入nextHead.next中。
黑马瑞吉优化Day3
09-24
黑马瑞吉优化Day3是指在数据库中使用一个元数据处理器来填充公共字段，以及创建一个线程局部变量工具类来设置和获取当前用户ID，从而实现验证用户是否登录的功能。元数据处理器是一个类，通过实现MyBatis Plus框架中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值