【C语言】单链表(二)

最新推荐文章于 2023-08-16 17:51:34 发布
最新推荐文章于 2023-08-16 17:51:34 发布
阅读量141 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 链表 c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_47329175/article/details/117827346
版权

前言

前面我们已经实现了链表的创建、插入（头插法）、删除、打印功能，下面我们来实现，查找和指定位置插入

5、指定位置插入

5.1前驱插入

//指定位置的前面插入，和按值删除类似
void Inster_PostionPrecursor_List(Lnode* Head_Node,Node_Data posdata,Node_Data data)
{
    Lnode* posNode = Head_Node->next;
    Lnode* posNodeFront = Head_Node;
    Lnode* New_Node = Create_New_Node(data);
    if(posNode == NULL || New_Node == NULL)
    {
        printf("插入失败，此链表为空\n");
        return ;
    }
    else
    {
        while(posNode->data != posdata)
        {
            posNodeFront = posNode;
            posNode = posNode->next;
            if(posNode == NULL)
            {
                printf("插入失败\n");
                return ;
            }
        }
        New_Node->next = posNode;
        posNodeFront->next = New_Node;
       // printf("插入成功\n");
    }
}

posNode为指定的位置节点，posNodeFront为指定位置节点的前驱，New_Node为待插入节点。
while(posNode->data != posdata)遍历链表，直到找到posdata所在的节点，确保遍历过程中posNode与posNodeFront一前一后( posNodeFront = posNode; posNode = posNode->next;)，当不满足循环条件时，表示此时posNode节点是我们想找到的节点，接下来插入节点New_Node

在这里插入图片描述

谨记插入过程中，一和二的顺序别写反了
①、New_Node->next = posNode;
②、posNodeFront->next = New_Node;

5.2后继插入

void Inster_PostionRear_List(Lnode* Head_Node,Node_Data posdata,Node_Data data)
{
	Lnode* posNode = Head_Node->next;
    Lnode* New_Node = Create_New_Node(data);

	if(posNode == NULL)
	{
		printf("此链表为空，插入失败\n");
		return ;
	}
	else
	{
		while(posNode->data != posdata)
		{
			posNode = posNode->next;
			if(posNode == NULL)
			{
				printf("插入失败\n");
				return ;
			}
		}
		New_Node->next = posNode->next;
		posNode->next = New_Node;
	}
	
}

和前驱插入类似。
在这里插入图片描述

①、New_Node->next = posNode->next;
②、posNode->next = New_Node;

6、查找

6.1查找某个值

//查找链表中的某个值 
void Find_CertainValue_List(Lnode* Head_Node,Node_Data value)
{
	Lnode* pMove = Head_Node->next;

	if(pMove == NULL)
	{
		printf("查找失败，链表为空\n");
		return ;
	}
	else
	{
		//遍历整个链表
		while(pMove->data !=  value)
		{
			pMove = pMove->next;
			//遍历结束还未找到
			if(pMove == NULL)
			{
				printf("查找失败，不存在该值\n");
				return ;
			}
		}
		//跳出while表示查找成功
		printf("查找成功\n");
		return ;
	}
}

此查找方法为直接查找，定义指针pMove遍历整个链表

6.2查找某个链表的倒数第n个值

给定一个链表，不知道链表长度，查找此链表倒数第n个值 (前提是链表长度大于n)

//不知道链表长度的情况下(链表长度大于n)，查找倒数第n个值
Node_Data Find_Value_List(Lnode* Head_Node,int n)
{
    Lnode* posNode = Head_Node->next;
    Lnode* posNode_Behind_n = Head_Node->next;
    while(n--)
    {
        posNode_Behind_n = posNode_Behind_n->next;
    }
    
    if(posNode == NULL)
    {
        //printf("此链表为空，查找失败\n");
        return -1;
	}
    else
    {
        while(posNode_Behind_n != NULL)
        {
            posNode = posNode->next;
            posNode_Behind_n = posNode_Behind_n->next;
        }
        return posNode->data;
    }
    
}

思路如下:
定义两个指针posNode_Behind_n和posNode，二者相隔n个位置，当posNode_Behind_n为NULL时，此时posNode所指向的节点就是链表的倒数第n个节点。

7、全部代码测试如下

#include<stdio.h>
#include<malloc.h>

typedef int Node_Data;

typedef struct node{
    Node_Data data;
    struct node* next;
}Lnode;

//创建链表头节点,返回值为struct node*
Lnode* Create_Head_Node()
{
    //动态内存申请
    Lnode* Head_Node = (Lnode *)malloc(sizeof(Lnode));
    if(Head_Node == NULL)
    	return NULL;
    else
    {
	    //初始化头节点
	   // Head_Node->data = 1;  //这个可以随意赋值
	   Head_Node->next = NULL;
	   return Head_Node;
    }
}

//创建新的节点，并给此节点赋值
Lnode* Create_New_Node(Node_Data data)
{
    Lnode* New_Node = (Lnode *)malloc(sizeof(Lnode));
    
    if(New_Node == NULL)
    	return NULL;
    else
    {
	    New_Node->data = data;
	    New_Node->next = NULL;
	    
	    return New_Node;
    }
}

//打印链表
void Printf_List(Lnode* Head_Node)
{
    Lnode* pMove = Head_Node->next;
    
    if(pMove == NULL)
    {
        printf("此链表为空，打印失败\n");
        return ;
    }
    else
    {
        while(pMove != NULL)
        {
            printf("%d->",pMove->data);
            pMove = pMove->next;
        }
        printf("NULL\n");
    }
}

//头插法插入数据
void Insert_Data_List(Lnode* Head_Node,Node_Data data)
{
    Lnode* New_Node = Create_New_Node(data);
    
    if(New_Node == NULL)
    {
        printf("插入失败\n");
        return ;
    }
    else
    {
        New_Node->next = Head_Node->next;
        Head_Node->next = New_Node;
        //printf("插入成功\n");
        return ;
    }
}

//按值删除
void Delete_AccordValue_List(Lnode* Head_Node,Node_Data posdata)
{
    Lnode* posNode = Head_Node->next;
    Lnode* posNodeFornt = Head_Node;
    
    if(posNode == NULL)
    {
        printf("此链表为空，删除失败\n");
        return ;
    }
    else
    {
        while(posNode->data != posdata)
        {
            posNodeFornt = posNode;
            posNode = posNode->next;
            if(posNode == NULL)
            {
                printf("删除失败，不存在该值\n");
                return ;
            }
        }
        posNodeFornt->next = posNode->next;
        free(posNode);
        printf("删除成功\n");
    }
}

//指定位置的前面插入，和按值删除类似
void Inster_PostionPrecursor_List(Lnode* Head_Node,Node_Data posdata,Node_Data data)
{
    Lnode* posNode = Head_Node->next;
    Lnode* posNodeFront = Head_Node;
    Lnode* New_Node = Create_New_Node(data);
    if(posNode == NULL || New_Node == NULL)
    {
        printf("插入失败，此链表为空\n");
        return ;
    }
    else
    {
        while(posNode->data != posdata)
        {
            posNodeFront = posNode;
            posNode = posNode->next;
            if(posNode == NULL)
            {
                printf("插入失败\n");
                return ;
            }
        }
        New_Node->next = posNode;
        posNodeFront->next = New_Node;
       // printf("插入成功\n");
    }
}

void Inster_PostionRear_List(Lnode* Head_Node,Node_Data posdata,Node_Data data)
{
	Lnode* posNode = Head_Node->next;
    Lnode* New_Node = Create_New_Node(data);

	if(posNode == NULL)
	{
		printf("此链表为空，插入失败\n");
		return ;
	}
	else
	{
		while(posNode->data != posdata)
		{
			posNode = posNode->next;
			if(posNode == NULL)
			{
				printf("插入失败\n");
				return ;
			}
		}
		New_Node->next = posNode->next;
		posNode->next = New_Node;
	}
	
}

//查找链表中的某个值 
void Find_CertainValue_List(Lnode* Head_Node,Node_Data value)
{
	Lnode* pMove = Head_Node->next;

	if(pMove == NULL)
	{
		printf("查找失败，链表为空\n");
		return ;
	}
	else
	{
		while(pMove->data !=  value)
		{
			pMove = pMove->next;
			if(pMove == NULL)
			{
				printf("查找失败，不存在该值\n");
				return ;
			}
		}
		printf("查找成功\n");
		return ;
	}
}

//不知道链表长度的情况下(链表长度大于n)，查找倒数第n个值
Node_Data Find_List(Lnode* Head_Node,int n)
{
    Lnode* posNode = Head_Node->next;
    Lnode* posNode_Black_n = Head_Node->next;
    while(n--)
    {
        posNode_Black_n = posNode_Black_n->next;
    }
    
    if(posNode == NULL)
    {
        //printf("此链表为空，查找失败\n");
        return -1;
	}
    else
    {
        while(posNode_Black_n != NULL)
        {
            posNode = posNode->next;
            posNode_Black_n = posNode_Black_n->next;
        }
        return posNode->data;
    }
    
}


int main()
{
    Lnode* Head_Node = Create_Head_Node();
    
    Insert_Data_List(Head_Node,1);
    Insert_Data_List(Head_Node,2);
    Insert_Data_List(Head_Node,3);
    Insert_Data_List(Head_Node,4);
    Insert_Data_List(Head_Node,5);
    Insert_Data_List(Head_Node,6);
    Insert_Data_List(Head_Node,7);
	printf("链表内容如下：");
	Printf_List(Head_Node);
	
	printf("\n删除链表中的5：");
    Delete_AccordValue_List(Head_Node,5);
	printf("删除之后，内容如下：");
	Printf_List(Head_Node);

	printf("\n在4的前面插入77：");
	Inster_PostionRear_List(Head_Node,4,77);
	printf("插入数据后，内容如下：");
	Printf_List(Head_Node);

	printf("\n在6的后面插入88：");
	Inster_PostionPrecursor_List(Head_Node,6,88);
	printf("插入数据后，内容如下：");
	Printf_List(Head_Node);

	printf("\n查找链表中的77：");
    Find_CertainValue_List(Head_Node,1);

	printf("\n查找链表中倒数第3个值：");
    printf("%d\n",Find_List(Head_Node,3));

	printf("\n测试结束!!!!\n");
    return 0;
}

运行结果如下：
在这里插入图片描述

END

到这里链表的基本操作已经实现了，下一节我会写一个学生管理系统

点灯大师～
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
剑指Offer(Python多种思路实现):链表中倒数第k个节点
01-20
剑指Offer(Python多种思路实现):链表中倒数第k个节点 面试22题： 题目：链表中倒数第k个节点 题：输入一个链表，输出该链表中倒数第k个结点。 解题思路一：为了实现只遍历链表一次就能找到倒数第k个节点，我们可以定义两个指针。让第一个指针先向前走k-1步，第二个指针保持不动；从第k步开始，第二个指针也开始从链表的头指针开始遍历。由于两个指针的距离保持在k-1,当第一个指针到达链表的尾节点时，第二个指针刚好到达倒数第k个节点。 class Solution: def FindKthToTail(self, head, k): # write code here
21. 合并两个有序链表
01-20
题目 将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例： 输入：1->2->4, 1->3->4 输出：1->1->2->3->4->4 解题思路 解法一：迭代法 复杂度分析： 时间复杂度：O(n + m) ，其中 n 和 m 分别为两个链表的长度。因为每次循环迭代中，l1 和 l2 只有一个元素会被放进合并链表中， 因此 while 循环的次数不会超过两个链表的长度之和。所有其他操作的时间复杂度都是常数级别的，因此总的时间复杂度为 O(n+m)。 空间复杂度：O(1) 。我们只需要常数的空间存放若干变量。 注：关于合并若干有序链表的详细解法
整数链表
07-11
1、先建立一个类。 2、在类的前边建立一个结构体。 3、在类中定义一个函数，实现链表的创建，节点的删除和插入。
java实现链表
09-24
链表是一种物理存储单元上非连续、非顺序的存储结构。 java代码实现单链表，插入，删除和遍历等功能。 链表能够灵活的进行插入和删除操作，时间复杂度为O（1）,链表的查找时间复杂度为O（n）。
C语言中关于链表
03-13
C语言中关于链表的总结内容，内附代码例题，详细的有条理的讲解链表内容
c语言单链表二路归并排序,二路归并排序（C语言实现）
weixin_34609222的博客
05-22 745
#include "stdio.h"#define MAXSIZE 50typedef int RcdType;void Merge(RcdType SR[],RcdType (&TR)[MAXSIZE],int i,int m,int n){int j,k;for(j=m+1,k=i;i<=m&&j<=n;++k)if (SR[i]{TR[k]=SR[i++]...
C语言单链表
knighthood2001
05-06 1127
int data;} Node;这里我们使用typedef将struct Node命名为Node。当然很多书以及代码中会使用到如下的int data;这里它还定义了一个指向这个结点的指针，当然对于初学者（笔者也是初学者）来说。使用*LinkList后，不太好理解，这里笔者就使用上述Node的版本。
c语言单链表基本操作
qq_59328991的博客
08-16 559
单链表基本操作
c语言单链表的逆置
weixin_50626842的博客
10-08 2466
单链表的逆置 方法一：头插 void Reverse(Node* plist) { assert(plist != NULL&&plist->next!=NULL); Node* p = plist->next; Node* q; plist->next = NULL; while (p != NULL) { q = p->next; p->next = plist->next; plist->next = p; p
C语言 单链表的反转
热门推荐
Genven_Liang的博客
05-18 2万+
C语言 单链表的反转 一、简述 记--简单的将单链表的数据顺序进行反转。如将原来的顺序1 2 3 4 5 6 7 反转为：7 6 5 4 3 2 1 二、方式1：头插法 2.1 头插法1--类似新建链表 2.1.1 思路：断开链表头，然后以头插法的方式将原链表的数据添加链表。 2.1.2 测.........
C语言实现静态链表
08-18
主要为大家详细介绍了C语言实现静态链表，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
单向循环链表
01-20
循环链表 循环链表是一种特殊的单链表。实际上，循环链表也很简单。它跟单链表唯一的区别就在尾结点。我们知道，单链表的尾结点指针指向空地址，表示这就是最后的结点了。而循环链表的尾结点指针是指向链表的头结点。从我画的循环链表图中，你应该可以看出来，它像一个环一样首尾相连，所以叫作“循环”链表。 操作 is_empty() 判断链表是否为空 length() 返回链表的长度 travel() 遍历 add(item) 在头部添加一个节点 append(item) 在尾部添加一个节点 insert(pos, item) 在指定位置pos添加节点 remove(item) 删除一个节点 search(i
LeetCode-[链表]-翻转链表
01-07
1. 双指针迭代翻转链表 翻转链表和交换两个变量的操作大同小异。 首先需要一个prev指针（指着当前节点的前一个节点），一个cur指针（指着当前节点） 翻转链表需要注意的一点是：链表之间靠指针连接，如果贸然将某个节点的next指向其他节点，就有可能造成该节点的丢失，所以翻转链表时（单向或双向），都要注意保存它的周围环境。 时间复杂度：O(n) 空间复杂度：O(1) public ListNode reverseList(ListNode head) { ListNode prev = null; ListNode cur = head; whil
链表填空题（打印）1
08-08
/*链表的结点删除部分略*/}程序运行结果为： 333 gong 222 chen 111 wang3. 以下结点node定义了一个学生的信息，函数del
链表及使用
07-27
链表的学习
C语言单链表的创建
qq_51830913的博客
07-20 1362
单链表是一种线性结构，但是它不是像一维数组一样所有的存储空间都是连续的。单链表是碎片的，也就是不连续。那么它是靠什么来连接，从而使它成为一种线性结构？如图：L就是一个单链表的结构，a就是一个数组。L中用红线连接起来的是一个个节点。每一个节点分为俩部分，一个是data域,还有一个是指针next域。data域里面存放的就是数据，next存放的是下一个节点的地址，也就是这样，next一个连一个，把链表串了起来。需要注意的是：头节点，也就是第一个节点的data通常是不存储数据的。
最完整C语言单链表
亿只萌新的博客
11-06 2896
用C语言创建一条链表，并对其增删改查排序。
c语言单链表销毁、清空
qq_42449028的博客
08-02 2466
清空指从首元结点开始删除每一个结点，并将头结点的next指针置为null。由于头结点不能删除，所以删除时循环需从首元结点开始，最后对头结点做单独置空。销毁指从头结点开始删除每一个结点。...
C语言单链表代码
weixin_42104550的博客
08-26 2778
下面的内容对初学者来说很抽象，建议多画图理解，或者去看熟悉我的C语言内存结构以及指针研究的文章再来理解链表。 顺序表的缺点可以用链表来解决，链表也分为单链表和双链表。这一文只展示单链表的代码。为什么单链表的访问效率极高，而且不会因为表的长度而影响的。因为链表在每一个数据前面都有一个地址头，也就是说链表的每个数据其实是有头有尾的，头是一个指向尾的地址，尾部才是真正的用户存储的数据。 每个数据是这样存储的，next是地址指针 data才是数据。每个数据都是独立的一个节点，只是这些块节点有next指针把它们串
c语言单链表实验小结
最新发布
04-10
C语言单链表实验小结： 在C语言中，单链表是一种常用的数据结构，用于存储和操作数据。在实验中，我们学习了如何使用C语言来实现单链表，并进行了相关的操作。 首先，我们需要定义一个结构体来表示链表的节点，该...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

点灯大师～

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

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

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

打赏作者

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

抵扣说明：

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

余额充值