看一遍就理解,图解单链表反转

前言

反转链表是程序员必备的基本素养,经常在面试、笔试的过程中出现。一直觉得反转链表实现代码不是很好理解,决定搬leetcode那道经典反转链表题出来,用十多张图去解析它,希望加深大家对链表反转的理解,谢谢阅读。

leetcode的反转链表原题&答案

题目描述: 反转一个单链表。

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

分析:

假设存在链表 1 → 2 → 3 → ?,我们想要把它改成 ? ← 1 ← 2 ← 3。

在遍历列表时,将当前节点的 next 指针改为指向前一个元素。由于节点没有引用其上一个节点,因此必须事先存储其前一个元素。在更改引用之前,还需要另一个指针来存储下一个节点。不要忘记在最后返回新的头引用!

代码实现:

public ListNode reverseList(ListNode head) {
    ListNode prev = null;
    ListNode curr = head;
    while (curr != null) {
        ListNode nextTemp = curr.next;
        curr.next = prev;
        prev = curr;
        curr = nextTemp;
    }
    return prev;
}

图解链表反转代码的实现

接下来,我们图解以上代码实现,先对以上实现代码加上行号,如下:

public ListNode reverseList(ListNode head) {  //1
    ListNode prev = null;   // 2
    ListNode curr = head;   // 3
    while (curr != null) {   //4
        ListNode nextTemp = curr.next; //5
        curr.next = prev;  // 6
        prev = curr;  //7
        curr = nextTemp; //8
    }
    return prev;  //9
}

第一行代码图解

public ListNode reverseList(ListNode head) {  //1

我们顺着题目描述意思,假设链表就有1、2、3个元素吧,后面还跟着一个null,又因为输入是ListNode head,所以这个即将要反转的链表如下:

第二行代码图解

ListNode prev = null;   // 2

将null赋值给prev,即prev指向null,可得图如下:

第三行代码图解

ListNode curr = head;

将链表head赋值给curr,即curr指向head链表,可得图如下:

循环部分代码图解

 while (curr != null) {   //4
        ListNode nextTemp = curr.next; //5
        curr.next = prev;  // 6
        prev = curr;  //7
        curr = nextTemp; //8
    }

循环部分是链表反转的核心部分,我们先走一遍循环,图解分析一波。

因为curr指向了headhead不为null,所以进入循环。先来看第5行:

ListNode nextTemp = curr.next; //5

把curr.next 赋值给nextTemp变量,即nextTemp 指向curr的下一节点(即节点2),可得图如下:

再执行到第6行:

curr.next = prev;  // 6 

把prev赋值给curr.next,因为prev初始化化指向null,即curr(节点1)指向了null,链表图解成这样了:

然后我们看执行到第7行

 prev = curr;  //7

把curr赋值给prev,prev指向curr,图解如下:

接着,我们执行到第8行:

curr = nextTemp; //8

把nextTemp赋值给curr,即curr指向nextTemp,图解如下:

至此,第一遍循环执行结束啦,回到循环条件,curr依旧不为null,我们继续图解完它。

5-8行代码又执行一遍,依次可得图:

        ListNode nextTemp = curr.next; //5
        curr.next = prev;  // 6
        prev = curr;  //7
        curr = nextTemp; //8

执行完ListNode nextTemp = curr.next;后:

执行完curr.next = prev;后:

执行完prev = curr;后:

执行完curr = nextTemp;后:

来到这里,发现curr还是不为null,再回到while循环,再执行一遍:

        ListNode nextTemp = curr.next; //5
        curr.next = prev;  // 6
        prev = curr;  //7
        curr = nextTemp; //8

依次可得图:

来到这里,我们发现curr已经为null了,可以跳出循环了。这时候prev指向的就是链表的反转呀,所以第9行执行完,反转链表功能实现:

 return prev;  //9

参考与感谢

个人公众号

  • 如果你是个爱学习的好孩子,可以关注我公众号,一起学习讨论。
  • 如果你觉得本文有哪些不正确的地方,可以评论,也可以关注我公众号,私聊我,大家一起学习进步哈。

原文地址:https://www.cnblogs.com/jay-huaxiao/p/12286133.html

时间: 2024-10-11 03:44:36

看一遍就理解,图解单链表反转的相关文章

图解单链表反转

仅一家之言,望多交流,如有错漏,还请指教! 另,做图不易,转发请注明出处 https://www.cnblogs.com/luego/p/11421590.html 本文有要以图的方式,来呈现链表反转推演的具体过程,以助于理解,保持思路的清晰. 主要采用两种方法实现单链表反转: (1)通过循环,通过三个指针对链表进行遍历,并逐个反转: (2)使用递归的方法进行反转.  1. 循环反转 废话不多说,先上图: 操作过程: ① 初始化pNext至当前节点的下一个节点,为断链做准备② 判断下一个节点是否

链表 单链表反转

思路1:O(n^2). “狸猫换太子”,不进行改动链表结构,只首尾交换len/2次.但是在本函数中用到了定位函数,定位函数实际上是遍历了一遍整个链表,所以综合效率很低,达到O(n^2). //单链表反转(O(n^2)) void reverseList(Node* Head) { int count = numOfNodes(Head); //首尾交换 for(int i=1; i<=count/2; i++) { Node* p1 = locateNodeI(Head, i); Node* p

单链表反转总结篇

单链表反转总结篇 转自https://www.cnblogs.com/byrhuangqiang/p/4311336.html 单链表的反转是常见的面试题目.本文总结了2种方法. 1 定义 单链表node的数据结构定义如下: class ListNode { int val; ListNode next; ListNode(int x) { val = x; next = null; } } 2 方法1:就地反转法 2.1 思路 把当前链表的下一个节点pCur插入到头结点dummy的下一个节点中

单链表反转问题

单链表反转问题 基本问题 如何将单链表反转? 算法实现 /** * * Description: 单链表反转. * * @param head * @return ListNode */ public static ListNode reverseList(ListNode head) { if (head == null) { return head; } ListNode prev = null; ListNode current = head; ListNode next = null;

单链表反转的2种方法

1 public class ReverseDemo { 2 3 /** 4 * 单链表反转的两种方法 5 */ 6 public static void main(String[] args) { 7 Node head =new Node("a"); 8 Node node2=new Node("b"); 9 Node node3=new Node("c"); 10 head.setNext(node2); 11 node2.setNext(

单链表反转C语言实现

单链表的反转可以使用循环,也可以使用递归的方式 1.循环反转单链表 循环的方法中,使用pre指向前一个结点,cur指向当前结点,每次把cur->next指向pre即可. 代码: # include <iostream> # include <cstdlib> using namespace std; struct linkNode { int val; linkNode *next; linkNode(int x):val(x),next(NULL){} }; linkNod

单链表反转python实现

单链表的反转可以使用循环,也可以使用递归的方式 1.循环反转单链表 循环的方法中,使用pre指向前一个结点,cur指向当前结点,每次把cur->next指向pre即可. 代码: class ListNode: def __init__(self,x): self.val=x; self.next=None; def nonrecurse(head): #循环的方法反转链表 if head is None or head.next is None: return head; pre=None; c

数据结构 单链表反转 回顾练习

之前写了一个单链表反转,但是使用的新的空间. 这次的反转是不修改原来的结构,直接将节点内的元素进行修改 1 #!/usr/bin/env python3 2 3 class LNode(object): 4 def __init__(self, elem, next_=None): 5 self.elem = elem 6 self.next = next_ 7 8 class ListError(Exception): 9 pass 10 11 class LList(object): 12

单链表反转(Singly Linked Lists in Java)

单链表反转(Singly Linked Lists in Java) 博客分类: 数据结构及算法 Java代码   package dsa.linkedlist; public class Node<E>{ E data; Node<E> next; } Java代码   package dsa.linkedlist; public class ReverseLinkedListRecursively { public static void main(String args[])