206. Reverse Linked List

题目描述（简单难度）

单链表倒置。

解法一 迭代

首先看一下原链表。

总共需要添加两个指针，pre 和 next。

初始化 pre 指向 NULL 。

然后就是迭代的步骤，总共四步，顺序一步都不能错。

next 指向 head 的 next ，防止原链表丢失

head 的 next 从原来链表脱离，指向 pre 。

pre 指向 head

head 指向 next

次迭代就完成了，如果再进行一次迭代就变成下边的样子。

可以看到整个过程无非是把旧链表的 head 取下来，添加的新链表头部。代码怎么写呢？

next = head.next;//保存head的next，以防取下head后丢失
head.next = pre;//将head从原链表取下，添加到新链表中
pre=head;//pre右移
head=next;//head右移

接下来就是停止条件了，我们再进行一次循环。

可以发现当 head 或者 next 指向 null 的时候，我们就可以停止了。此时将 pre 返回，便是逆序了的链表了。

class ListNode{
    int val;
    ListNode next;
    ListNode(int x){val=x;}
}
public class Reverse_Linked_List {
    public static ListNode reverseList(ListNode head){
        if(head==null) return null;
        ListNode pre=null;
        ListNode next;
        while(head!=null){
            next=head.next;
            head.next=pre;
            pre=head;
            head=next;
        }
        return pre;
    }
    public static void main(String args[]){
        ListNode head=new ListNode(1);
        ListNode p=head;
        p.next=new ListNode(2);
        p=p.next;
        p.next=new ListNode(3);
        p=p.next;
        p.next=new ListNode(4);
        p=p.next;
        p.next=new ListNode(5);
        ListNode ans = reverseList(head);
        while(ans!=null){
            System.out.println(ans.val);
            ans=ans.next;
        }
    }
}

解法二递归

• 首先假设我们实现了将单链表逆序的函数，ListNode reverseListRecursion(ListNode head)，传入链表头，返回逆序后的链表头。
• 接着我们确定如何把问题一步一步的化小，我们可以这样想。

把 head 结点拿出来，剩下的部分我们调用函数 reverseListRecursion ，这样剩下的部分就逆序了，接着我们把 head结点放到新链表的尾部就可以了。这就是整个递归的思想了。

• head 结点拿出来
  
• 剩余部分调用逆序函数 reverseListRecursion ，并得到了 newhead
  
• 将 2 指向 1 ，1 指向 null，将 newhead 返回即可。
  
• 找到递归出口

当然就是如果结点的个数是一个，那么逆序的话还是它本身，直接 return 就够了。怎么判断结点个数是不是一个呢？它的 next 等于 null 就说明是一个了。但如果传进来的本身就是 null，那么直接找它的 next 会报错，所以先判断传进来的是不是 null ，如果是，也是直接返回就可以了。

public ListNode reverseList(ListNode head) {
    ListNode newHead;
    if (head == null || head.next == null) {
        return head;
    }
    newHead = reverseList(head.next); // head.next 作为剩余部分的头指针
    // head.next 代表新链表的尾，将它的 next 置为 head，就是将 head 加到末尾了。
    head.next.next = head;
    head.next = null;
    return newHead;
}

python迭代

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def reverseList(self, head):
        prev=None
        while head:
            curr=head
            head=head.next
            curr.next=prev
            prev=curr
            
        return prev

总结

关于链表的题，没有什么技巧性，还是需要多多练习。

参考文献

• https://zhuanlan.zhihu.com/p/99243026