链表练习：使用递归重写单链表

最新推荐文章于 2023-10-28 10:17:08 发布
最新推荐文章于 2023-10-28 10:17:08 发布
阅读量607 收藏 4
点赞数 2
分类专栏： 数据结构 文章标签： 单链表 数据结构 链表 递归法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014799564/article/details/105678441
版权

本次的练习是使用递归来实现单链表的各种操作，本文目录如下

目录

定义链表结点

递归销毁

递归输出

递归尾插

尾部插入（Java写法）

尾部插入（C++写法）

递归在指定位置插入

递归删除值为x的结点

本文完整代码

结束语

 

定义链表结点

首先要定义数据结构，定义一下构造函数方便后面写码：

struct Node
{
    int data;
    Node *next;
    Node(int d = -1, Node *nn = NULL) : data(d), next(nn) {}
};

这里有个技巧，构造函数的参数我一般会把next结点放在后面，因为这样可以直接只传一个值data来构造新结点，next默认为NULL， 而据我的经验，直接使用一个data值构造新Node的情况比较多，同时因为设置了默认参数的缘故，也可以直接无参new Node()。

 

递归销毁

递归销毁和二叉树的后序遍历的思想差不多，都是先递归调用再销毁自己，这样会在递归调用到底部之后，从尾到头回溯地delete每个结点。实现代码如下：

void destroy(Node *p)
{
    if (!p)
        return;
    destroy(p->next);
    delete p;
}

顺带一提，delete一个NULL的指针是没什么问题的，C++标准有规定，这里开头需要判NULL的原因是后面需要访问p->next，如果此时p为NULL的话，p->next会直接段错误。

 

递归输出

void print(Node *p)
{
    if (!p)
        return;
    cout << p->data << " ";
    print(p->next);
}

与递归销毁不同的是，这里需要先输出再递归调用才是正序输出（即从头到尾），否则将会逆序输出（即从尾到头输出），除此之外，如果链表有头结点的话，需要传头结点的下一个结点进去才能正常输出，否则会一并输出头节点。

输出后不带换行。

 

递归尾插

这里分两种插入，一是插入到尾部，二是插入到指定顺序。遗憾的是，好像并不能统一成一个函数

 

尾部插入（Java写法）

Java没有指针的引用这种东西，但是C++可以用指针的引用来简化这个递归写法，所以我在这里分成两个写法。但是不管是Java写法还是C++写法，其实都是使用的C++，只不过Java写法将指针改为Java里的引用就可以变成真正的Java写法，而C++写法则是使用了一些C++的特性。

代码：

Node *TailInsertion(Node *p, int data)
{
    if (!p)
        return new Node(data);
    else
        p->next = TailInsertion(p->next, data);
    return p;
}

分三个步骤理解：

  1. 递归的终止条件就是遇到一个传进来是NULL的指针，意味着递归到了尾结点的next位置，那么此时就是要添加结点的时候了，Java版的写法是利用返回值，此时返回一个新的结点作为插入的尾结点。
  2. 但是新插入的尾结点怎么挂到链表上去？这里就要看函数里的else分支了，else分支里接收递归调用的返回值复制给p->next，这样假设现在递归到最后一个结点了，p指向最后一个结点，那么else分支里递归调用传进去的p->next就是NULL（尾结点的next肯定为NULL），传进去NULL根据我们的递归终止条件，此时会返回一个新的结点，那么就刚好接收作为尾结点的next。
  3. 那现在不是递归到尾结点，而是中间结点，怎么保证这种修改p->next的写法不会断链表？这个时候就得看函数的底部的返回值，在处理完函数头部的if分支后直接原样得返回p，这样就会返回到上一级递归调用的else分支，而else分支里是这样写的：p->next = TailInsertion(p->next, data)，对于中间结点来说，就等于p->next = p->next，当然不会断链。

 

TailInsertion的函数作用是传进去一个链表的头结点，返回插入尾结点后的链表，听起来比较难理解，但是当你结合这个函数的作用来理解函数里面递归调用的地方就不难理解了。可以说这种写法是一种比较 “正统” 的递归写法，因为按递归定义来说，其实这个函数符合递归的定义：链表的一部分也是一个链表，即是以结点p为首的链表是一个链表，同样以p->next结点为首的链表也同样是个链表。

不管怎么样，初学者还是要多写多练多思考才能彻底掌握递归。

 

尾部插入（C++写法）

利用C++里指针的引用，可以写出更加简化的代码，但是也比较难以理解，需要读者对C++指针、引用理解得很透彻才能掌握。

代码：

void TailInsertion2(Node *&p, int data)
{
    if (!p)
        p = new Node(data);
    else
        TailInsertion2(p->next, data);
}

注意，函数参数p是一个指针的引用，利用此特性可以免去返回值，直接定义成void返回值。

说说为什么可以这样写。其实这个指针的引用，就相当于是个二级指针，假设现在有个链表：

header-> 1 -> 2 -> 3 -> 4 -> 5 -> NULL

假设当前函数递归到结点3的位置，也就是函数参数p传进来的是指向结点3的指针，此时对指针p解引用会得到结点3，但是如果我们修改p，将会修改结点2的next指针，因为在函数递归到结点2的时候，在else分支将结点2的next作为参数递归调用，所以递归到结点3的时候，参数传进来的引用其实是结点2的next指针，根据引用的特性，修改它自然也就修改了上一个结点的next。按照这个规则，当函数递归到NULL的时候，p这个指针本身是结点5的next指针，只是它指向NULL而已。

这个写法确实难理解得多，还是得多写多练多思考才能掌握。

 

递归在指定位置插入

Java写法的实现代码：

Node *insert(Node *p, int index, int data)
{
    if (!p)
        return NULL;
    if (index == 0)
        return new Node(data, p);
    else
        p->next = insert(p->next, index - 1, data);
    return p;
}

每次递归的时候将index减1，并判断index为0时插入，即可实现指定递归位置插入且不需要外部变量辅助。要注意的是在index为0的时候new的结点是要把p作为该结点的next传进去构造的，否则会断掉后面的链，并且这种插入方法只支持在头部和中间插入，不能在尾部插入。但是这个算法的鲁棒性还是很好的，即使你index传的是负数或是超出链表长度的数，这个函数就会在递归遍历完链表后返回，什么都不会发生。

写个main函数测试一下：

int main()
{
    Node *header = new Node;

    for (int i = 1; i <= 10; ++i)
        TailInsertion(header, i);

    cout << "origin linkedlist:" << endl;
    print(header->next);
    cout << endl;

    cout << "mid insertion:" << endl;
    insert(header, 5, 99);
    print(header->next);
    cout << endl;

    cout << "head insertion:" << endl;
    insert(header, 1, 88);
    print(header->next);
    cout << endl;

    cout << "illeage insertion:" << endl;
    insert(header, 50, 77);
    print(header->next);
    cout << endl;

    cout << "illeage insertion2:" << endl;
    insert(header, -5, 77);
    print(header->next);
    cout << endl;
    
    destroy(header);
    return 0;
}

输出：

origin linkedlist:
1 2 3 4 5 6 7 8 9 10
mid insertion:
1 2 3 4 99 5 6 7 8 9 10
head insertion:
88 1 2 3 4 99 5 6 7 8 9 10
illeage insertion:
88 1 2 3 4 99 5 6 7 8 9 10
illeage insertion2:
88 1 2 3 4 99 5 6 7 8 9 10

附一个C++指针引用的版本：

void insert2(Node *&p, int index, int data)
{
    if (!p)
        return;
    if (index == 0)
        p = new Node(data, p);
    else
        insert2(p->next, index - 1, data);
}

 

递归删除值为x的结点

原理和上文指定位置插入差不多，只不过new结点变成了delete结点，C++指针引用的实现：

void delNode2(Node *&p, int x)
{
    if (!p)
        return;
    if (p->data == x)
    {
        Node *tmp = p->next;
        delete p;
        p = tmp;
    }
    else
        delNode2(p->next, x);
}

当匹配到当前结点的值与x相同时，直接删除当前结点并返回当前结点的下一个结点。

Java版：

Node *delNode(Node *p, int x)
{
    if (!p)
        return NULL;
    if (p->data == x)
    {
        Node *ret = p->next;
        delete p;
        return ret;
    }
    else
        p->next = delNode(p->next, x);
    return p;
}

要注意不管哪个版本，如果链表带有头结点的话一定得传头结点的下一个结点，像这样 delNode(header->next,5) ，否则头结点的值也会被判断，如果头结点的值刚好与x相同头结点就会被删掉。

 

本文完整代码

测试代码并没写完整，就不给出了，可以自己写点代码测试测试。

#include <iostream>
#include <algorithm>

using namespace std;

struct Node
{
    int data;
    Node *next;
    Node(int d = -1, Node *nn = NULL) : data(d), next(nn) {}
};

void destroy(Node *p)
{
    if (!p)
        return;
    destroy(p->next);
    delete p;
}

void print(Node *p)
{
    if (!p)
        return;
    cout << p->data << " ";
    print(p->next);
}

Node *TailInsertion(Node *p, int data)
{
    if (!p)
        return new Node(data);
    else
        p->next = TailInsertion(p->next, data);
    return p;
}

void TailInsertion2(Node *&p, int data)
{
    if (!p)
        p = new Node(data);
    else
        TailInsertion2(p->next, data);
}

Node *insert(Node *p, int index, int data)
{
    if (!p)
        return NULL;
    if (index == 0)
        return new Node(data, p);
    else
        p->next = insert(p->next, index - 1, data);
    return p;
}

void insert2(Node *&p, int index, int data)
{
    if (!p)
        return;
    if (index == 0)
        p = new Node(data, p);
    else
        insert2(p->next, index - 1, data);
}

void delNode2(Node *&p, int x)
{
    if (!p)
        return;
    if (p->data == x)
    {
        Node *tmp = p->next;
        delete p;
        p = tmp;
    }
    else
        delNode2(p->next, x);
}

Node *delNode(Node *p, int x)
{
    if (!p)
        return NULL;
    if (p->data == x)
    {
        Node *ret = p->next;
        delete p;
        return ret;
    }
    else
        p->next = delNode(p->next, x);
    return p;
}

int main()
{

    Node *header = new Node;

    for (int i = 1; i <= 10; ++i)
        TailInsertion(header, i);

    cout << "origin linkedlist:" << endl;
    print(header->next);
    cout << endl;

    //test here..

    destroy(header);
    return 0;
}

 

结束语

递归确实是一个比较难的内容，特别是利用指针引用这种思路更是难以理解，但是只要我们多写多练多思考，慢慢地总会熟练掌握的，共勉。

 

 

Melonl
关注
专栏目录
C++递归单链表插入
MaLker的博客
04-09 1478
插入的方法头插法语言描述在单链表的头结点之前插入一个新的节点，使之成为一个从新节点开始的完整链表。 * 所以这个算法的时间复杂度为O1代码实现int headInsert(node *&/*特别强调这里有个引用*/head,int data) { node *temp = head;//这是存储了原有链表的头结点 head = new node;//生成了新链表的头结点，并且叫做h
数据结构之单链表插入，遍历（递归实现）
weixin_44027897的博客
11-30 2177
单链表插入，遍历 单链表的插入简单来说就是找到位置，然后将元素插入。 如何找？ 循环遍历找位置，因为链表的每个节点在内存中的存储位置是非连续的，所以不能像数组那样通过下标位移找到每个元素，而是需要借助元素的 next 域挨个找到目标位置。 数据结构中的遍历分为两种，一种是循环，比如 while（…）,for (…)，一种是递归，没错，递归就是一种遍历。 递归法插入代码如下： void Link::insert(int value, int location) { insert(value, loc
递归程序设计方法练习--递归输出单链表
刘二狗的博客
09-28 5287
6-2 递归程序设计方法练习--递归输出单链表 （10 分） 本题要求用递归方法编写递归函数实现无头结点单链表的输出操作函数。L是一个不带头结点的单链表，函数void ListPrint_L_Rec(LinkList L)要求用递归的方法输出无头结点之单链表中各个元素的值，每个元素的前面都有一个空格（包括首元素）。递归思想可借鉴下述代码中链表创建的递归函数。 函数接口定义： void Li...
递归建立单链表
Alask_的博客
01-16 2657
主要是确定递归基是n==0 然后有点像中文语言一样，第一个节点是p,然后它的next就是cteateList(n-1)。到此，已经完成所有操作。 #include<iostream> using namespace std; struct Node{ int data; Node *next; }; Node * createList(int n){ if(n==0)return NULL; Node*p=new Node; cin>>p->data; p-&gt
用递归实现单向链表
jxc47的博客
09-25 1329
链表具有天然的递归性。 如图： 对于链表的递归我们可以理解为： 对于任何一个节点，它后面可以挂接另一个链表。 该节点的后继节点可以当成另外一个链表的头结点。 在这里我们写的是单向循环链表的递归。同样的，它要实现我们之前写过的List接口的方法，并且要有一个节点的内部类。 这里我们从虚拟头结点开始。 1.LinkedListRecursion（）类 public class LinkedList...
【数据结构与算法】之单链表、双链表、循环链表的基本介绍及其Java代码实现---第三篇
Java学习
10-13 867
博主秋招提前批已拿百度、字节跳动、拼多多、顺丰等公司的offer，可加微信：pcwl_Java一起交流秋招面试经验，可获得博主的秋招简历和复习笔记。 一、链表的基本介绍 链表的定义：链表是一种递归的数据结构，它或者为空(null)，或者是指向一个结点(node)的引用，该结点含有一个泛型的元素和一个指向另一条链表的引用。----Algorithms Fourth Edition...
单链表的基本操作（Java）
qq_43588650的博客
07-25 510
已实现的操作 增删查，改不难，后面考虑写不写 单链表中节点按升序排列 返回链表长度 合并两个有序单链表（基于递推实现，递归的方式个人还未完全理解，算法力扣上有，B站也有相关视频） 返回链表的倒数第k个节点 未实现的操作 单链表的反转（这两天会写完~~） package clwAhu; public class SingleLinkListDemo { public static void main(String[] args) { Node node1
【数据结构练习题】栈和队列（含统考真题）
Obliviate的博客
01-28 6839
栈详解 队列详解 单项选择题 【2010统考真题】若元素a,b,c,d,e,f,依次进栈，允许进栈、退栈操作交替进行，但不允许连续3次进行退栈操作,不可能得到的出栈序列是（)。 A. dcebfa B.cbdaef C. bcaefd D.afedcb 【2018统考真题】若栈S1中保存整数，栈S2中保存运算符，函数F()依次执行下述各步操作: 1）从S1中依次弹出两个操作数a和b。 2）从S2中弹出一个运算符op。 3）执行相应的运算b op a. 4）将运算结果压入S1中。 假定S1中的操作数依
团体程序设计天梯赛-练习集 （L2-021 - L2-040）
Obliviate的博客
04-22 3730
团体程序设计天梯赛-练习集 L2-021点赞狂魔、L2-022重排链表、L2-023图着色问题、L2-024部落、L2-025分而治之、L2-026小字辈、L2-027名人堂与代金券、L2-028秀恩爱分得快、L2-029特立独行的幸福、L2-031深入虎穴、L2-032彩虹瓶、L2-033简单计算器、L2-035完全二叉树的层序遍历、L2-036网红点打卡攻略、L2-037包装机、L2-038病毒溯源、L2-039清点代码库、L2-040哲哲打游戏
python 中常见的面试练习题
zhang1ng的博客
05-07 3830
python 中常见的面试题语言特性编码规范数据类型-字符串数据类型 - 列表数据类型 - 字典数据类型 - 综合操作类题目高级特性正则表达式其他内容算法和数据结构爬虫类网络编程并发Git面试题 人生苦短，我用python！ 语言特性 谈谈对 python 和其他语言的区别 简述解释型和编译型语言 python 的解释器种类以及相关特点 python3 和 python2 的区别 python3...
6-3 递归程序设计方法练习--递归输出单链表
最新发布
2203_75646004的博客
10-28 214
其中L是一个不带头结点的单链表。
单链表递归
ych9527的博客
12-23 1482
文章目录1.前言2.平常递归3.链表递归 1.前言 以前觉得递归太麻烦，指针方便多了，于是乎单链表的题目都是用迭代呀，双指针呀来做的。这次突破下自己，将单链表的递归掰扯一下，等下会用一个简单的小题目来作为例子； 2.平常递归 我先讲一下平常递归的流程，方便待会单链表递归的理解； 题目：输入一个数字 N=123，打印出1，2，3； 代码： void print(n) { if(n>9) print(n/10); printf("%d\n",n%10); } 运行流程图： 3.链表递归 链表递归其实也
递归控制-创建链表
weixin_30566063的博客
11-24 146
0.目录 1.递归控制 2.Java代码实现 2.1 链表结点的实现 2.2 创建链表函数的实现 2.3 测试用例 1.递归控制 递归书写方法： 严格定义递归函数作用，包括参数，返回值，Side-effect 先一般，后特殊 每次调用 必须 缩小问题规模 每次问题规模缩小程度必须为 1 2.Java代码实现 2.1 链表结点的实现 Node有两个成员： 一个是value，希望用户创建后就不...
使用递归方法编写一个简单链表
u014577469的博客
12-31 252
class Node { private String data; private Node next; public Node(String data){ this.data = data; } public String getData(){ return this.data; } public void setNext(Node ne...
链表方法重写
qq_40740954的博客
08-10 137
实现方法 采用接口实现类的方式 list接口 package LinkedList; /** * @Author: mcc * @Date: 2021/8/10 * @Description: LinkedList * @version: 1.0 */ public interface List<E> { static final int ELEMENT_NOT_FOUND = -1; /** * 清除所有元素 */ void clea
JS --- 递归
weixin_30340819的博客
02-20 85
所谓的递归函数就是在函数体内调用本函数 用arguments.callee可解决问题，这是一个指向正在执行的函数的指针，用它来实现对函数的递归调用。 《高程》7.1 递归 阶乘 function factorial(num){ if (num <= 1){ return 1; } else...
递归练习6 求出1000的阶乘尾部零的个数（递归）
ArcherLu的博客
02-23 500
分析： 5 10 15 20 25 30 35 40 45 50 55 60 65 70 75 80 85 90 95 100...10001000 / 5 = 2005的倍数 1个0这些数和任意的偶数相乘，结尾就会产生0 5*5 5*5*2 5*5*3 5*5*4 5*5*5 5*5*6 5*5*7 5*5*8 5*5*9 5*5*10...5*5*40...
递归反转单链表
恋恋风辰的技术博客
01-07 1385
递归反转 本文介绍递归反转单链表，和之前的循环遍历反转单链表方式略有不同，递归的方式要写出推到递归公式。并且在递归的同时修改指针的指向。 先定义Node节点 class Node { public: Node(int dt, Node *nt = nullptr) : data(dt), next(nt) {} Node() = default; int data; Node *next; }; Node节点构成的链表如下图 基本思路是实现recursive_rever
方法练习
BullZeng的博客
03-10 217
形式参数的改变不影响实际参数的改变 package com.zws; /* * 形式参数的改变不影响实际参数的改变 * 形式参数：用于接收实际参数的变量 * 实际参数：实际参与运算的变量 */ public class MethodDemo6 { public static void main(String[] args) { int a = 10; ...
链表详解：线性链表、单链表与基本操作
单链表是链表的一种形式，其中每个结点只包含一个指针域，用于存储指向下一个结点的引用。为了方便操作，通常会在链表开始处添加一个头结点，头结点不包含实际数据，但指向第一个含有数据的结点。 在C语言中，结点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值