码迷，mamicode.com
首页 > 其他好文 > 详细

单链表反转

时间：2016-10-05 19:39:26      阅读：116      评论：0      收藏：0      [点我收藏+]

标签：

一. 先画一个单链表，这个单链表有4个元素。思路就是，每次把第二个元素提到最前面来。比如下面是第一次交换，我们先让头结点的next域指向结点a2，再让结点a1的next域指向结点a3，最后将结点a2的next域指向结点a1，就完成了第一次交换。

技术分享

第一次交换

然后进行相同的交换将结点a3移动到结点a2的前面，然后再将结点a4移动到结点a3的前面就完成了反转。

技术分享

 第二次交换

技术分享

 第三次交换

思路1：

这里我们需要额外的两个工作指针来辅助交换。这个下面的步骤慢慢理解下，结合图片。注意结点之间的关系要先断再连。

步骤：

  1. 定义当前结点 current，初始值为首元结点，current = L->next;
  2. 定义当前结点的后继结点 pnext， pnext = current->next; 
  3. 只要 pnext 存在，就执行以下循环：
    • 定义新节点 prev，它是 pnext的后继结点，prev = pnext->next;
    • 把pnext的后继指向current, pnext->next = current;
    • 此时，pnext 实际上已经到了 current 前一位成为新的current，所以这个时候 current 结点实际上成为新的 pnext，current = pnext;
    • 此时，新的 current 就是 pnext，current = pnext;
    • 而新的 pnext 就是 prev，pnext = prev;
  4. 最后将头结点与 current 重新连上即可，L->next = current;

函数设计如下：

技术分享 
/* 单链表反转/逆序 */
LinkList ListReverse(LinkList L)
{
    LinkList current,pnext,prev;
    if(L == NULL || L->next == NULL)
        return L;
    current = L->next;  /* p1指向链表头节点的下一个节点 */
    pnext = current->next;
    current->next = NULL;
    while(pnext)
    {
        prev = pnext->next;
        pnext->next = current;
        current = pnext;
        pnext = prev;
    }
    //printf("current = %d,next = %d \n",current->data,current->next->data);
    L->next = current;  /* 将链表头节点指向p1 */
    return L;
}
View Code

思路2：

不同于思路一的current一直是表的第一个结点，这里的current始终是首元结点的值，函数需要每次对pnext重新赋值。先将current指向prev，再将pnext指向current，最后将头结点指向pnext。

步骤如下：

  1. p = current->next; p 就相当于前面的 pnext。（图1中a2即为p）
  2. current->next = p->next; p->next 就相当于 prev的角色，这句代码意思是 current 的后继指向 prev.（相当于图1中a1->next = a3(a2->next)）
  3. p->next = L->next; 这句就是 p 的后继直接指向首元节点。（相当于图1中a2->next = a1）
  4. L->next = p; 然后再将头结点指向 p。（相当于图1中L->next = a2）

代码如下：

技术分享 
LinkList ListReverse2(LinkList L)
{
    LinkList current, p;

    if (L == NULL)
    {
        return NULL;
    }
    current = L->next;
    while (current->next != NULL)
    {
        p = current->next;
        current->next = p->next;
        p->next = L->next;
        L->next = p;
        ListTraverse(L);
        printf("current = %d, \n", current -> data);
    }
    return L;
}
View Code

以下代码是模仿思路2自己实现的：

技术分享 
LinkList ListReverse4(LinkList L){ //4为模仿2的思想自己实现的算法
    LinkList current,p;
    if(!L || !L->next){
        return L;
    }
    current = L->next;
    p = current->next;
    while(p){
        current->next = p->next;
        p->next = L->next;
        L->next = p;
        p = current->next;
    }
    return L;
}
View Code

二、最后附上完整代码，反转有两个函数。

  • 方法1，current始终保持在第一位，pnext与prev遍历并完成交换。
  • 方法2，current始终是原链表的第一个数，然后把pnext不断移动到首位。
技术分享 
// 单链表转置.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include<iostream>
#include<time.h>

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 20 /* 存储空间初始分配量 */

using namespace std;

typedef int Status;/* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int ElemType;/* ElemType类型根据实际情况而定，这里假设为int */

typedef struct Node
{
    ElemType data;
    struct Node *next;
}Node;
/* 定义LinkList */
typedef struct Node *LinkList;

/* 初始化顺序线性表 */
Status InitList(LinkList *L) //涉及到创建链表的必须用二级指针
{
    (*L)=(LinkList)malloc(sizeof(Node)); /* 产生头结点,并使L指向此头结点 */
    if(!(*L)) /* 存储分配失败 */
    {
        return ERROR;
    }
    (*L)->next=NULL; /* 指针域为空 */

    return OK;
}

/* 初始条件：顺序线性表L已存在。操作结果：返回L中数据元素个数 */
int ListLength(LinkList L)
{
    int i=0;
    LinkList p = L->next; /* p指向第一个结点 */
    while(p)
    {
        i++;
        p=p->next;
    }
    return i;
}

/* 初始条件：顺序线性表L已存在。操作结果：将L重置为空表 */
Status ClearList(LinkList L)
{
    LinkList p,q;
    p = L->next;           /*  p指向第一个结点 */
    while(p)                /*  没到表尾 */
    {
        q=p->next;
        free(p);
        p=q;
    }
    L->next = NULL;        /* 头结点指针域为空 */
    return OK;
}

Status visit(ElemType c)
{
    printf("-> %d ",c);
    return OK;
}

/* 初始条件：顺序线性表L已存在 */
/* 操作结果：依次对L的每个数据元素输出 */
Status ListTraverse(LinkList L)
{
    LinkList p=L->next;
    while(p)
    {
        visit(p->data);
        p=p->next;
    }
    printf("\n");
    return OK;
}

/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：用e返回L中第i个数据元素的值 */
Status GetElem(LinkList L,int i,ElemType *e)
{
    int j;
    LinkList p;        /* 声明一结点p */
    p = L->next;        /* 让p指向链表L的第一个结点 */
    j = 1;        /*  j为计数器 */
    while (p && j < i)  /* p不为空或者计数器j还没有等于i时，循环继续 */
    {
        p = p->next;  /* 让p指向下一个结点 */
        ++j;
    }
    if ( !p || j>i )
        return ERROR;  /*  第i个元素不存在 */
    *e = p->data;   /*  取第i个元素的数据 */
    return OK;
}

/* 初始条件：顺序线性表L已存在 */
/* 操作结果：返回L中第1个与e满足关系的数据元素的位序。 */
/* 若这样的数据元素不存在，则返回值为0 */
int LocateElem(LinkList L,ElemType e)
{
    int i=0;
    LinkList p=L->next;
    while(p)
    {
        i++;
        if(p->data==e) /* 找到这样的数据元素 */
                return i;
        p=p->next;
    }

    return 0;
}

/*  随机产生n个元素的值，建立带表头结点的单链线性表L（头插法） */
void CreateListHead(LinkList *L, int n)  //涉及到创建链表的必须用二级指针
{
    LinkList p;
    int i;
    srand(time(0));                         /* 初始化随机数种子 */
    (*L) = (LinkList)malloc(sizeof(Node));
    (*L)->next = NULL;                      /*  先建立一个带头结点的单链表 */
    for (i=0; i < n; i++)
    {
        p = (LinkList)malloc(sizeof(Node)); /*  生成新结点 */
        p->data = rand()%100+1;             /*  随机生成100以内的数字 */
        p->next = (*L)->next;
        (*L)->next = p;                        /*  插入到表头 */
    }
}

/*  随机产生n个元素的值，建立带表头结点的单链线性表L（尾插法） */
void CreateListTail(LinkList *L, int n) //涉及到创建链表的必须用二级指针
{
    LinkList p,r;
    int i;
    srand(time(0));                      /* 初始化随机数种子 */
    (*L) = (LinkList)malloc(sizeof(Node)); /* L为整个线性表 */
    r = *L;                                /* r为指向尾部的结点 */
    for (i=0; i < n; i++)
    {
        p = (Node *)malloc(sizeof(Node)); /*  生成新结点 */
        p->data = rand()%100+1;           /*  随机生成100以内的数字 */
        r->next=p;                        /* 将表尾终端结点的指针指向新结点 */
        r = p;                            /* 将当前的新结点定义为表尾终端结点 */
    }
    r->next = NULL;                       /* 表示当前链表结束 */
}

/* 初始条件：顺序线性表L已存在,1≤i≤ListLength(L)， */
/* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
Status ListInsert(LinkList L,int i,ElemType e)  //此时可以不用二级指针
{
    int j;
    LinkList p,s;
    p = L;     /* 声明一个结点 p，指向头结点 */
    j = 1;
    while (p && j < i)     /* 寻找第i个结点 */
    {
        p = p->next;
        ++j;
    }
    if (!p || j > i)
        return ERROR;   /* 第i个元素不存在 */
    s = (LinkList)malloc(sizeof(Node));  /*  生成新结点(C语言标准函数) */
    s->data = e;
    s->next = p->next;      /* 将p的后继结点赋值给s的后继  */
    p->next = s;          /* 将s赋值给p的后继 */
    return OK;
}

/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */
Status ListDelete(LinkList L,int i,ElemType *e)  //此时可以不用二级指针
{
    int j;
    LinkList p,q;
    p = L;
    j = 1;
    while (p->next && j < i)    /* 遍历寻找第i个元素 */
    {
        p = p->next;
        ++j;
    }
    if (!(p->next) || j > i)
        return ERROR;           /* 第i个元素不存在 */
    q = p->next;
    p->next = q->next;            /* 将q的后继赋值给p的后继 */
    *e = q->data;               /* 将q结点中的数据给e */
    free(q);                    /* 让系统回收此结点，释放内存 */
    return OK;
}

/* 单链表反转/逆序 */
LinkList ListReverse(LinkList L)
{
    LinkList current,pnext,prev;
    if(L == NULL || L->next == NULL)
        return L;
    current = L->next;  /* p1指向链表头节点的下一个节点 */
    pnext = current->next;
    current->next = NULL;
    while(pnext)
    {
        prev = pnext->next;
        pnext->next = current;
        current = pnext;
        pnext = prev;
    }
    //printf("current = %d,next = %d \n",current->data,current->next->data);
    L->next = current;  /* 将链表头节点指向p1 */
    return L;
}

LinkList ListReverse2(LinkList L)
{
    LinkList current, p;

    if (L == NULL)
    {
        return NULL;
    }
    current = L->next;
    while (current->next != NULL)
    {
        p = current->next;
        current->next = p->next;
        p->next = L->next;
        L->next = p;
        ListTraverse(L);
        printf("current = %d, \n", current -> data);
    }
    return L;
}

LinkList ListReverse4(LinkList L){ //4为模仿2的思想自己实现的算法
    LinkList current,p;
    if(!L || !L->next){
        return L;
    }
    current = L->next;
    p = current->next;
    while(p){
        current->next = p->next;
        p->next = L->next;
        L->next = p;
        p = current->next;
    }
    return L;
}
int main(int argc, char * argv[])
{
    LinkList L = NULL;
    Status i;
    int j,k,pos,value;
    char opp = NULL;
    ElemType e;

    i=InitList(&L);
    printf("链表L初始化完毕，ListLength(L)=%d\n",ListLength(L));

    printf("\n1.整表创建（头插法） \n2.整表创建（尾插法） \n3.遍历操作 \n4.插入操作");
    printf("\n5.删除操作 \n6.获取结点数据 \n7.查找某个数是否在链表中 \n8.置空链表");
    printf("\n9.链表反转逆序");
    printf("\n0.退出 \n请选择你的操作：\n");
    while(opp != ‘0‘){
        scanf("%c",&opp);
        switch(opp){
            case ‘1‘:
                CreateListHead(&L,10);
                printf("整体创建L的元素(头插法)：\n");
                ListTraverse(L);
                printf("\n");
                break;

            case ‘2‘:
                CreateListTail(&L,10);
                printf("整体创建L的元素(尾插法)：\n");
                ListTraverse(L);
                printf("\n");
                break;

            case ‘3‘:
                ListTraverse(L);
                printf("\n");
                break;

            case ‘4‘:
                printf("要在第几个位置插入元素？");
                scanf("%d",&pos);
                printf("插入的元素值是多少？");
                scanf("%d",&value);
                ListInsert(L,pos,value);
                ListTraverse(L);
                printf("\n");
                break;

            case ‘5‘:
                printf("要删除第几个元素？");
                scanf("%d",&pos);
                ListDelete(L,pos,&e);
                printf("删除第%d个元素成功，现在链表为：\n", pos);
                ListTraverse(L);
                printf("\n");
                break;

            case ‘6‘:
                printf("你需要获取第几个元素？");
                scanf("%d",&pos);
                GetElem(L,pos,&e);
                printf("第%d个元素的值为：%d\n", pos, e);
                printf("\n");
                break;

            case ‘7‘:
                printf("输入你需要查找的数：");
                scanf("%d",&pos);
                k=LocateElem(L,pos);
                if(k)
                    printf("第%d个元素的值为%d\n",k,pos);
                else
                    printf("没有值为%d的元素\n",pos);
                printf("\n");
                break;

            case ‘8‘:
                i=ClearList(L);
                printf("\n清空L后：ListLength(L)=%d\n",ListLength(L));
                ListTraverse(L);
                printf("\n");
                break;

            case ‘9‘:
                ListReverse4(L);
                printf("\n反转L后\n");
                ListTraverse(L);
                printf("\n");
                break;

            case ‘0‘:
                exit(0);
        }
    }
    system("pause");
    return 0;
}
View Code

 本文参考：http://www.nowamagic.net/librarys/veda/detail/2241

单链表反转

标签：

原文地址：http://www.cnblogs.com/tianyalu/p/5932510.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！