单链表逆转

单链表逆转

以pta题为例：

函数接口定义：

List Reverse( List L );

其中List结构定义如下：

typedef struct Node *PtrToNode;
struct Node {
    ElementType Data; /* 存储结点数据 */
    PtrToNode   Next; /* 指向下一个结点的指针 */
};
typedef PtrToNode List; /* 定义单链表类型 */

L是给定单链表，函数Reverse要返回被逆转后的链表。

裁判测试程序样例：

#include <stdio.h>
#include <stdlib.h>

typedef int ElementType;
typedef struct Node *PtrToNode;
struct Node {
    ElementType Data;
    PtrToNode   Next;
};
typedef PtrToNode List;

List Read(); /* 细节在此不表 */
void Print( List L ); /* 细节在此不表 */

List Reverse( List L );

int main()
{
    List L1, L2;
    L1 = Read();
    L2 = Reverse(L1);
    Print(L1);
    Print(L2);
    return 0;
}

/* 你的代码将被嵌在这里 */

输入样例：

5
1 3 4 5 2

输出样例：

1
2 5 4 3 1

为方便读者自行测试我将题中省略部分补全并放在下。

#include <stdio.h>
#include <stdlib.h>

typedef int ElementType;
typedef struct Node *PtrToNode;
struct Node {
    ElementType Data;
    PtrToNode   Next;
};
typedef PtrToNode List;

List Read(); 
void Print( List L ); 

List Reverse( List L );

int main()
{
    List L1, L2;
    L1 = Read();
    L2 = Reverse(L1);
    Print(L1);
    printf("\n");
    Print(L2);
    return 0;
}

List Read(){//返回结构体指针的函数
    List L=(List)malloc(sizeof(struct Node)),newp,headp=NULL,tailp;
    int N=0,i,data;
    
    scanf("%d",&N);
    for(i=0;i<N;i++){
        scanf("%d",&data);
        newp=(List)malloc(sizeof(struct Node));
        newp->Data=data;
        if(i==0){
            headp=newp;
        }
        else{
            tailp->Next=newp;
        }
        tailp=newp;
    }
    if(N!=0)
        tailp->Next=NULL;
    return headp;
}

void Print( List check ){
    if(check!=NULL){
        printf("%d ",check->Data);
        Print(check->Next);
    }
}

这里我没有释放申请的内存，但各位读者在写程序时要养成好的习惯。

方法简介

用较为直观的方法表示出链表：
这里用的例子为：1 3 4 5 2注意与输入样例区分。

考虑到效率和解决问题的程度，下面我将重点介绍方法三，其他只是粗略的讲。

第一种方法

一种较为粗糙的方法是通过遍历链表从最后一个节点（data为2）开始更改，通过循环向头结点（data为1）运动。每次循环从头结点开始到上一次更改的前一个节点结束。
他的时间复杂度分析如下：
设链表节点总数为n，则：
时间复杂度的计算如下：

代码如下：

List Reverse( List L ){
    List check=L,tail=L,head=NULL;
    
    if(L==NULL)
        return NULL;
    while((*check).Next!=NULL){
        check=(*check).Next;
    }
    head=check;
    while(check!=L)
    {
        while(tail->Next!=check)
            tail=(*tail).Next;
        (*check).Next=tail;
        check=tail;
        tail=L;
    }
(*check).Next=NULL;
    return head;
}

第二种方法

使用堆栈的方式依次将节点放入栈中，再依次出栈节点。这种方法在解决问题的角度上与第一种方法相似，但实现的方式不同。
分析其时间复杂度为：T=O(n），代码略过。

第三种方法

虽然第二种方法在时间复杂度上已经比第一种方法有了很大的进步，但不能解决更复杂的问题，例如如果链表中有一些无关的节点，即我未必需要将链表的全部节点颠倒，而只是将部分节点颠倒，那么方法二需要进一步的改动（方法一同样无法解决这个问题）。因此需要引入新的方法——方法三。

List Reverse( List L ){
    List front=L,mid=L,rear,nhead;
    if(L==NULL)
        return NULL;
    else{
        rear=front->Next;
        while(rear!=NULL){
            mid=rear;
            rear=mid->Next;
            mid->Next=front;
            front=mid;      
        }
        nhead=mid;
        L->Next=NULL;
        return nhead;
    }
}

使用三个中间变量front，mid，rear，完成箭头的调换。用front，mid将确定的节点箭头对调，用rear记录对调前mid->Next指向的节点指针。
进入循环时：

第一次循环结束：

第二次循环结束：

第三次循环结束：

第四次循环结束：

四次循环结束后退出循环。
最后将第一个节点指向下一节的指针改为空并返回mid所指指针即完成函数。
这种方法的时间复杂度为：T=O(n)
且可以通过控制循环体条件实现规避无需转置的节点，比第一种和第二种方法更加优异。且这种算法具有更广泛的运用，有时间我们再举例讨论。