链表反转操作的三种实现

一、链表反转

带头结点（若不带头可自行设置头结点）的单链表基本构造如下。

typedef int ElementType; 
typedef struct LNode *PtrToLNode;
typedef PtrToLNode Position;
typedef PtrToLNode List;
struct LNode {
    ElementType Data;
    PtrToLNode Next;
};

 它有3种的反（翻）转操作

 

1. 头插法

       将a1到an元素再依次以头插入的方式生成链表，实现链表reverse

List L;
 
/* L为带头结点链表， reverse头结点插入实现 */
List Reverse1(List L)
{ 
　　 /* 头结点指向NULL, 再将后续节点头依次插入 */
    Position p;      /* 连接后续节点指针 */
    Position cur;    /* 当前工作指针 */
    p = L->Next;     /* 指向后续链表 */
    cur = p;
    L->Next = NULL;  /* 头结点分离 */
    
    while ( p!=NULL ) /* 依次向下移动，直到为NULL */ 
    {
        p = p->Next; /* 指向下一节点 */
        /* 将当前节点插入L */
        cur->Next = L->Next;
        L->Next = cur; 
        cur = p; /* 移动到下个节点 */ 
    } 
    
    return L;
}

 

2. 前后指针交替交换

/* 链表翻转，各节点依次反转  */ 
List Reverse2(List L)
{   /* 使用3个指针指向前、中、后三个节点 */
    Position pre;
    Position cur;        /* 当前工作节点 */
    Position rear; 
    cur = L->Next;
    rear = cur->Next;
    
    cur->Next = NULL;       /* 初始操作 将第一个节点变为尾节点 */
    /* rear指向后节点，当rear==NULL，p则为最后节点 */
    while( rear!= NULL ) 
    {   /* 遍历处理 */ 
        pre = cur;       /* 指针依次后移 */
        cur = rear;
        rear = rear->Next;    
            cur->Next = pre;     /* 链表节点翻转 */ 
    } 
    L->Next = cur;           /* 头节点连接到翻转后的链表节点 */
    
    return L;
}

 

3. 递归反转

class ListNode:
    def __init__(self, x):
         self.val = x
         self.next = None

class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        if head is None or head.next is None:
            return head

        new_head = ListNode(0)
        new_head.next = self.reverseList(head.next)

        head.next.next = head
        head.next = None
        return new_head.next

图片来自网络