反转一个单链表（C Python Java）

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

C语言

三指针法（头插法）：
利用temp临时存储q->next，p与q反转连接后再将temp赋值给q。

struct ListNode* reverseList(struct ListNode* head)
{
    struct ListNode*p=NULL;
    struct ListNode*q=head;
    while(q)
    {
        struct ListNode*temp=q->next;
        q->next=p;
        p=q;
        q=temp;
    }
    return p;
}

栈方法：
此方法大致可分为以下步骤：求结点个数->链表入栈->链表出栈

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* reverseList(struct ListNode* head)
{
    if(!head||!head->next)  return head;/*链表为空或一个结点直接返回*/
    struct ListNode*q=head;
    int size=0;
    while(q)/*计算链表结点数*/
    {
        ++size;
        q=q->next;
    }
    struct ListNode*stack[size];/*创建栈*/
    int top=-1;q=head;
    while(q)/*链表入栈*/
    {
        stack[++top]=q;
        q=q->next;
    }
    struct ListNode*head_s=stack[top];
    q=head_s;
    while(top!=-1)/*出栈*/
    {
        q->next=stack[top--];
        q=q->next;
    }
    q->next=NULL;
    return head_s;
}

Java

栈方法

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) 
    {
        Stack<ListNode>stack=new Stack<>();
        while(head!=null)/*结点入栈*/
        {
            stack.push(head);
            head=head.next;
        }
        if(stack.isEmpty())return null;
        ListNode head2=stack.peek();
        ListNode node=stack.pop();
        while(!stack.isEmpty())/*结点反向出栈*/
        {
            ListNode tempNode=stack.pop();
            node.next=tempNode;
            node=node.next;
        }
        node.next=null;
        return head2;
    }
}

在Java中栈是Vector的一个子类，所以不用自己定义，所以会比上面C语言的栈方法简单一些，但基本原理还是挺相似的，都是先入栈后出栈。

递归：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {

public ListNode reverseList(ListNode head) {
    //终止条件
    if (head == null || head.next == null)
        return head;
    //保存当前节点的下一个结点
    ListNode next = head.next;
    //从当前节点的下一个结点开始递归调用
    ListNode reverse = reverseList(next);
    //reverse是反转之后的链表，因为函数reverseList
    // 表示的是对链表的反转，所以反转完之后next肯定
    // 是链表reverse的尾结点，然后我们再把当前节点
    //head挂到next节点的后面就完成了链表的反转。
    next.next = head;
    //这里head相当于变成了尾结点，尾结点都是为空的，
    //否则会构成环
    head.next = null;
    return reverse;
}
}

递归还是稍微有一点绕的，需要好好理解一下。

Python

递归：

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

class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        def reverse_lined_list(node, pre):
            if not node:
                return pre
            
            temp_node = node.next
            node.next = pre

            return reverse_lined_list(temp_node, node)

        return reverse_lined_list(head, None)

递推：

class Solution:
    def reverseList(self, head: ListNode) -> ListNode:

         pre = None
         cur = head
        
         while cur:
             temp = cur.next
             cur.next = pre
             pre = cur
             cur = temp
            
         return pre