单链表操作大全（图解逆序）

最新推荐文章于 2022-09-16 15:25:11 发布
最新推荐文章于 2022-09-16 15:25:11 发布
阅读量7.5k 收藏 22
点赞数 3
分类专栏： C 文章标签： null date delete output insert struct
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dxdxsmy/article/details/7346326
版权

 如果说你经常在linux中，或者在kernel下面做事的话，一定会碰到链表的操作。
如果你没有真正了解单链表，还是把基础打好吧。
如下程序综合了链表的常用方面，请你下自己写出每个函数，debug并运行，直到运行正确；然后对照参考程序，
比较程序的差异，有时候，可能你测试不全面，会有这样那样的错误，多思考，这样，你才记忆深刻。

#include <stdio.h>  
#include <stdlib.h>  
  
typedef struct node  
{  
	int nDate;  
	struct node *pstnext;  
}Node;  
//链表输出  
void output(Node *head)  
{  
	Node *p = head->pstnext;  
	while(NULL != p)  
	{  
  	printf("%d  ", p->nDate);   
  	p = p->pstnext;  
	}  
	printf("\r\n");  
}  
//链表建立  
Node* creat()  
{  
	Node *head = NULL, *p = NULL, *s = NULL;  
	int Date = 0, cycle = 1;  
	head = (Node*)malloc(sizeof(Node));  
	if(NULL == head)  
	{  
	  printf("分配内存失败\r\n");  
	  return NULL;  
	}  
	head->pstnext = NULL;  
  
	p = head;  
	while(cycle)  
	{  
  		printf("请输入数据且当输入数据为0时结束输入\r\n");  
  		scanf("%d", &Date);  
  		if(0 != Date)  
  		{  
   			s = (Node*)malloc(sizeof(Node));  
   			if(NULL == s)  
   			{  
    				printf("分配内存失败\r\n");  
    				return NULL;  
   			}  
   			s->nDate = Date;  
   			p->pstnext = s;  
   			p = s;  
  		}  
  		else  
  		{  
   			cycle = 0;  
  		}  
	}  
	p->pstnext = NULL;  
	return(head);  
}  
//单链表测长  
void length(Node *head)  
{  
	Node *p = head->pstnext;  
	int j=0;  
	while(NULL != p)  
	{  
  		p = p->pstnext;  
  		j++;  
	}  
	printf("%d\r\n", j);  
}  
//链表按值查找  
void research_Date(Node *head, int date)  
{  
	Node *p;  
	int n=1;  
	p = head->pstnext;  
	while(NULL != p && date != p->nDate)  
	{	  
 		 p = p->pstnext;  
  		++n;  
	}  
	if(NULL == p)  
	{  
		  printf("链表中没有找到该值");  
	}
	else if(date == p->nDate)  
	{  
  		printf("要查找的值%d在链表中第%d个位置\r\n", date, n);  
	}  
	return;  
}  
//按序号查找  
void research_Number(Node *head, int Num)  
{  
	Node *p=head;  
	int i = 0;  
	while(NULL != p && i < Num)  
	{  
  		p = p->pstnext;  
  		i++;  
	}  
	if(p == NULL)  
	{  
  		printf("查找位置不合法\r\n");  
	}
	else if(i == 0)  
	{  
  		printf("查找位置为头结点\r\n");  
	}
	else if(i == Num)  
	{  
  		printf("第%d个位置数据为%d\r\n", i, p->nDate);  
	}  
}  
//在指定元素之前插入新结点  
void insert_1(Node *head, int i, int Newdate)  
{  
	Node *pre = head, *New = NULL;  
	int j = 0;  
	while(NULL != pre && j < i-1)  
	{   
  		pre = pre->pstnext;  
  		j++;  
	}  
	if(NULL == pre || j > i-1)  
	{  
  		printf("插入位置不存在\r\n");  
	}
	else  
	{  
  		New = (Node*)malloc(sizeof(Node));  
  		if(NULL == New)  
  		{  
   			printf("分配内存失败\r\n");  
   			return;  
  		}  
  		New->nDate = Newdate;  
  		New->pstnext = pre->pstnext;  
  		pre->pstnext = New;  
	}  
  
}  
//在指定元素之后插入新结点  
void insert_2(Node *head, int i, int Newdate)  
{  
	Node *pre = head, *New = NULL;  
	int j = 0;  
	while(NULL != pre->pstnext && j < i)  
	{  
  		pre = pre->pstnext;  
  		j++;  
	}  
	if( j == i)  
	{  
  		New = (Node*)malloc(sizeof(Node));  
  		if(NULL == New)  
  		{  
  			printf("分配内存失败\r\n");  
   			return;  
  		}  
  		New->nDate = Newdate;  
  		New->pstnext = pre->pstnext;  
  		pre->pstnext = New;  
	}
	else  
	{  
  		printf("插入位置不存在\r\n");  
	}  
}  
//删除指定结点  
void Delete_1(Node *head, int i3)  
{  
	Node *p = head, *pre = NULL;  
	int j = 0;  
	while(NULL != p && j < i3)  
	{  
  		pre = p;  
  		p = p->pstnext;  
  		j++;  
	}  
	if(NULL == p)  
	{  
 		printf("删除位置不存在\r\n");  
	}
	else  
	{  
  		pre->pstnext = p->pstnext;  
  		free(p);  
	}  
}  
//指定删除单链表中某个数据，并统计删除此数据的个数  
int Delete_2(Node *head, int Delete_date)  
{  
	int count = 0;  
	Node *p = head, *q;  
	while(NULL != p->pstnext)  
	{	  
  		q = p->pstnext;  
  		if(q->nDate == Delete_date)  
  		{  
   			p->pstnext = q->pstnext;  
   			free(q);  
   			++count;  
  		}  
  		else  
  		{  
   			p = q;  
  		}  
}  
return count;  
}  
//链表逆置，一定要掌握好，详解见图 
void Reverse_list(Node *head)  
{  
	Node *q, *s;  
	if(NULL == head->pstnext || NULL == head->pstnext->pstnext)  //是否要判断head为空？
	{  
  		return;  
	}  
	q = head->pstnext->pstnext;  
	head->pstnext->pstnext = NULL;  
	while(NULL != q)  
	{  
  		s = q->pstnext;  
  		q->pstnext = head->pstnext;  
  		head->pstnext = q;  
  		q = s;  
	}  
}  
//单链表的连接  
void connect_list(Node *head, Node *head_New)  
{  
	Node *p = head;  
	while(NULL != p->pstnext)  
	{	  
  		p = p->pstnext;  
	}  
	p->pstnext = head_New->pstnext;  
}  
//单链表销毁  
void destroy_list(Node* head)  
{  
	while (NULL != head)  
	{  
		Node* temp = head;  
  		head = head->pstnext;  
  		free(temp);  
	}  
}  
main()  
{  
int date, num;    //待查找数据  
int i3;     //指定删除元素的位置  
int i1, i2, Newdate_1, Newdate_2;    //待插入的新数据  
int Delete_date, k;    //待删除的数据与其个数  
Node *Head = NULL;   //定义头结点  
Node *Head_New = NULL;  
  
//链表建立  
Head = creat();  
printf("输出建立的单链表\r\n");  
output(Head);  
  
//单链表测长  
printf("单链表长度为\r\n");  
length(Head);  
  
//链表按值查找  
printf("请输入待查找的数据\r\n");  
scanf("%d", &date);  
    research_Date(Head, date);  
  
//链表按序号查找  
printf("请输入待查找序号\r\n");  
scanf("%d", &num);  
research_Number(Head, num);  
  
//在指定第i1个元素之前插入新元素Newdate  
printf("在指定第i个元素之前插入新元素Newdate");  
printf("请输入i与元素且以逗号间隔\r\n");  
scanf("%d,%d", &i1, &Newdate_1);  
insert_1(Head, i1, Newdate_1);  
printf("插入后新链表\r\n");  
output(Head);   
  
//在指定第i2个元素之后插入新元素Newdate  
printf("在指定第i个元素之后插入新元素Newdate");  
printf("请输入i与元素且以逗号间隔\r\n");  
scanf("%d,%d", &i2, &Newdate_2);  
insert_2(Head, i2, Newdate_2);  
printf("插入后新链表\r\n");  
output(Head);   
  
//指定删除i3元素  
printf("删除元素的位置\r\n");  
scanf("%d", &i3);  
Delete_1(Head, i3);  
printf("删除后新链表\r\n");  
output(Head);  
  
//指定删除单链表中某个数据，并统计删除此数据的个数  
printf("请输入待删除的元素\r\n");  
scanf("%d", &Delete_date);  
k = Delete_2(Head, Delete_date);  
printf("删除后新链表\r\n");  
output(Head);  
printf("删除指定元素在链表中的个数为：");  
printf("%d\r\n", k);  
  
//单链表逆置  
Reverse_list(Head);  
printf("逆置后输出\r\n");  
output(Head);  
  
//单链表的连接  
printf("建立一个新链表\r\n");  
Head_New = creat();  
printf("输出新链表");  
output(Head);  
printf("将新链表连接到原来链表的尾部并输出\r\n");  
connect_list(Head, Head_New);  
output(Head);  
         destroy_list(Head);  
  
}


如果，你对前面几个操作比较熟悉的话，单链表逆序就能考验你的能力了，(其实也不难），关键是思路清晰。
首先，我们看下单链表逆序的原理，如果你理解错了，可能程序也写不出来。
原理如图所示：

 

这里我们分析一下程序中的逆序函数，特别提出的是，这里的单链表是含有header的单链表。
为画图方便，这里，我们暂时只假定链表中只有3项，1，2和3.更多的情况类同。
每条语句的含义都在图中详细解释了。

 

附1：无链表头的单链表逆序程序

typedef struct student
{
    int number;
    char name[20];
    int score;
    struct student *next;
}student;


student *reverse2(student *stu)
{
        student *p1,*p2,*p3;
        if(stu == NULL ||stu->next == NULL)
                return stu;
        p1=stu;                                   //p1指向链表的第一个节点                                                  
          p2=p1->next;
    	p1->next = NULL;
        while(p2)
        {
                p3=p2->next;
                p2->next = p1;
                p1=p2;
                p2=p3;
        }
        printf("p1 = %d,next = %d\n ",p1->number,p1->next->number);
        stu=p1;                                  //将链表第一个节点指向p1
        return stu;
}


 

附2：从无头单链表中删除节点
题目：

        假设有一个没有头指针的单链表。一个指针指向此单链表中间的一个节点（非第一个节点， 也非最后一个节点）。请将该节点从单链表中删除。

 

解答：

        典型的“狸猫换太子”， 若要删除该节点，正常情况下，应该要知道该节点的前面节点的指针，但是由于单链表中没有头结点，所以无法追溯到该节点前面的那个节点，因此，这里采用了“移花接木”的方法。设该节点为B，下一个节点为C。那么，首先将B节点的内容替换为C节点的内容，然后，将C节点删除，这样就达到了我们的目的。代码如下：

		pcur->next = pnext->next;

		pcur->data = pnext->date;

		delete pnext;

代码

void DeleteListNode(node* pCurrent)  
{      
 assert(pCurrent != NULL);      
 node* pNext = pCurrent -> next;     
 if (pNext == NULL)      
  pCurrent = NULL;    
 else  
 {     
  pCurrent -> next = pNext -> next;  
  pCurrent -> data = pNext -> data;   
  delete pNext;     
 }
}

类似问题：

1、 从无头单链表中删除节点问题：假设有一个没有头指针的单链表，一个指针p指向单链表中的一个节点（不是第一个，也不是最后一个），请将该节点删除掉。

2、 向无头单链表中添加节点问题：假设有一个没有头指针的单链表，一个指针p指向单链表中的一个节点（不是第一个，也不是最后一个），请在该节点之前插入一个新的节点q。

 

        由于链表是无头单向链表，所以我们无法由当前节点获得p的前一节点，而无论是删除当前节点还是向前面节点插入新节点都需要获得p的前一节点。在这里我们不妨换一下思路，对当前节点的后继结点进行操作，然后将前后节点的数据进行适当交换也可以得到相应效果。

问题1解法：将p后继结点p->next的数据拷贝到p，然后删除p->next，这样就达到了相同的效果，代码如下：

			      ListNode* p_next = p->next;

                                p->value=p_next->value;

                                p->next=p_next->next;

                                delete   p_next;


问题2解法：在p节点后添加q，然后交换p和q的数据即可。

			      q->next=p->next;

                                p->next=q;

                                swap(&p->value, &q->value);


 

扩展问题：

        将一个单链表，在只遍历一遍的情况下，将单链表中的元素顺序反转过来。

解答：

        我的想法是这样的，用三个指针进行遍历，在遍历的途中，进行逆置。

 


 

xuexingyang
关注
  • 3
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】——手撕单链表（流程图+代码版）
yangzaiiscute的博客
11-11 1598
单链表的增删查改，代码、流程图、注释，你想要的我都有!
无头单链表逆序（法一）
Embedded Travel
02-27 968
#include "stdio.h" #include "stdlib.h" #include "time.h" typedef struct node{ int a; struct node* next; }LNODE; LNODE* LinklistCreate(void); void LinklistVisit(LNODE *head); LNODE* LinklistConvert
C语言数据结构实现链表逆序并输出
12-26
C语言数据结构实现链表逆序并输出 将一个链表逆序并输出。我用了两种方法来实现，第一种是借助了一个新的空链表；第二种是在原来链表的基础上直接实现逆序。 实例代码：     头文件：   #include #include #include typedef int ElemType; typedef struct Node {//结点结构 ElemType value; //值域 struct Node *next;//指针域 }Node,*ptr_Node; typedef struct LinkList {/
实现链表的逆序的三种方式
热门推荐
Lud的博客
09-24 1万+
文章目录问题分析方法一：就地逆序方法二：递归法方法三：插入法 问题 给定一个带头节点的单链表，将其逆序。head->1->2->3->4->5->6->7变为 head->7->6->5->4->3->2->1。 分析 单链表与数组不同，单链表中每个节点的地址都存储在其前驱节点的指针域中，因此对链表中任何一个节...
链表逆序
xiaozhu0301的博客
07-04 3656
链表逆序的本质就是把没一个节点原本指向的下一个节点的next指针倒转过来，指向它的前置节点 让我们从链表头部开始，建立三个临时节点的引用，分别为p1，p2，p3。它们分别指向头节点、第二个节点、第三个节点。 实现链表逆序的完整步骤如下： 1.以p2节点为视角，把p2节点原本指向p3的next指针倒转，指向p1。 2.三个临时节点引用p1，p2，p3分别向后移动一格位置。...
单链表的基本操作（全）
weixin_55859275的博客
09-27 1637
#include<stdio.h> #include<stdlib.h> #define ERROR NULL typedef int ElemType; typedef struct LNode *PtrToLNode; typedef struct LNode { //对节点的定义 int Date; struct LNode *next; }LNode; typedef PtrToLNode List; typedef PtrToLNode Post.
C语言实现单链表逆序与逆序输出实例
09-04
总结来说，单链表的逆序输出和逆序操作是数据结构和算法的基础知识，它们对理解和实现更复杂的链表操作如排序、查找等具有重要意义。熟练掌握这些技能有助于提升编程能力，特别是在处理动态数据结构的问题时。通过...
单链表逆序
03-04
逆序单链表的目标是将链表的顺序从原来的"头 -> 节点1 -> 节点2 -> ... -> 尾"转变为"尾 -> 节点2 -> 节点1 -> 头"。以下是实现这一操作的步骤： 1. 初始化单链表：首先，我们需要创建一个空的链表。这可以通过定义...
算法实现：Java单链表逆序
最新发布
09-01
有一次，我去陆家嘴一家银行面试，面试官给我出了一道算法编程题，用Java实现单链表逆序，不到10分钟，我就写出来了，拿到了offer。 但是当时是写在纸上的，我用手机拍了下来，然后回去又在电脑上把代码敲了下来，...
java实现单链表之逆序
09-03
单链表逆序是指将链表中的元素顺序颠倒，使得原本的第一个元素变为最后一个，原本的最后一个元素变为第一个。这个过程可以通过迭代或递归的方式来实现。本文将详细介绍如何使用Java实现单链表的逆序。 首先，我们...
链表逆序的三大方法（Python实现）
qq_43300880的博客
05-07 2861
链表逆序的三大方法 更多文章代码详情，可以查看博主： GitHub地址：https://github.com/TheAlgorithm-SimpleChinese/Python 个人网站：https://www.iwtmbtly.com 假设给定一个带头结点的单链表，要将其逆序。 即如果单链表原来为head->1->2->3->4->5->6->7，那么逆序后变为 head->7->6->5->4->3->2->1。 有什
关于逆序的一些基本操作
feitianxuxue的专栏
11-12 776
1. 字符串逆序，abcde->edcba 2. 单词逆序，how are you->you are how 3. 单链表逆序，[1,2,3,4,5]->[5,4,3,2,1] a = 'abcde' print '原始字符串:', a print '翻转字符串:',a[::-1] def reverse(arr, left, right): """ ...
数据结构——链表（3）——链表的逆序
qq_33713592的博客
05-12 667
链表的逆序：链表的只逆序输出，链表不逆序，第二种是链表的逆序。、 面试中经常考察链表的逆序。 https://www.jianshu.com/p/8b6f4dbe497e https://blog.csdn.net/liu583685/article/details/78125454 参考博客：https://blog.csdn.net/m0_37787222/article/detai...
单链表的逆置--普通循环方法（详细图解）
Jermery的专栏
08-03 4369
关于单链表的逆置，大家都很清楚有两种基本方法：（1）普通的循环的方法。（2）递归调用方法。今天正好研究这两种方法，发现很不理解代码这么写的具体的作用，诚如很多人所说，吃透这个还是要自己画一个详细的过程图。今天就给大家介绍一下（普通的循环方法）我学习下来的一些经验，如有不对之处还望大家一起交流。 首先，以下是关于单链表逆置的普通循环方法的代码： typedef struct ListNode{
单链表的实现及实现链表的反转、逆序、倒数查询
休对故人思故国，且将新火试新茶。诗酒趁年华
01-09 252
链表是有序的列表，但它在内存中的存储如下： 小结： 链表是以节点的的方式来存储，是链式存储 每个节点包含data域，next域：指向下一个节点 链表各个节点不一定是连续存储 链表分为带头节点的链表和没有头节点的链表，根据实际的需求来确定。 带头节点的逻辑结构示意图如下： 单链表的应用实例： 定义实体类： /定义HeroNode，每个HeroNode对象就是-一个节点 class HeroN...
单链表(图解以及分析)
qq_54469537的博客
09-16 5021
（单向非循环不带头节点）
数据结构与算法之单链表
hcyxsh的博客
02-25 510
数据结构与算法之单链表 1、链表介绍 链表是有序的列表，但是它在内存中是存储如下 小结上图: 链表是以节点的方式来存储,是链式存储 每个节点包含 data 域， next 域：指向下一个节点. 如图：发现链表的各个节点不一定是连续存储. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定 单链表(带头结点)逻辑结构示意图如下 2、单链表的应用实例 使用带 head 头的单向链表实现 –水浒英雄排行榜管理完成对英雄人物的增删改查操作， 注: 删除和修改,查找 （1） 第一种
设计一个c语言算法，将单链表中结点以逆序排列。逆序的单链表中的结点均为原表中的结点。
03-20
以下是一个C语言算法，可以将单链表中的结点以逆序排列： ```c #include <stdio.h> #include <stdlib.h> struct Node { int data; struct Node* next; }; void reverseList(struct Node** head) { struct Node* prev = NULL; struct Node* current = *head; struct Node* next = NULL; while (current != NULL) { next = current->next; current->next = prev; prev = current; current = next; } *head = prev; } void printList(struct Node* head) { while (head != NULL) { printf("%d ", head->data); head = head->next; } } int main() { struct Node* head = NULL; struct Node* second = NULL; struct Node* third = NULL; head = (struct Node*)malloc(sizeof(struct Node)); second = (struct Node*)malloc(sizeof(struct Node)); third = (struct Node*)malloc(sizeof(struct Node)); head->data = 1; head->next = second; second->data = 2; second->next = third; third->data = 3; third->next = NULL; printf("Original List: "); printList(head); reverseList(&head); printf("\nReversed List: "); printList(head); return 0; } ``` 这个算法会将单链表中的结点以逆序排列，并且逆序的单链表中的结点均为原表中的结点。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值