C语言 单链表的反转

2019-05-18 22:41:09 5840 收藏 39
分类专栏： C 文章标签： C语言 单链表的反转
最后发布:2019-05-18 22:41:09首次发布:2019-05-18 22:41:09
学习笔记
本文链接：https://blog.csdn.net/nanfeibuyi/article/details/90116419
版权

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 测试代码

#include <stdio.h>
#include <stdlib.h>

//链表节点定义 
typedef struct s_node
{
	int data;
	struct s_node* pNext;
}Node;

Node* create_list_head();
Node* create_new_node(int node_data);
int add_node_head(Node* head, Node* new_node);
void display_list(Node* head);
void free_list(Node* head);
Node* revert_list(Node* head);
 
int main(int argc, char *argv[])
{
	//创建链表 
	Node* head = create_list_head();
	if(NULL == head)
	{
		printf("create_list_head failed!\n");
		return -1;
	}
	
	//填充数据（添加节点） 
	int i;
	for(i=1; i<8; i++)
		add_node_head(head, create_new_node(i));

	//打印原来链表数据 
	printf("befor "); 
	display_list(head);
	
	//反转链表
	head = revert_list(head); 
	printf("after "); 
	display_list(head);
	
	//释放链表空间 
	free_list(head);
	return 0;
}

//创建链表 
Node* create_list_head()
{
	Node* head = (Node*)malloc(sizeof(Node));
	if(NULL != head)
	{
		head->data= -1;
		head->pNext= NULL;	
	}
	return head;
} 

//创建新节点 
Node* create_new_node(int node_data)
{
	Node* new_node = (Node*)malloc(sizeof(Node));
	if(NULL != new_node)
	{
		new_node->data= node_data;
		new_node->pNext= NULL;	
	}	
	return new_node;
}

//头插法
int add_node_head(Node* head, Node* new_node)
{
	if(NULL == head || NULL == new_node)
		return -1;
 	new_node->pNext = head->pNext;
	head->pNext = new_node;
	return 0; 
} 

//打印链表数据 
void display_list(Node* head)
{
	if(NULL == head)
		return;
	Node* tmp = head;
	printf("list data:");
	while(NULL !=(tmp=tmp->pNext))
	{
		printf("%d  ", tmp->data);
	}
	printf("\n");
}

//释放链表 
void free_list(Node* head)
{
	if(NULL == head) 
		return;
	Node* p = head;
	while(p = p->pNext)
	{
		head->pNext = p->pNext;
		//printf("free:%d\n", p->data);
		free(p);
		p = head;
	}
	free(head);
} 

//头插方式1-反转链表 
Node* revert_list(Node* head)
{
	if(NULL == head)
		return;

	Node* p = head->pNext;
	head->pNext= NULL;
	Node* tmp = NULL;
	while(p)
	{
		tmp = p->pNext;
		add_node_head(head, p); 
		p = tmp;	
	}
	
	return head;
}

        2.1.3 测试结果

              

        2.2 头插法2 --与方式1雷同

         2.2.1 思路：除了第一个逐个往插入到最前面

         2.2.2 测试代码

#include <stdio.h>
#include <stdlib.h>

//链表节点定义 
typedef struct s_node
{
	int data;
	struct s_node* pNext;
}Node;

Node* create_list_head();
Node* create_new_node(int node_data);
int add_node_head(Node* head, Node* new_node);
void display_list(Node* head);
void free_list(Node* head);
Node* revert_list(Node* head);
 
int main(int argc, char *argv[])
{
	//创建链表 
	Node* head = create_list_head();
	if(NULL == head)
	{
		printf("create_list_head failed!\n");
		return -1;
	}
	
	//填充数据（添加节点） 
	int i;
	for(i=1; i<8; i++)
		add_node_head(head, create_new_node(i));

	//打印原来链表数据 
	printf("befor "); 
	display_list(head);
	
	//反转链表
	head = revert_list(head); 
	printf("after "); 
	display_list(head);
	
	//释放链表空间 
	free_list(head);
	return 0;
}

//创建链表 
Node* create_list_head()
{
	Node* head = (Node*)malloc(sizeof(Node));
	if(NULL != head)
	{
		head->data= -1;
		head->pNext= NULL;	
	}
	return head;
} 

//创建新节点 
Node* create_new_node(int node_data)
{
	Node* new_node = (Node*)malloc(sizeof(Node));
	if(NULL != new_node)
	{
		new_node->data= node_data;
		new_node->pNext= NULL;	
	}	
	return new_node;
}

//头插法
int add_node_head(Node* head, Node* new_node)
{
	if(NULL == head || NULL == new_node)
		return -1;
 	new_node->pNext = head->pNext;
	head->pNext = new_node;
	return 0; 
} 

//打印链表数据 
void display_list(Node* head)
{
	if(NULL == head)
		return;
	Node* tmp = head;
	printf("list data:");
	while(NULL !=(tmp=tmp->pNext))
	{
		printf("%d  ", tmp->data);
	}
	printf("\n");
}

//释放链表 
void free_list(Node* head)
{
	if(NULL == head) 
		return;
	Node* p = head;
	while(p = p->pNext)
	{
		head->pNext = p->pNext;
		//printf("free:%d\n", p->data);
		free(p);
		p = head;
	}
	free(head);
} 

//新建链表方式-反转链表 
Node* revert_list(Node* head)
{
	if(NULL == head)
		return;
	
	Node* p = head->pNext;
	Node* q = NULL;
	while(q = p->pNext)
	{
		p->pNext = q->pNext;//分离q 
		add_node_head(head, q);//将q插入到首元素位置 
	}
	
	return head;
}

         2.2.3 测试结果

     

 三、方式2 尾插方式

        3.1 思路：找到最后一个元素，然后从第一个元素逐个插入到尾部。

        3.2 测试代码

#include <stdio.h>
#include <stdlib.h>

//链表节点定义 
typedef struct s_node
{
	int data;
	struct s_node* pNext;
}Node;

Node* create_list_head();
Node* create_new_node(int node_data);
int add_node_tail(Node* head, Node* new_node); 
void display_list(Node* head);
void free_list(Node* head);
Node* revert_list(Node* head);
 
int main(int argc, char *argv[])
{
	//创建链表 
	Node* head = create_list_head();
	if(NULL == head)
	{
		printf("create_list_head failed!\n");
		return -1;
	}
	
	//填充数据（添加节点） 
	int i;
	for(i=1; i<8; i++)
		add_node_tail(head, create_new_node(i));

	//打印原来链表数据 
	printf("befor "); 
	display_list(head);
	
	//反转链表
	head = revert_list(head); 
	printf("after "); 
	display_list(head);
	
	//释放链表空间 
	free_list(head);
	return 0;
}

//创建链表 
Node* create_list_head()
{
	Node* head = (Node*)malloc(sizeof(Node));
	if(NULL != head)
	{
		head->data= -1;
		head->pNext= NULL;	
	}
	return head;
} 

//创建新节点 
Node* create_new_node(int node_data)
{
	Node* new_node = (Node*)malloc(sizeof(Node));
	if(NULL != new_node)
	{
		new_node->data= node_data;
		new_node->pNext= NULL;	
	}	
	return new_node;
}

//尾插法 
int add_node_tail(Node* head, Node* new_node)
{
	if(NULL == head || NULL == new_node)
		return -1;
	Node* tmp = head;
	while( NULL != tmp->pNext )//遍历链表到尾部 
	{
		tmp = tmp->pNext;
	}
	
	tmp->pNext = new_node;
	new_node->pNext = NULL; 
	return 0;
} 

//打印链表数据 
void display_list(Node* head)
{
	if(NULL == head)
		return;
	Node* tmp = head;
	printf("list data:");
	while(NULL !=(tmp=tmp->pNext))
	{
		printf("%d  ", tmp->data);
	}
	printf("\n");
}

//释放链表 
void free_list(Node* head)
{
	if(NULL == head) 
		return;
	Node* p = head;
	while(p = p->pNext)
	{
		head->pNext = p->pNext;
		//printf("free:%d\n", p->data);
		free(p);
		p = head;
	}
	free(head);
} 

//尾插方式-反转链表 
Node* revert_list(Node* head)
{
	if(NULL == head)
		return;
	
	Node* p = head->pNext, *q, *end = head;
	while( NULL != end->pNext )//使得end指向链表最后一个元素
	{
		end = end->pNext;
	}
	q = end;
	 
	while(p != end)
	{
		head->pNext= p->pNext;//分离p
		add_node_tail(head, p);//将p插入到末尾位置
		p =  head->pNext;//p指向第一个元素 
	}
	
	return head;
}

        3.3 测试结果

已标记关键词 清除标记
C语言实现单链表反转
qq_40691208的博客
09-20 7915
最近在考研复习，记录一下基础的数据结构算法，有事没事翻一翻，以防忘了 自己写了个翻转链表算法，感觉要比别人的要通俗易懂些 void Reverse(List *L){ //分别是当前节点，直接前驱节点，直接后继节点 LNode *current, *pre, *pnext; //初始化 current = L -&gt; next; pre = NU...
表情包
插入表情
还能输入1000个字符 “速评一下”
c语言如何实现链表的反转，请详细介绍下
01-20
c语言如何实现链表的反转，请详细介绍下
c语言实现单链表的操作：创建，删除，插入，反转, 排序等下载
07-25
c语言实现单链表的操作：创建，删除，插入，反转, 排序等 相关下载链接：//download.csdn.net/download/wahack/3756831?utm_source=bbsseo
C语言：单链表的反转
qq_43432875的博客
12-17 783
思路 定义三个指针分别指向 当前结点（pte）、下一个结点（pnext）、上一个结点（pre） 从头结点开始遍历、每个循环内的四步为 1.将pnext指向下一个结点（pnext=pte->next） 2.改变当前结点的指针域（pte->next=pre） 3.将pre指向当前结点（pre=pte） 4.当前结点后移、使pte指向下一个结点(pte=pnext) 循环结...
单链表的反转（C语言实现）
qq_37406462的博客
09-25 587
链表的反转或者说逆序的核心思想：遍历链表将所有节点依次摘链，并重新挂在链表头。 假设我们有一个链表，如图 A节点本身就是头节点，所以不必将其再摘链，挂链 所以第一步我们将B节点提到最前面 这个时候C节点变成了A节点的后继节点，我们需要把C节点提到最前面 这样D节点成了A节点的后继节点，依次类推，我们每次只需要将A节点的后继节点摘链并提到最前面即可完成整个链表的反转。 关键代...
链表问题：反转链表、反转m和n之间的链表、K个一组翻转链表
weixin_41565755的博客
08-29 129
1、反转链表 反转一个单链表。 示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL struct ListNode { int val; ListNode *next; ListNode(int x) : val(x), next(NULL) {} }; ...
牛客_将链表m到n节点间的元素进行反转
zhangvalue的博客
09-11 470
题目：将链表m到n节点间的元素进行反转 样例输入：a、b、c、d、e、f 6个ListNode结点的一个单链表 head（head是第一个元素）让其反转3到5 最终输出的val为 1 2 5 4 3 6 也就是3、4、5发生了反转成了5 、4、3 public class Solution2 { /** * 定义的ListNode结构体 */ ...
链表反转--c语言实现
月下犀牛
01-19 5056
今天找一个链表问题时，动手用c语言实现了下，不多说直接上代码/* 0 2 4 6 8 8 6 4 2 0 Press any key to continue */ #include #include #define ELTYPE int typedef struct node { ELTYPE m; struct node *next; } *NODE; void
C语言中单向的链表反转？
12-22
这段代码实在看不懂啊，求解 ``` Linklist *reverse(Linklist *head) //链表逆置 { Linklist *p,*t; p=head->next; t=p->next; p->next=NULL; while(t!=NULL) { p=t->next; t->next=head->next; head->next=t; t=p; } return head; } ``` 其中之一：while中第二句head->next就相当于P，那p=t->next;和t->next=head->next（P）;有什么区别呢？
C语言之单链表反转（递归，迭代），排序
little_fengfeng的博客
06-04 488
C语言之单链表反转（递归，迭代），排序 前言 这篇会是关于单链表最后一篇的介绍，之前还介绍过的文章分别是： 单链表及各项操作介绍 单链表初始化 单链表打印（遍历），查询，定位，插入，删除，链表长度 单链表反转之迭代 对于单链表很多的基本算法，甚至是树结构，在这本人都比较建议各位不要用大脑想如何实现，而是在本子上画出来它的步骤，即使是个大概也好，必须先要有思路再敲代码。所以在这里先用图解来介绍一下单链表反转中运用迭代的方式实现的步骤。 首先我们先取单链表当中的任意一个节点来作例子： 从上面的图片可以看
C语言单向链表的反转实现
Cris_7的博客
02-17 1949
#include &amp;lt;stdio.h&amp;gt; #include &amp;lt;stdlib.h&amp;gt; typedef struct node { int value; struct node *next; } nodes; nodes *LinkList_Init(); void Insert_value(int value_in, nodes *P_node); void ...
如何用c语言实现链表的反转？？？
09-02
如何用c语言实现链表的反转？？？
单链表反转C语言实现
Hokeo的专栏
03-01 2005
typedef struct node { int num; struct node *next; }Node,*pNode; pNode CreatLinkList(int a) { pNode p; pNode q; p = q = (pNode)malloc(sizeof(Node)); p->num = a; while (a--) { p->next = (
使用递归的方法反转单链表 C语言
11-21
typedef struct { node_t * head; node_t * tail; } LL_t; typedef struct _node{ int data; struct _node
c语言手动实现反转链表 Reverse
weixin_30389003的博客
10-20 119
本题要求实现一个函数，将给定的单链表逆转。 函数接口定义： List Reverse( List L ); 其中List结构定义如下： typedef struct Node *PtrToNode; struct Node { ElementType Data; /* 存储结点数据 */ PtrToNode Next; /* 指...
C语言实现单链表反转(图文)
SAU_19IoT_Hu的博客
03-18 247
C语言实现单链表反转(图文) 据说是一道微软的面试题改编 挺有名的,据说很多人面试时 被要求当场纸写程序基本上都没答出来或者没答完整 本着他人故事不要成为我的事故的原则 ,尝试解一解 把思路分享一下(￣▽￣)"
C语言反转单向链表
欢迎来到知识的海洋！！
01-09 639
反转单向链表 思路 定义三个指针p1，p2，p3分别指向要反转节点的上一个节点，要反转的节点，下一次反转的节点 先将链表头结点的next指针置空 保留p3指针（因为在反转的过程中p2-&gt;next会丢失） 将p2进行反转 p1 = p2,p2 = p3; 进行循环反转即可，直到链表结束 最后要将链表的head指针指向p1（此时的p1就是链表的头结点） 代码如下 //反转链表 void re...
LeetCode-92-反转链表II-C语言
SFFS
05-10 274
typedef struct ListNode Node; /* * 算法思想： * 将链表分为三段，index在M与N之间的为第二段，将第二段反转 * 并且记录第一段的尾，第三段的头，用来连接三段链表 */ struct ListNode* reverseBetween(struct ListNode* head, int m, int n){ Node *p = head; ...
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页