链表逆序(递归实现和非递归实现)

最新推荐文章于 2024-09-19 14:52:21 发布
最新推荐文章于 2024-09-19 14:52:21 发布
阅读量278 收藏
点赞数
文章标签： 数据结构与算法 测试
原文链接：http://www.cnblogs.com/beyond-Acm/p/4415714.html
版权

链表逆序操作笔试的时候真的不要写的太多， 上次还来了个递归实现链表逆序。

就当利用这个题复习下单链表的常用操作了， 下面的单链表（ADT）参考了《数据结构和算法分析---C语言描述》中的写法， 稍有改动。

增加了一些自己觉得会经常用到的函数。链表的主要操作在 linklist.h 文件中， 链表函数的实现主要在 linklist.c 文件中。 test_linklist.c 是一个简单的测试用例。

下面再具体看看链表逆序函数的实现(非递归) ：

在函数ReverseList()当中， 定义了4个指针，

1.  pReversedList 指向反转以后的链表头 。

2.  pNode指向的是当前要反转的结点

3.  pPrev是指向的是要反转结点（pNode）的前一个结点（也就是已经反转好的链表的尾结点）

4.  pNext指向的是pNode的下一个结点。主要通过下面几条语句进行反转， 直到链表尾为止。

pNode->Next = pPrev;

pPrev = pNode;

pNode = pNext;

pNext = pNode->Next;

/*　　linklist.h　　*/

/***********************************************************/
/* Copyright (C) SA14226214, USTC, 2014-2015               */
/*                                                         */
/*  FILE NAME             :  linklist.h                       */
/*  PRINCIPAL AUTHOR      :  GaoZhipeng                    */
/*  SUBSYSTEM NAME        :  LinkList                      */
/*  MODULE NAME           :  LinkList                      */
/*  LANGUAGE              :  C                             */
/*  TARGET ENVIRONMENT    :  ANY                           */
/*  DATE OF FIRST RELEASE :  2015/04/13                    */
/*  DESCRIPTION           :  This is a linklist program    */
/***********************************************************/

/*
 *Revision log:
 *
 *Ceated by GaoZhipeng, 2015/04/13
 *     
 */


#ifndef LINK_LIST_H
#define LINK_LIST_H


#define ElementType char
#define boolean int
#define true 1
#define false 0

typedef struct Node
{
    ElementType Element;
    struct Node *Next;
}Node;

//typedef struct Node;
typedef struct Node *PtrToNode;
/*List是一个固定的链表，Position是链表中的位置可以移动 */
typedef PtrToNode List;
typedef PtrToNode Position;




List MakeEmpty(List L);
int IsEmpty(List L);
int IsLast(Position P, List L);
Position Find(ElementType X, List L);
//按照元素和位置查找
Position FindPreviousElement(ElementType X, List L);
Position FindPreviousPosition(int K, List L);
//插入删除操作
void DeleteByElement(ElementType X, List L);
Position DeleteByPosition(int i, List L);
Position InsertByPosition(ElementType X, int i, List L);

List CreateListR();
void PrintList(List L);
void DeleteList(List L);
/*链表逆序*/
List ReverseList(List L);
List ReverseList_DG(List L);
//Position Header(List L);
//Position First(List L);
//Posttion Advance(Position P);
//ElementType Retrieve(Position P);


#endif
View Code

/*　　linklist.c　　*/

/***********************************************************/
/* Copyright (C) SA14226214, USTC, 2014-2015               */
/*                                                         */
/*  FILE NAME             :  linklist.c                   */
/*  PRINCIPAL AUTHOR      :  GaoZhipeng                    */
/*  SUBSYSTEM NAME        :  LinkList                      */
/*  MODULE NAME           :  LinkList                      */
/*  LANGUAGE              :  C                             */
/*  TARGET ENVIRONMENT    :  ANY                           */
/*  DATE OF FIRST RELEASE :  2015/04/13                    */
/*  DESCRIPTION           :  This is a linklist program    */
/***********************************************************/

/*
 *Revision log:
 *
 *Ceated by GaoZhipeng, 2015/04/13
 *     
 */

#include<stdio.h>
#include<malloc.h>
#include"linklist.h"


List MakeEmpty(List L)
{
    List P = L;
    P->Next = NULL;
    return P;
}



boolean IsEmpty(List L) 
{
    Position P = L;
    if(P->Next == NULL) 
    {
        return true;
    }
    else return false;
}


boolean IsLast(Position P, List L) 
{
    Position p = P;
    if(p->Next == NULL) 
    {
        return true;
    }
    else
    {
        return false;
    }
}


Position Find(ElementType X, List L)
{
    Position p = L->Next;
    while(p != NULL && p->Element != X) 
    {
        p = p->Next;
    }
    return p;
}


/*按照值查找*/
Position FindPreviousElement(ElementType X, List L)
{
    Position p = L;
    while(p->Next != NULL && p->Element != X) 
    {
        p = p->Next;
    }
    return p;
}

/*按照序号查找*/
Position FindPreviousPosition(int K, List L)
{
    Position P = L;
    int i = 1;
    while(P != NULL && i<K )
    {
        P = P->Next;
        i++;
    }
    if(i == K) return P;
    else return NULL;
}

/*按照节点的值删除*/
void DeleteByElement(ElementType X, List L)
{
    Position P, TmpCell;
    P = FindPreviousElement(X, L);
    if( !IsLast(P, L) )
    {
        TmpCell = P->Next;
        P->Next = TmpCell->Next;
        free(TmpCell);
    }
}

/*删除第i个节点, i从1开始*/
Position DeleteByPosition(int i, List L)
{
    Position P, TmpCell;
    if(i==1)
    {
        TmpCell = L;
        if(L != NULL) L = L->Next;
        else return NULL;
        free(TmpCell);
        return L;
    }
    P = FindPreviousPosition(i-1, L);
    if(P==NULL) 
    {
        printf("第%d个节点不存在", i-1);
    }
    else if(P->Next == NULL)
    {    
        printf("第%d个节点不存在", i);
    }
    else 
    {
        TmpCell = P->Next;
        P->Next = TmpCell->Next;
        free(TmpCell);
        return P;
    }
}


/*插入到第i个位置，i从1开始*/
Position InsertByPosition(ElementType X, int i, List L)
{
    Position P, TmpCell;
    if( i==1 )
    {
        TmpCell = (Position)malloc(sizeof(Node));
        TmpCell->Element = X;
        TmpCell->Next= L;
        return TmpCell;
    }
    P = FindPreviousPosition(i-1, L);
    if(P == NULL)
    {
        printf("第%d个节点不存在", i-1);
        return NULL;
    }
    else 
    {
        TmpCell = (List)malloc(sizeof(Node));
        TmpCell->Element = X;
        TmpCell->Next = P->Next;
        P->Next = TmpCell;
        return TmpCell;
    }
}

/*删除整表*/
void DeleteList(List L)
{
    Position P, Tmp;
    P = L->Next;
    L->Next = NULL;
    while(P != NULL) 
    {
        Tmp = P->Next;
        free(P);
        P = Tmp;
    }
}

/*尾插法建表*/
List CreateListR()
{
    List Head, TmpCell, P;
    ElementType Tmp;
    Head = (List)malloc(sizeof(Node));
    P = Head;
    //假定输入以'$'符号结束
    Tmp = getchar();
    P->Element = Tmp;
    Tmp = getchar();
    while(Tmp != '$')
    {
        TmpCell = (Position)malloc(sizeof(Node));
        TmpCell->Element = Tmp;
        P->Next = TmpCell;
        P = TmpCell;
        Tmp = getchar();
    }
    P->Next = NULL;
    return Head;
}

void PrintList(List L)
{
    Position P = L;
    while(P != NULL) 
    {
        printf("%c", P->Element);
        if( !IsLast(P, L) ) 
        {    
            printf("---->");
        }
        P = P->Next;
    }
    printf("\n\n");
}


/*链表逆序(非递归实现)*/

List ReverseList(List L)
{
    List ReverseList = NULL;
    Position pNode = L;
    Position pPre = NULL;
    Position pNext ;

    while(pNode != NULL) 
    {
        pNext = pNode->Next;
        if(pNext == NULL) 
        {
            ReverseList = pNode;
        }
        pNode->Next = pPre;
        pPre = pNode;
        pNode = pNext;
    }
    return ReverseList;
}

/*链表逆序递归实现*/

List ReverseList_DG(Position Head)
{

    /*结束的条件:链表为空或者链表最后一个节点*/

    if(Head==NULL || Head->Next == NULL) 
    {
        return Head;
    }

    Position NewHead = ReverseList_DG(Head->Next);
    Head->Next->Next = Head;
    Head->Next = NULL;
    return NewHead;


}
View Code

/*　　test_linklist.c　　*/

/***********************************************************/
/* Copyright (C) SA14226214, USTC, 2014-2015               */
/*                                                         */
/*  FILE NAME             :  test_linklist.c           */
/*  PRINCIPAL AUTHOR      :  GaoZhipeng                    */
/*  SUBSYSTEM NAME        :  LinkList                      */
/*  MODULE NAME           :  LinkList                      */
/*  LANGUAGE              :  C                             */
/*  TARGET ENVIRONMENT    :  ANY                           */
/*  DATE OF FIRST RELEASE :  2015/04/13                    */
/*  DESCRIPTION           :  This is a linklist program    */
/***********************************************************/

/*
 *Revision log:
 *
 *Ceated by GaoZhipeng, 2015/04/13
 *     
 */

#include<stdio.h>
#include"linklist.h"

#define MaxData 65535

int main()
{
    ElementType Num;
    List L, R1, R2;
    printf("输入链表（字符），以'$'符号结束\n");
    
    L = CreateListR();
    PrintList(L);
    
    /*测试插入操作*/
    InsertByPosition('a', 7, L);
    PrintList(L);
    
    /*测试删除操作*/
    DeleteByPosition(7, L);
    PrintList(L);
    
    /*测试逆序操作*/
    R1 = ReverseList(L);
    PrintList(R1);

    /*测试递归逆序*/
    R2 = ReverseList_DG(R1);
    PrintList(R2);
}
View Code

/*　　makefile　　*/

#this is a makefile

all : test

test : test.o linklist.o 
    gcc $^ -o $@

test.o : test_linklist.c linklist.c linklist.h
    gcc -c test_linklist.c -o test.o

linklist.o : linklist.c linklist.h
    gcc -c linklist.c -o linklist.o

clean :
    -rm test *.o

.PHONY: clean
View Code


执行make，运行的结果如下所示 ：

转载于:https://www.cnblogs.com/beyond-Acm/p/4415714.html

dizhi3891
关注
简单的单链表逆序 非递归
04-05
本示例中的`reverse`函数清晰地展示了如何利用两个辅助指针来遍历并逆序单链表，为理解和实现类似算法提供了有价值的参考。掌握这种技巧对于深入学习数据结构和算法，特别是在面试和项目开发中，都将大有裨益。
单链表逆序--非递归算法
07-24 525
初始状态： prev = null; head = head; next = head.next;//保证不断链 开始逆序： head.next = prev;//不会断链，next保持在链上（最后一个节点指向null） prev = head; head = next;
单链表逆序
热门推荐
autumn20080101的专栏
05-27 7万+
2、 单链表逆序          第二个题目是很经典的“单链表逆序”问题。很多公司的面试题库中都有这道题，有的公司明确题目要求不能使用额外的节点存储空间，有的没有明确说明，但是如果面试者使用了额外的节点存储空间做中转，会得到一个比较低的分数。如何在不使用额外存储节点的情况下使一个单链表的所有节点逆序？我们先用迭代循环的思想来分析这个问题，链表的初始状态如图（1）所示： 图（1
关于链表逆序的（递归方法）
最新发布
2402_85360089的博客
09-19 219
以上我们创建了一个简单但函数还不是递归的。上述我们不可以从头开始，要从尾巴开始；这个时候需要递归一下到最后一个节点。有所不对还望指出，本文只写了此题递归的中心思想；还有前面的创建表，打印表等自己去尝试一下。这样其实代码已经完成了，但是还有一点个人之前不懂得（遇到的分析困难）这种情况我们又有东西没考虑周全。如果说他只有一个节点或者是空的；
逆置单链表——递归与非递归
Aa_lihua的博客
08-14 3194
文章目录前言方式一:非递归原理图解实现代码方式二:递归原理图解实现代码完整实现代码运行结果 前言 单链表的逆置图解 方式一:非递归 原理 非递归逆置单链表的本质是创建一个新的链表，遍历原先的链表，利用头插法将节点插入新的链表当中去。 图解 实现代码 //链表节点定义 typedef struct link_list{ int data; struct link_list *next; }singel_link_t; /************************************
2-6 链表逆序及其C++实现
朝花&夕拾
06-21 873
更多系列博文请点击：0-数据结构与算法链接目录 2-6 链表逆序 我只介绍两种常用方法吧，非递归方法 和 递归 方法 我觉得够用就行 1、非递归方法： 将第二个元素后面的元素依次插入到头结点后面， 最后再把原始第一个元素放到原始第二个元素后面，整个链表就能够反转了 这个方法对于带不带头结点的链表都适用： ①不带头结点 原始链表，其中第二个元素是 B A ->...
【数据结构】链表逆序
weixin_56213139的博客
07-09 386
逆序链表的一种算法介绍
链表反序/逆序，递归&非递归
09-15
链表反序/逆序，递归和非递归写法
快速排序的非递归算法.doc
05-26
非递归版本的快速排序则是不使用递归实现这一算法。 在给定的文档中，`quickpass` 函数实现了快速排序的主要逻辑，即“主元交换”（partition）过程。`quicksort` 函数则负责整体的控制，包括栈的管理以及主元交换...
单链表的合并（递归-非递归）以及将单链表逆序
05-09
单链表的合并可以使用非递归方式实现，利用一个辅助指针来存储当前节点的前一个节点，然后将当前节点插入到合并后的链表中。具体实现步骤如下： 1. 设定两个单链表 head1 和 head2，其中 head1 和 head2 是有序升序...
递归.pptx
12-21
- **非递归思路**：使用栈模拟递归的过程，通过控制节点的入栈和出栈顺序来实现不同遍历方式。 ### 总结 递归作为一种强大的编程技术，在处理具有自相似性的数据结构时非常有效。本文介绍了递归的基本概念、在树和...
必会算法之链表逆序
qq_46138057的博客
08-06 184
先简单说一下链表的特点： 链表在空间上不是连续的 每存放一个值，都要多开销一个引用空间(即next) 每一个节点都认为自己是根节点 只要内存足够大，就能存的下，不用担心空间碎片的问题（数组就必须需要一整个连续的空间来存储） 链表逆序 思路：改变next的指向 （1）先定义一个链表： function Node(value){ this.value = value; this.next = null; } let node1 = new Node(1); let node2 = new N
Linux学习——数据结构之单链表
qq_52479948的博客
10-22 806
Linux中用C实现单链表
链表逆序输出（递归妙）
低调的旋律
12-26 1189
四种方式实现--从尾到头输出链表 　　方法一：借用栈倒序输出链表 　　方法二：先翻转链表，再顺序输出 　　方法三：递归实现，一个字妙，两个字很妙，三个字太妙了 　　方法四：用数组实现 　　方法一：借用栈倒序输出链表   　　　　　 因为栈是先进后出，把链表中的元素存进栈中，链表前面的元素在栈底，后面的元素在栈顶，链表后面的元素先出栈 　　方法二：先翻转链表，再
链表逆序的三大方法（Python实现）
qq_43300880的博客
05-07 2983
链表逆序的三大方法 更多文章代码详情，可以查看博主： GitHub地址：https://github.com/TheAlgorithm-SimpleChinese/Python 个人网站：https://www.iwtmbtly.com 假设给定一个带头结点的单链表，要将其逆序。 即如果单链表原来为head->1->2->3->4->5->6->7，那么逆序后变为 head->7->6->5->4->3->2->1。 有什
用递归实现链表逆序
rckxzj的博客
02-22 754
自定义链表类型： /** * 自定义链表，用于ListReverse.java——链表逆序 * @author ZJ * */ public class MyList { int data; MyList next; MyList(int data, MyList next){ this.data = data; this.next = next; } } 程序...
大厂面试算法系列-如何实现链表的逆序(二)-递归法
初学者
12-26 2209
导语   接着上次的内容，上次博客中展示了原地进行单链表的逆序操作，当然除了原地逆序还可以通过递归的方式进行调用操作。下面就来看看通过递归的方式如何进行单链表的逆序操作。 递归法逆序链表   假定原来的链表为1->2->3->5->4->7,递归的思路，首先就是将除了第一个节点以外的节点先进行逆序，然后将第一个节点添加到逆序的子链表后面。同理要逆序第二个节点，就需要将除了第一个节点以外的链表先进行逆序。通过这种方式就可以实现链表的完全逆序了。 第一次递归 第二次递归  .
实现链表的逆序的三种方式
Lud的博客
09-24 1万+
文章目录问题分析方法一：就地逆序方法二：递归法方法三：插入法 问题 给定一个带头节点的单链表，将其逆序。head->1->2->3->4->5->6->7变为 head->7->6->5->4->3->2->1。 分析 单链表与数组不同，单链表中每个节点的地址都存储在其前驱节点的指针域中，因此对链表中任何一个节...
链表反转 - 递归
人生一世 草木一秋
08-13 323
递归实现 链表反转(逆序)
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值