Day4-数据结构-链表

已于 2023-07-18 19:49:45 修改
阅读量43 收藏
点赞数
分类专栏： 转世重生 文章标签： 数据结构 链表 算法
于 2023-07-18 19:33:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ck0056/article/details/131794604
版权

1.单链表任意位置修改

2.单链表任意位置查找

3.单链表排序

head.h文件

#ifndef __HEAD_H__
#define __HEAD_H__
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
typedef int datatype;
typedef struct Node
{
	datatype data;
	struct Node *next;
}*Linklist;

Linklist bull(Linklist l);   //排序
int find_data(int n,Linklist l);  //任意位置查找
Linklist amend_data(int n,Linklist l);  //任意位置修改
Linklist insert_data(int n,Linklist l,int e);  //按位置插入
int Linklist_len(Linklist l);  //计算链表元素个数
Linklist delete_real(Linklist l);  //尾删
Linklist insert_end(int e,Linklist l);  //尾插1.0
Linklist delete_head(Linklist l);  //头删
Linklist creat_node();  //申请节点空间
Linklist insert_head(datatype e,Linklist l);  //头插
int ouputs(Linklist l);  //输出
Linklist insert_tail(datatype e,Linklist rear);  //尾插
#endif

test.c文件

#include "head.h"
Linklist creat_node()  //申请节点空间
{
	Linklist node=(Linklist)malloc(sizeof(struct Node));
	if(NULL==node)
		return NULL;
	node->data=0;
	node->next=NULL;
	return node;
}
Linklist insert_head(datatype e,Linklist l)  //头插
{
	Linklist node=creat_node();
	if(NULL==node)
		return NULL;
	node->data=e;
	node->next=l;
	l=node;
	return l;
}
int  ouputs(Linklist l)  //输出
{
	if(NULL==l)
	{
		return -1;
	}
	while(l!=NULL)
	{
		printf("%d ",l->data);
		l=l->next;
	}
	printf("\n");
}
Linklist insert_tail(datatype e,Linklist rear)  //尾插
{
	Linklist s=creat_node();
	if(NULL==s)
		return NULL;
	s->data=e;
	if(rear!=NULL)
		rear->next=s;
	rear=s;
	return rear;

}
Linklist insert_end(int e,Linklist l)  //尾插1.0
{
	Linklist s=creat_node();
	s->data=e;
	if(l==NULL)
	{
		l=s;
	}
	else
	{
		Linklist end=l;
		while(end->next!=NULL)
		{
			end=end->next;
		}
		end->next=s;
	}
	return l;
}
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;
}
Linklist delete_real(Linklist l)  //尾删
{
	if(NULL==l)
		return NULL;
	else if(l->next==NULL)
	{
		free(l);
		l=NULL;
	}
	else
	{
		Linklist p=l;
		while(p->next->next!=NULL)
		{
			p=p->next;
		}
		free(p->next);
		p->next=NULL;
	}
	return l;
}
int Linklist_len(Linklist l)  //计算链表元素个数
{
	int count=0;
	while(l!=NULL)
	{
		l=l->next;
		count++;
	}
	return count;
}
Linklist insert_data(int n,Linklist l,int e)  //按位置插入
{
	//１.判断链表是否为空
	//２.判断位置是否合法
	int len=Linklist_len(l);
	if(NULL==l||n<1||n>len+1)
	{
		puts("insert error\n");
		exit(-1);
	}
	Linklist p=l;
	if(n==len+1)
	{
		insert_end(e,l);
		return l;
	}
	else
	{
		for(int i=1;i<n;i++)
		{
			p=p->next;
		}
		Linklist s=creat_node();
		s->next=p->next;
		p->next=s;
		s->data=p->data;
		p->data=e;
		return l;
	}
}
Linklist amend_data(int n,Linklist l)  //任意位置修改
{
	int len=Linklist_len(l);
	if(NULL==l||n<1||n>len)
	{
		printf("insert error\n");	
		exit(-1);
	}
	int i;
	Linklist p=l;
	for(i=1;i<n;i++)
	{
		p=p->next;
	}
	printf("please enter the modified data:");
	int e;
	scanf("%d",&e);
	p->data=e;
	return l;
}
int find_data(int n,Linklist l)  //任意位置查找
{
	int len=Linklist_len(l);
	if(NULL==l||n<1||n>len)
	{
		printf("insert error\n");	
		 exit(-1);
	}
	int i;
	Linklist p=l;
	for(i=1;i<n;i++)
	{
		p=p->next;
	}
	return p->data;
}
Linklist bull(Linklist l)   //排序
{
	int len=Linklist_len(l);
	int arr[len];
	int i,j,t;
	Linklist p=l;
	Linklist q=l;
	for(i=0;i<len;i++)
	{
		arr[i]=p->data;
		p=p->next;
	}
	for(i=1;i<len;i++)
	{
		for(j=0;j<len-i;j++)
		{
			if(arr[j]>arr[j+1])
			{
				t=arr[j];arr[j]=arr[j+1];arr[j+1]=t;
			}
		}
	}
	for(i=0;i<len;i++)
	{
		q->data=arr[i];
		q=q->next;
	}
	return l;
}

main.c文件

#include "head.h"
int main(int argc, const char *argv[])
{
	Linklist l=NULL;
	int n;
	datatype e;
	printf("please enter n:");
	scanf("%d",&n);
	/*for(int i=0;i<n;i++)
	{
		//头插
		printf("please enter elemen:");
		scanf("%d",&e);
		l=insert_head(e,l);
	}*/
	for(int i=0;i<n;i++)
	{
		//尾插
		printf("please enter elemen:");
		scanf("%d",&e);
		l=insert_end(e,l);
	}
//	delete_head(l);
//	l=delete_real(l);
//	l=insert_data(l);
/*	ouputs(l);
	printf("请输入要插入的位置：");
	int n1;
	scanf("%d",&n1);
	printf("please enter elemen:");
	scanf("%d",&e);
	l=insert_data(n1,l,e);
	ouputs(l);
	ouputs(l);
	printf("请输入要修改的位置：");
	int n1;
	scanf("%d",&n1);
	l=amend_data(n1,l);
	ouputs(l);*/
	ouputs(l);
//	printf("请输入要查找的位置：");
//	int n1;
//	scanf("%d",&n1);
//	printf("%d\n",find_data(n1,l));
	l=bull(l);
	ouputs(l);
	return 0;
}

一、链表

顺序表存在满，适用于数据量较小的情况，顺序表不方便插入和删除操作，那么引出链表。链表不需要预估存储空间，动态分配空间。

1.概念

1.1 链表：线性的链式存储，称为链表

1.2 链表的逻辑结构：线性结构【一对一】

1.3 链式的存储结构：链式存储【逻辑相邻，物理不一定相邻】

1.4 链表分类：单向链表、单向循环链表、双向链表、双向循环链表

 

1.5 节点

节点：数据域、指针域

 1.6 头节点和头指针

 1.7 节点的结构体定义

 1.8 插入和删除

 

2.单链表的操作

2.1 单链表创建

/*
 * function:    创建一个节点
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist create_node()
{
Linklist node=(Linklist)malloc(sizeof(struct Node));
    if(NULL==node)
    return NULL;
node->data=0;
node->next=NULL;
    return node;//0x10
}

2.2 单链表头插

 

/*
 * function:    头插
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
Linklist insert_head(datatype e,Linklist L)
{
    //在堆区创建一个节点
Linklist node=create_node();
node->data=e;
node->next=L;
    L=node;
    return L;
}

2.3 单链表尾插

 

 

/*
 * function:    尾插
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist insert_rear(datatype e,Linklist L)
{
    //创建一个新节点
Linklist s=create_node();
s->data=e;
    if(L==NULL)
    {
    L=s;
    }
    else
    {
    //rear指向最后一个节点的地址
    Linklist rear=L;
    while(rear->next!=NULL)
    {
        rear=rear->next;
    }
    rear->next=s;
    }
    return L;
}

2.4 单链表头删

 

/*
 * 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;


}

2.5 单链表尾删

/*
 * function:    尾部删除
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist delete_rear(Linklist L)
{
    //1,判断链表是否为空
    if(NULL==L)
    {
    return NULL;
    }
    //2,判断如果链表只有一个节点
    else if(L->next==NULL)
    {
    free(L);
    L=NULL;
    }
    else
    {
    //3,有多个节点
    //循环倒数第二个节点
    Linklist second=L;
    while(second->next->next!=NULL)
    {
        second=second->next;
    }
    free(second->next);
    second->next=NULL;
    }
    return L;
}

 2.6 单链表遍历

/*
 * function:    循环遍历
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int output(Linklist L)
{
    //判断是否创建
    //判断是否为空
    if(NULL==L )
    {
    return -1;
    }
    while(L!=NULL)
    {
    printf("%d\t",L->data);
    L=L->next;
    }
    puts("");
}

2.7 单链表任意位置插入

int Len_linklist(Linklist L)
{
    int count=0;
    while(L!=NULL)
    {
    count++;
    L=L->next;
    }
    return count;
}
/*
 * function:    按位置插入
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist insert_by_pos(int pos,datatype e,Linklist L)
{
    //1,判断链表是否为空
    //2，判断位置是否合法
    int len;
    if(NULL==L || pos<1 || pos>(len=Len_linklist(L))+1)
    {
    puts("insert arror");
    return L;
    }
    
    //3,插入
Linklist p=L;
    if(pos==len+1)
    {
    insert_rear(e,L);
    return L;
    }
    
    for(int i=1;i<pos;i++)
    {
    p=p->next;
    }
    
    
    //在p节点后面插入新节点s
Linklist s=create_node();
s->next=p->next;
p->next=s;
s->data=p->data;
p->data=e;
    
    
    return L;
}

 

2.8 单链表任意位置删除

2.9 单链表任意位置修改

参数：查找的位置、链表

思路：

判断链表是否为空

判断位置是否合法

循环找到当前pos位置，

直接重新赋值该节点的数据域

2.10 单链表任意位置查找

参数：查找的位置、链表

思路：

判断链表是否为空

判断位置是否合法

循环找到当前pos位置，

直接输出该节点的数据元素

2.11 单链表任意元素插入

2.12 单链表任意元素删除

2.13 单链表任意元素修改

2.14 单链表任意元素查找

2.15 单链表逆置

2.17 单链表排序

2.18 单链表释放

ck钉钉钉
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构第二部分学习（双链表）
06-08
双链表的增删改查操作，最后添加了一个顺序添加的功能。请之后去掌握构建链表结构。
数据结构的学习:代码分析
06-07
第四问：不考虑编号顺序的链表
数据结构day4-链表
m0_54896893的博客
12-22 40
6.单向链表查找倒数第n个节点。2.单向链表任意元素查找。3.单向链表任意元素修改。4.单向链表任意元素删除。8.单向链表释放内存。
数据结构-C语言代码 day 4-静态链表
yydslty的博客
05-03 1029
一、静态链表定义 逻辑结构上相邻的数据元素，存储在指定的一块内存空间中，数据元素只允许在这块内存空间中随机存放，这样的存储结构生成的链表称为静态链表。也就是说静态链表是用数组来实现链式存储结构，目的是方便在不设指针类型的高级程序设计语言中使用链式结构。它的优点是和动态链表一样，删除和插入元素时间复杂度低；不足是和数组一样，需要提前分配一块较大的空间。 数据存放到数组中时，给各个数据元素配备一个整形变量，此变量用于指明各个元素的直接后继元素所在数组中的位置下标： 上图中，从 a[1] 存储.
代码随想录Day4--链表part02
B7_0729的博客
01-28 923
随着进度推进，感觉题目也越来越难了。今天的任务更重要，继续升级！
数据结构 day4 链表
weixin_55070858的博客
03-15 396
1：2:3:4:5:
数据结构-C语言代码 day 3-双向链表
yydslty的博客
05-03 1364
1.双向链表的定义 上一节学习了单链表。今天学习双链表。 单向链表特点：   1.我们可以轻松的到达下一个节点, 但是回到前一个节点是很难的.   2.只能从头遍历到尾或者从尾遍历到头(一般从头到尾) 双向链表特点   1.每次在插入或删除某个节点时, 需要处理四个节点的引用, 而不是两个. 实现起来要困难一些   2.相对于单向链表, 必然占用内存空间更大一些.   3.既可以从头遍历到尾, 又可以从尾遍历到头 双向链表的定义:   双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指
day03-链表part1
younglg的博客
05-27 163
想法：添加节点是在给定下标节点的前面插入，所以要用到下标节点的前一个节点指针，删除给定下标节点也要用到前一个节点指针，所以可以用虚拟头节点。示例 1： 输入：head = [1,2,6,3,4,5,6], val = 6 输出：[1,2,3,4,5]想法：虚拟头节点，遍历链表时，先拿出一个变量来存遍历起始指针，然后用这个变量进行遍历，注意找好遍历条件。示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL。题意：删除链表中等于给定值 val 的所有节点。
day04-链表part2
younglg的博客
05-30 204
想法：虚拟节点，链表的增删改都可以用到虚拟节点，2个节点相互交换，需要借助前面一个节点来操作，找到遍历条件，通过画图确定交换逻辑。你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。
求职 leetcode 刷题 day4 --- 链表
qq_44486787的博客
05-26 488
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。给定一个链表的头节点 head ，返回链表开始入环的第一个节点。如果链表无环，则返回 null。给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
数据结构 day4+day5 链表
2203_75782206的博客
12-25 608
链表
57春节7天练---Day-1：数组和链表 数组和链表.pdf
04-18
57春节7天练---Day-1：数组和链表 数组和链表.pdf
day8035.rar_数据结构_Visual_C++_
08-12
这是用C++写的关于链表的创建
鸿蒙轻内核A核源码分析系列二 数据结构-位图操作
maniuT的博客
06-11 1040
位操作模块提供对32位无符号整数数值的bit位进行操作，bit位取值为0-31，以0开始计算，从左向右，第0位，第1位。。。第31位等。⑴处定义的宏如下，也就是十进制31。如果传入的比特位pos大于31，会通过逻辑与运算截断，只取低5位，确保不会大于31，避免溢出。⑵处定义的位图掩码全是1。在文件中定义了常用的位操作相关的宏。宏根据参数x计算出需要操作第几个状态字，由于计算状态字的使用的是UINTPTR，状态字可以是32位、也可以是64位。后文，我们默认以32位进行讲解。宏传入的参数是位操作的开始bit。
数据结构--第七章--树和二叉树
2302_80052051的博客
06-11 315
前序+中序可以确定一个二叉树；中序+后序可以确定一个二叉树。，将数据元素组织成层次结构，元素间属于。二叉树的定义是递归定义。
数据结构--线性表和串
code袁的博客
06-08 815
🦁作者简介：一名喜欢分享和记录学习的在校大学生💥个人主页code袁💥个人QQ🐯个人wechat：code8896线性表是一种常见的数据结构，它是具有相同数据类型的有限序列。线性表中的元素之间存在一种顺序关系，可以通过元素在表中的位置来访问和操作。串是由零个或多个字符组成的有限序列，也可以理解为字符串。串是计算机科学中最基本的数据类型之一，常用于表示文本信息。手动码字，如有错误，欢迎在评论区指正💬~你的支持就是我更新的最大动力💪~
数据结构 -- 树状数组
gghhb12的博客
06-09 1254
树状数组或二叉索引树（Binary Indexed Tree），又以其发明者命名为 Fenwick 树。其初衷是解决数据压缩里的累积频率的计算问题，现多用于高效计算数列的前缀和、区间和。它可以以 O(logn) 的时间得到任意前缀和。并同时支持在 O(logn) 时间内支持动态单点值的修改。空间复杂度 O(n)。具体区别和联系如下：1.两者在复杂度上同级, 但是树状数组的常数明显优于线段树, 其编程复杂度也远小于线段树.
【算法与数据结构】【数组篇】【题6-题10】
最新发布
handsomethefirst的博客
06-11 1169
首先，是一个递增排序，那么我们可以知道头尾相加，判断最大值和最小值的和是否等于目标值，如果大于目标值，则说明我们值找大了，那就要找到次第二最大值，作为新区间的最大值，然后继续判断是否等于目标值。当为偶数的时候，如果x+y=i，i的值小于最大的行数，代表坐标x从i开始，y从0开始，如果i大于等于最大的行数，代表坐标x从m开始，y=i-m开始。当为奇数的时候，如果x+y=i，i的值小于最大的列数，代表坐标y从i开始，x从0开始, 如果i大于等于最大的列数，代表坐标y从n开始，x=i-n开始。
数据结构----单向链表
03-27
单向链表是一种常见的数据结构，它由一系列节点组成，每个节点包含两部分：数据和指向下一个节点的指针。每个节点只知道下一个节点的位置，而不知道前一个节点的位置。 单向链表的特点是插入和删除操作的效率较高，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ck钉钉钉

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值