将一个链表翻转

最新推荐文章于 2023-11-19 11:45:21 发布
最新推荐文章于 2023-11-19 11:45:21 发布
阅读量363 收藏
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yiluohan0307/article/details/51451531
版权

算法描述：

将一个链表翻转

算法实现：

/*************************************************************************
	> File Name: main.c
	> Author: cyf
	> Mail: XXX@qq.com
	> Created Time: 2016年05月19日 星期四 09时00分24秒
 ************************************************************************/
#include "reverseList.h"
#include "List.h"
struct ListNode* Test(struct ListNode* pHead)
{
    printf("\nThe original list is: \n");
    PrintList(pHead);

    struct ListNode* pReversedHead = reverseList(pHead);

    printf("\nThe reversed list is: \n");
    PrintList(pReversedHead);

    return pReversedHead;
}

// 输入的链表有多个结点
void Test1()
{
    struct ListNode* pNode1 = CreateListNode(1);
    struct ListNode* pNode2 = CreateListNode(2);
    struct ListNode* pNode3 = CreateListNode(3);
    struct ListNode* pNode4 = CreateListNode(4);
    struct ListNode* pNode5 = CreateListNode(5);

    ConnectListNodes(pNode1, pNode2);
    ConnectListNodes(pNode2, pNode3);
    ConnectListNodes(pNode3, pNode4);
    ConnectListNodes(pNode4, pNode5);

    struct ListNode* pReversedHead = Test(pNode1);

    DestroyList(pReversedHead);
}

// 输入的链表只有一个结点
void Test2()
{
    struct ListNode* pNode1 = CreateListNode(1);

    struct ListNode* pReversedHead = Test(pNode1);

    DestroyList(pReversedHead);
}

// 输入空链表
void Test3()
{
    Test(NULL);
}
int main()
{
	Test1();
	Test2();
	Test3();<pre name="code" class="cpp">/*************************************************************************
	> File Name: reverseList.c
	> Author: cyf
	> Mail: XXX@qq.com
	> Created Time: 2016年05月19日 星期四 08时55分50秒
 ************************************************************************/

#include "reverseList.h"
struct ListNode *reverseList(struct ListNode *pHead)
{
	if (pHead == NULL)
		return pHead;
	struct ListNode *pCur = pHead;
	struct ListNode *pNext = pHead->next;
	pCur->next = NULL;
	
	while (pNext != NULL)
	{
		struct ListNode *tmp = pNext->next;
		pNext->next = pCur;
		pCur = pNext;
		pNext = tmp;
	}
	return pCur;
}

return 0;} 

 

/*************************************************************************
	> File Name: reverseList.h
	> Author: cyf
	> Mail: XXX@qq.com
	> Created Time: 2016年05月19日 星期四 08时53分32秒
 ************************************************************************/

#ifndef _REVERSELIST_H
#define _REVERSELIST_H
#include "List.h"
#include <stdlib.h>
#include <stdio.h>
struct ListNode *reverseList(struct ListNode *pHead);

#endif
 

/************************************************************************
	> File Name: List.h
	> Author: cyf
	> Mail: 1097189275@qq.com 
	> Created Time: 2016年03月23日 星期三 17时27分15秒
 ************************************************************************/

#ifndef ALGRITHMN_LIST_H
#define ALGRITHMN_LIST_H


struct ListNode
{
	int data;
	struct ListNode *next;
};
struct ListNode *CreateListNode(int value);
void ConnectListNodes(struct ListNode *pCurrent, struct ListNode *pNext);
void PrintListNode(struct ListNode *pNode);
void PrintList(struct ListNode *pHead);
void AddToTail(struct ListNode **pHead, int value);
void RemoveNode(struct ListNode **pHead,int value);
unsigned int GetListLength(struct ListNode *pHead);
void DestroyNode(struct ListNode *pNode);
void DestroyList(struct ListNode *pHead);

#endif
 

 

/*************************************************************************
	> File Name: List.cpp
	> Author: cyf
	> Mail: 1097189275@qq.com 
	> Created Time: 2016年03月23日 星期三 17时32分11秒
 ************************************************************************/

#include "List.h"
#include <stdio.h>
#include <stdlib.h>
/*
 * 创建一个链表的结点
 * */
struct ListNode *CreateListNode(int value)
{
	struct ListNode *pNode =(struct ListNode *)malloc(sizeof(struct ListNode));
	pNode->data = value;
	pNode->next = NULL;

	return pNode;
}
/*
 * 将两个结点连接起来
 * */
void ConnectListNodes(struct ListNode *pCurrent, struct ListNode *pNext)
{
	if(!pCurrent)
	{
		printf("ERROR!connect two ListNode.\n");
		exit(1);
	}
	pCurrent->next = pNext;
}
/*
 * 打印结点
 * */
void PrintListNode(struct ListNode *pNode)
{
	if(!pNode)
	{
		printf("the node is null!\n");
		exit(1);
	}
	printf("The value of the node is %d\n",pNode->data);
}
/*
 * 打印链表
 * */
void PrintList(struct ListNode *pHead)
{
	printf("print the list:\n");
	struct ListNode *pNode = pHead;
	if(!pNode)
	{
		printf("the list is null\n");
		exit(1);
	}
	while(pNode != NULL)
	{
		printf("%d ",pNode->data);
		pNode = pNode->next;
	}
}
/*
 * 在链表结尾添加结点
 * */
void AddToTail(struct ListNode **pHead, int value)
{
	struct ListNode *pNew = (struct ListNode*)malloc(sizeof(struct ListNode));
	pNew->data = value;
	pNew->next = NULL;

	if(!pHead)
		*pHead = pNew;
	else
	{
		struct ListNode *pNode = *pHead;
		while(pNode != NULL)
		{
			pNode = pNode->next;
		}
		pNode->next = pNew;
	}
	
}
/*
 * 删除链表中结点值为value的结点
 * */
void RemoveNode(struct ListNode **pHead, int value)
{
	if(pHead == NULL||*pHead == NULL)
	{
		printf("the list is null");
		return;
	}
	struct ListNode *ToBeDel = NULL;

	if((*pHead)->data == value)
	{
		ToBeDel = *pHead;
		*pHead = (*pHead)->next;
	}
	else
	{
		struct ListNode *pNode = *pHead;

		while(pNode->next != NULL && pNode->next->data != value)
			pNode = pNode->next;
		if(pNode->next != NULL && pNode->next->data == value)
		{
			ToBeDel = pNode->next;
			pNode->next = pNode->next->next;
		}
	}

	if(ToBeDel != NULL)
	{
		free(ToBeDel);
		ToBeDel = NULL;
	}
}
/*
 * 计算链表的长度
 * */
unsigned int GetListLength(struct ListNode *pHead)
{
	unsigned int length = 0;
	struct ListNode *pNode = pHead;

	while(pNode != NULL)
	{
		++length;
		pNode = pNode->next;
	}

	return length;
}
/*
 * 销毁一个结点
 * */
void DestroyNode(struct ListNode *pNode)
{
	free(pNode);
	pNode = NULL;
}
void DestroyList(struct ListNode* pHead)
{
	struct ListNode *pNode = pHead;
	while (pNode != NULL)
	{
		pHead = pHead->next;
		free(pNode);
		pNode = pHead;
	}
}
 

 

 

 

 


                

        

        

    

  


    

      

        

            

              
                
                  yiluohan0307
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
链表的翻转

				
			

			

				

					usstmiracle的博客
				

				

					11-30
					
					174
					
				

			

		

		

			
				

#include &lt;iostream&gt;
using namespace std;

typedef struct LinkNode
{
    int id;
	struct LinkNode *Next;
}Node;


Node * createLink(Node a[],int n)
{
    Node *head=a;
	for(int i=0;i&lt;n-1;i++)...

			
		

	



                

            
              



	

		

			

				
					
实现链表翻转的两种方法

				
			

			

				

					樛木
				

				

					03-12
					
					1万+
					
				

			

		

		

			
				
题目

从尾到头打印链表_牛客网
https://www.nowcoder.com/practice/d0267f7f55b3412ba93bd35cfa8e8035?tpId=13&amp;tqId=11156&amp;tPage=1&amp;rp=1&amp;ru=/ta/coding-interviews&amp;qru=/ta/coding-interviews/question-rank...

			
		

	



              


  
              

                


	

		

			

				
					
将一个链表进行反转

				
			

			

				

					liyf__88的博客
				

				

					08-13
					
					383
					
				

			

		

		

			
				
/* 
面试题16：反转链表：定义一个函数，输入链表的头结点，反转该链表并输出反转后链表的头结点。 
*/struct ListNode
{
    int m_nvalue;
    ListNode* m_pNext;
};
//创建链表
ListNode* CreateListNode(int value)
{
    ListNode *pNode = new ListNode();

			
		

	





	

		

			

				
					
将单链表翻转的两种方法

				
			

			

				

					weixin_30809173的博客
				

				

					04-16
					
					112
					
				

			

		

		

			
				
单链表翻转很容易理解，例如：
输入： NODE1->NODE2->NODE3->NODE4->NODE5->NULL
输出： NODE5->NODE4->NODE3->NODE2->NODE1->NULL
那么，定义单链表如下： （为简单起见，将data字段定义为int, 当然实际应用中data很可能是一个复杂的结构体）
...

			
		

	



		

			
		



	

		

			

				
					
链表翻转，每k个进行翻转

				
			

			

				

					tinglu的专栏
				

				

					09-19
					
					652
					
				

			

		

		

			
				
链表翻转。给出一个链表和一个数k，比如链表1→2→3→4→5→6，k=2，则翻转后2→1→4→3→6→5，若k=3,翻转后3→2→1→6→5→4，若k=4，翻转后4→3→2→1→5→6

#include 
using namespace std;

struct node{
    int data;
    node* next;
};

node* init(int n)
{
    n

			
		

	





	

		

			

				
					
【力扣面试经典150题】（链表）K 个一组翻转链表

					
最新发布

				
			

			

				

					✎ℳ๓₯㎕...雲淡風輕
				

				

					11-19
					
					561
					
				

			

		

		

			
				
力扣面试经典必刷题之链表

			
		

	





	

		

			

				
					
链表翻转

				
			

			

				

					12-22
				

			

		

		

			
				
翻转指定区间内的链表连接方向（不改变节点的值)，以’1->2->3’的形式输出翻转后的链表。 class IntNode(object):  def __init__(self, value, next_node, previous_node):  self.value = value  self.next = next_...

			
		

	





	

		

			

				
					
K 个一组翻转链表1

				
			

			

				

					08-03
				

			

		

		

			
				
题目 "K 个一组翻转链表1" 是一个典型的链表操作问题，来源于 LeetCode。这个题目要求我们将一个给定的单链表按照每 k 个节点一组进行逆序排列，而剩余不足 k 个节点的部分保持原样。这里 k 是一个正整数，并且 k ...

			
		

	





	

		

			

				
					
K 个一组翻转链表（每次k个翻转+递归）1

				
			

			

				

					08-03
				

			

		

		

			
				
目标是给定一个单链表和一个整数 k，将链表中的节点按 k 个一组进行翻转，同时保持每组内部的相对顺序不变。如果链表的长度不是 k 的整数倍，那么剩下的部分应该保持原样。  首先，我们来看链表的定义。链表由一系列...

			
		

	





	

		

			

				
					
单向链表翻转

				
			

			

				

					韶言大雅
				

				

					04-23
					
					1088
					
				

			

		

		

			
				
编写一个将整条链表翻转过来的小程序。
任务：
编写一个程序，建立一个能存放int型数据的链表；
设计一个函数reverse实现将这条链表逆转过来，即将原来的表头变成表尾，原来的表尾变成表头；
在主函数中实现：
用户输入链表结点个数；依次输入各结点整数值；调用函数reverse，然后遍历并打印逆转后的链表结点整数值。
比如: 用户输入”3 7 8 9” （表示链表结点数3，整数值依次是7 8 9），...

			
		

	





	

		

			

				
					
#leetcode刷题之路25- k个一组翻转链表

				
			

			

				

					weixin_30750335的博客
				

				

					03-19
					
					78
					
				

			

		

		

			
				
给出一个链表，每 k 个节点一组进行翻转，并返回翻转后的链表。k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么将最后剩余节点保持原有顺序。
示例 :给定这个链表：1->2->3->4->5当 k = 2 时，应当返回: 2->1->4->3->5当 k = 3 时，应当返回: 3->2->1->4...

			
		

	





	

		

			

				
					
链表部分翻转

				
			

			

				

					CSDNGuoYuying的博客
				

				

					02-17
					
					535
					
				

			

		

		

			
				
题目描述
【】给定一个链表，翻转该链表从m到n的位置。要求直接翻转而非申请新空间。
【如】：给定1—&gt;2—&gt;3—&gt;4—&gt;5，m–2，n–4，返回1—&gt;4—&gt;3—&gt;2—&gt;5。
【】假定给出的参数满足：1&lt;=m&lt;=n&lt;=链表长度。
时间复杂度为o(n);
以下为代码
#include &lt;stdio.h&gt;
#include &

			
		

	





	

		

			

				
					
每天一道算法题之K个一组翻转链表

				
			

			

				

					m0_46855873的博客
				

				

					07-12
					
					328
					
				

			

		

		

			
				
K个一组翻转链表
题目描述:
给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。1


例如：
给你这个链表：1->2->3->4->5
当 k = 2 时，应当返回: 2->1->4->3->5
当 k = 3 时，应当返回: 3->2->1->4->5
若数目不够无需翻转


思路:
利用栈进行存储需要翻转

			
		

	





	

		

			

				
					
Leetcode:给定一个链表，每次反转链表k的节点并返回其修改后的链表。 如果节点的数量不是k的倍数，那么最后遗漏的节点应该保持原样。

				
			

			

				

					LeetCode:Given a m x n grid filled with non-negative numbers, find a path from top left to bottom right which minimizes the sum 
				

				

					07-06
					
					304
					
				

			

		

		

			
				
Given a linked list, reverse the nodes of a linked listkat a time and return its modified list.

If the number of nodes is not a multiple ofkthen left-out nodes in the end should remain as it is.
...

			
		

	





	

		

			

				
					
LeetCode 25. K 个一组翻转链表

				
			

			

				

					yleave的博客
				

				

					11-14
					
					103
					
				

			

		

		

			
				
https://leetcode-cn.com/problems/reverse-nodes-in-k-group/
难度：困难

  给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。
  k 是一个正整数，它的值小于或等于链表的长度。
  如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。
  示例：
  给你这个链表：1->2->3->4->5
  当 k = 2 时，应当返回: 2->1->4->3->5
  当 k =

			
		

	





	

		

			

				
					
反转链表的四种方法

				
			

			

				

					z3551906947的博客
				

				

					11-24
					
					1万+
					
				

			

		

		

			
				
分享了原地反转，头插，迭代，递归四种反转链表的方法。

			
		

	





	

		

			

				
					
单链表反转两种方法

					
热门推荐

				
			

			

				

					Super小龙的博客
				

				

					01-29
					
					10万+
					
				

			

		

		

			
				
最近同学介绍了一个lettcode(力扣)OJ给我，个人认为这个网站比母校的oj，杭电oj界面友好很多，题库充足，且支持多种主流语言，很适合闲时刷刷提高算法能力，算法的练习如同内功的修炼，碰到算法问题，经常有一种无力感，只能慢慢总结了。
链表是一种重要的数据结构，因为有递归性质，所以总是难以理解，涉及链表的复杂操作总是感觉一头雾水，看别人的实现代码总是似懂非懂，看完就忘，实际上就是没有理解透彻，特...

			
		

	





	

		

			

				
					
单向链表反转（倒置）问题

				
			

			

				

					blioo的博客
				

				

					03-14
					
					9万+
					
				

			

		

		

			
				
今天遇到单向链表的反转的问题，于是静下心来好好想了一番。 
解题思路如下图：假设当前创建好的链表如下：首先让头节点与第一个元素节点断开，但是要注意在断开之前需要用p指针指向第一个元素节点来保存第一个元素节点的位置，然后再断开。在这里有一个指针q指向一个指针域为空的节点，这个节点用来做为链表反转后的最后一个节点。让第二个元素节点的指针从指向第三个元素节点变为指向第一个元素节点，以此类推，直至指针p指向

			
		

	





	

		

			

				
					
leetcode链表反转总结——全部翻转，部分反转

				
			

			

				

					weixin_44844089的博客
				

				

					12-14
					
					2094
					
				

			

		

		

			
				
leetcode链表反转（递归）总结——全部翻转，部分反转
参考：步步拆解：如何递归地反转链表的一部分

由于链表反转使用迭代的思路进行实现比较简单，只是写法上比较复杂，所以这里仅整理记录一下递归反转链表的解法

一.全部反转
1.1 题目

使用递归反转链表，并返回链表

1.2 解法
    /**
     * 递归反转链表
     * @param head
     * @return
     */
    public static ListNode reverseList(ListNode

			
		

	





	

		

			

				
					
用Java写一个链表翻转

				
			

			

				

					02-24
				

			

		

		

			
				
在 Java 中，你可以使用以下代码来实现链表翻转:

```
public class LinkedList {
    private Node head;

    private static class Node {
        private int data;
        private Node next;

        private Node(int data) {
            this.data = data;
        }
    }

    public void addToFront(int data) {
        Node newNode = new Node(data);
        newNode.next = head;
        head = newNode;
    }

    public void reverse() {
        Node current = head;
        Node previous = null;
        Node next = null;

        while (current != null) {
            next = current.next;
            current.next = previous;
            previous = current;
            current = next;
        }

        head = previous;
    }

    public void printList() {
        Node current = head;
        while (current != null) {
            System.out.print(current.data + " ");
            current = current.next;
        }
    }

    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.addToFront(1);
        list.addToFront(2);
        list.addToFront(3);
        list.addToFront(4);
        list.addToFront(5);

        System.out.println("Original list: ");
        list.printList();
        System.out.println();

        list.reverse();

        System.out.println("Reversed list: ");
        list.printList();
    }
}
```

这段代码实现了一个单向链表类，包含了一些基本的方法，比如添加节点、翻转链表、打印链表。

链表翻转的具体实现在 `reverse` 方法中，通过循环不断地将当前节点的 next 指针指向前一个节点，最后将头节点更新为原来的尾节点即可实现链表翻转。

运行上面的代码，你会得到如下输出:

```
Original list: 
5 4 3 2 1 
Reversed list: 
1 2 3 4 5 
```

这就是如何使用 Java 实现链表翻转的基本方法。希望

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  





	
打赏作者

	

		

		
			
		
		

		

			
yiluohan0307

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

		

	

	

			

	

	

    ¥1
    ¥2
    ¥4
    ¥6
    ¥10
    ¥20
	

	

		

			

				

					扫码支付：¥1
				

				

					

					
					获取中
					

				

				

					
					
					扫码支付
				

			

		

		

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

			
打赏作者

		

	



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值