单链表实现就地逆转

在这里，我将展示用头插法的方法实现链表的就地逆转。原理是对于一个给定的链表，先将其头结点摘出来，接下来，依次将链表中的结点摘出来，用头插法插入到摘出来的头结点之后，直到将所有的结点都插入，那么就实现了链表的就地逆转。下面给的程序是c语言程序，可以在gcc里面运行出来。并且有详细的注释，因而在这儿就不再赘述类，看下面的程序。
注意：a.txt文件中的内容就是我们要逆转的数据，要跟我们的.c文件放在一起，否则就要将路径完整写出！！！

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

//操作状态
#define TRUE    1
#define FALSE   0
#define OK      1
#define ERROR   0
//=====================================================

// 操作状态类型
typedef int Status;

// 数据元素类型
typedef int ElemType;
//=====================================================

// 结点类型
typedef struct tag_LNode{ 
   int          data;
   struct tag_LNode *next;
}LNode;
//=====================================================

// 链表类型（带头结点的单链表）
typedef struct {
   int      lenth;              // 指示链表长度
   LNode    *head;              // 分别指向头结点和最后一个结点的指针
   LNode    *current;           // 指向当前被访问的结点的指针，初始位置指向头结点
} LinkList;
//=====================================================

//构造一个空的线性表L
Status InitList(LinkList *L)        
{
    L->head = (LNode *)malloc(sizeof(LNode));//开辟一个新的空间
    if(!L->head) return ERROR;  //空间开辟不成功
    L->head->next = NULL;       //初始化线性表L
    L->lenth = 0;
    L->current = L->head;
    return OK;
}
//=====================================================

//销毁线性表L
void DestroyList(LinkList *L)   //销毁线性表 L
{
    LNode *p;
    p = L->head;                //p指向表头
    while(p)                    //依次从表头开始删除每一个结点
    {
        L->head = L->head->next;//摘出p
        free(p);                //删除p
        p = L->head;            //又将p指向表头
    }
}
//=====================================================

//清空线性表的元素
void ClearList(LinkList  *L)
{
    LNode *p;
    while(L->head->next)        //删除除了表头的所有结点
    {
        p = L->head->next;      //p指向表头的下一个结点
        L->head->next = p->next;//摘出结点p
        free(p);                //删除p
    }
}
//=====================================================

// 改变当前指针指向第i个结点
Status LocatePos(LinkList *L, int i )
{
    int k;
    k = 0;
    L->current = L->head;       //初始化当前指针指向头指针处
    while(L->current->next && k < i)//移动当前指针，直到指向第i个位置结束
    {
        L->current = L->current->next;
        k++;
    }
    if(k != i) return ERROR;    
    return OK;
}
//=====================================================

//在当前位置之后插入数据元素e
Status InsertAfter(LinkList *L, ElemType e)
{
    LNode *s;
    if(!L->current) return ERROR;//当前指针为空，就返回错误 
    s = (LNode *)malloc(sizeof(LNode));//给s开辟新空间
    if(!s) return ERROR;         //s开辟空间失败  
    s->data = e;                 //将e赋给s->data
        if(L->current->next == NULL)//如果当前指针是最后一个，那么直接插入到最后即可
        L->current->next = s;
    else                        //当前指针不在最后时，我们就在当前指针之后插入
    {
        s->next = L->current->next;
        L->current->next = s;
    }
    L->lenth++;                 //插入一个结点后，表的长度要加1
    return OK;
}
//=====================================================

//在表头插入数据元素e
Status InsertHead(LinkList *L,  ElemType e)
{
    LNode *p;
    p = (LNode *)malloc(sizeof(LNode));//给p开辟新空间
    if(!p) return ERROR;        //p开辟空间失败   
    p->data = e;                //将e赋给p->data
    p->next = NULL;
    p->next = L->head->next;    //在表头插入结点p
    L->head->next = p;
    L->lenth++;
    return OK;
}
//=====================================================

//输出单链表的数据
void PrintOut(LinkList L)
{
    LNode *p;
    printf("链表有%d个元素：",L.lenth);
    p = L.head->next;
    while(p)                   //当p非空时，输出p的数据值
    {
        printf("%d ", p->data);     
        p = p->next;
    }
}
//=====================================================

//在表中查找数据元素e，让当前指针(current)指向该结点
Status LocateElem(LinkList *L, ElemType e)
{
    LNode *p;
    p = L->head->next;
    while(p)
    {
      if(p->data == e)        //依次判定该结点的数据是不是e
      {
          L->current = p;     //将当前指针指向p    
          return OK;
      }
          p = p->next;
    }
    return ERROR;
}
//=====================================================

//求线性表的长度
int ListLenth(LinkList L)
{
    return L.lenth;           //直接返回线性表L的长度即可
}
//=====================================================

//线性表就地逆转(前插法)
void ListReverse(LinkList *L)
{
    LNode *p,*q;
    p = L->head->next;        //p指向表头的下一个结点
    L->head->next = NULL;     //摘出表头
    while(p)                  //依次用前插法插入结点
    {
        q = p->next;          //q指向p的下一个结点，将p摘出来
        p->next = L->head->next;//将摘出来的p出入到表头的后面
        L->head->next = p;
        p = q;                //将p指向q指向的位置
    }
}
//=====================================================

int main(int argc,char* argv)
{
    FILE *fp;                 //文件指针
    LinkList L;               //线性表
    ElemType e;
    int j;                    //j作为后面选项的变量
    int i = 1;                //i作为while循环的判定变量
    if((fp = fopen("a.txt", "r")) == 0)//打开文件“a.txt”，r表示可读的意思
    {
        printf("打开文件失败");
        return -1;
    }
    if(!InitList(&L))         //初始化链表L
    {
        printf("初始化链表失败\n");
        return -2;
    }
    LocatePos(&L, 0);         //改变当前指针指向表的头结点
    while(1)                  //读入数据并插入到表中
    {
        if(fscanf(fp, "%d", &e) == EOF)//文件中的数据读数据到单链表L,知道读到文件最后，再跳出while循环,EOF是end of file 的意思
            break;
        InsertAfter(&L, e);
    }
    while(i)
    {
        printf("1.查看原始链表中的数据\n");
        printf("2.输出链表长度\n");
        printf("3.查找链表中的元素\n");
        printf("4.逆转该链表，并输出逆转后的数据\n");
        printf("5.销毁链表\n");
        printf("0.退出！\n");
        printf("选择你要进行的操作\n");
        scanf("%d", &j);      //输入选项
        printf("\n");
        switch(j)             //使用了switch-case来对选择不同的选项进行不同的操作  
        {
            case 1:           //输出单链表L的数据
                printf("\n原始链表\n");
                PrintOut(L);  //输出原始链表中的数据
                printf("\n\n");
                break;
            case 2:           //链表长度
                printf("链表长度：%d\n", ListLenth(L));//调用了链表长度的函数
                printf("\n");
                break;
            case 3:           //查找链表元素
                printf("输入要查找的数: ");
                scanf("%d", &e);
                if(LocateElem(&L, e))//LocateElem(&L,e)是调用定位函数，将当前指针定位到元素e的位置
                    printf("元素%d在链表中\n", L.current->data);
                else
                    printf("元素%d不在链表中\n", e);
                printf("\n");
                break;
            case 4:           //链表就地逆转
                printf("\n原始链表\n");
                PrintOut(L);  //输出原始链表里面的元素
                printf("\n\n");
                ListReverse(&L);//调用逆转链表的函数
                printf("\n逆转链表\n");
                PrintOut(L);
                printf("\n\n");
                break;
            case 5:           //销毁链表L
                DestroyList(&L);//调用销毁链表的函数
                printf("\n");
                break;
            case 0:
                printf("\n结束!\n");
                    i = 0;    //i = 0使得跳出整个while循环，结束程序
                    printf("\n");     
        }
    }

    return 0;
}

---