数据结构【十】- 递归【三】链表增删改查的递归实现

最新推荐文章于 2022-03-06 17:07:20 发布
最新推荐文章于 2022-03-06 17:07:20 发布
阅读量377 收藏
点赞数 1
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sunshine77_/article/details/103437355
版权

一。需求

我们对在数据结构【五】- 链表【链表的介绍和实现：增删改查】中，链表的增删改查用递归的方式实现。

二。代码准备

package recursion;

import LinkedList.LinkedListRmove.ListNode;

public class LinkedList_Recursion<E> {

    public class Node{
        public E e;
        public Node next;
        public Node(Node node, E e){
            this.e = e;
            this.next = node;
        }
        public Node(){
            this(null,null);
        }
        public Node(E e){
            this(null,e);
        }

        @Override
        public String toString() {
            return e.toString();
        }
    }
    private Node head;
    private int size;

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder("Head :");
        Node curr = head;
        while(curr != null){
            sb.append(curr+"-> ");
            curr = curr.next;
        }
        sb.append("NULL");
        return sb.toString();
    }
    public LinkedList_Recursion() {
        head = null;
        size =0;
    }
    //获取元素个数
    public int getSize(){
        return size;
    }
    //判断链表时候为空
    public boolean isEmpty(){
        return size==0;

    }

}

 

三。思路分析和代码实现

（一）在链表的index(0-based)位置添加新的元素e

1. 代码实现 

    // 在链表的index(0-based)位置添加新的元素e
    public void add(int index, E e){
        if(index < 0 || index > size){
            throw new IllegalArgumentException("Add failed. Illegal index.");
        }
        head = add(head, index, e);
        size++;
    }
    //在以node为头结点的链表的index位置插入元素e，递归算法
    public Node add(Node node, int index, E e){
        //递归的基本问题
        if(index == 0){
            return new Node(node, e);
        }
        node.next = add(node.next, --index, e);
        return node;
    }
    // 在链表头添加新的元素e
    public void addFirst(E e){
        add(0, e);
    }
    // 在链表末尾添加新的元素e
    public void addLast(E e){
        add(size, e);
    }
 

2. 这段递归代码的理解

//在以node为头结点的链表的index位置插入元素e，递归算法
public Node add(Node node, int index, E e){
     //递归的基本问题
    if(index == 0){
        return new Node(node, e);
    }
    node.next = add(node.next, --index, e);
    return node;
}

1） 递归算法的基本原则

  • 求解最基本的问题：最基本的问题就是我们找到了这个index节点，然后在当前位置插入新元素。
  • 更小的同一问题：给以node为头节点的链表的index位置插入元素e

2） 我们可以将这个问题这样理解【个人意见】

  •    更小的同一问题：我们将原来的链表看为：【当前节点】+【已经（在index位置添加了元素）的链表】，所以我们只需要将【当前节点的next】指向【已经（在index位置添加了元素）的节点】。
  •    最基本的问题：如果我们找到了index位置，就需要【要添加的节点】--> 【index位置的节点】，也就是【要添加的节点】的next指向【index位置的节点】。这样【返回的节点】就是【已经添加了新元素的节点】。代码就是【new Node(node, e);】

（二）获得链表的第index(0-based)个位置的元素

1. 代码

    // 获得链表的第index(0-based)个位置的元素
    public E get(int index){
        if(index < 0 || index >= size){
            throw new IllegalArgumentException("Get failed. Illegal index.");
        }
        return get(head, index);
    }
    //在以node为头节点的链表，获得第index个位置的元素，递归算法
    public E get(Node node, int index){
        //递归的基本问题
        if(index ==0){
            return node.e;
        }
        return get(node.next, --index);
    }
    // 获得链表的第一个元素
    public E getFirst(){
        return get(0);
    }

    // 获得链表的最后一个元素
    public E getLast(){
        return get(size - 1);
    }

2. 这段递归代码的理解：

    //在以node为头节点的链表，获得第index个位置的元素，递归算法
    public E get(Node node, int index){
        //递归的基本问题
        if(index ==0){
            return node.e;
        }
        return get(node.next, --index);
    }
  • 求解最基本的问题：最基本的问题就是我们找到了这个index节点，然后这个节点的值。
  • 更小的同一问题：在以node为头结点的链表中，找到第index个元素

（三）修改链表的第index(0-based)个位置的元素为e

1. 代码

    // 修改链表的第index(0-based)个位置的元素为e
    public void set(int index, E e){
        if(index <0 || index >= size){
            throw new IllegalArgumentException("Set failed. Illegal index.");
        }
        set(head, index, e);
    }
    // 修改以node为头结点的链表中，第index(0-based)个位置的元素为e，递归算法
    public void set(Node node, int index, E e){
        if(index ==0){
            node.e = e;
            return;
        }
        set(node.next, --index, e);
    }

2.  对其中递归的理解

  • 求解最基本的问题：最基本的问题就是我们找到了这个index节点，然后改变这个节点的值。
  • 更小的同一问题： 修改以node为头结点的链表中，第index(0-based)个位置的元素为e

（四）查找链表中是否有元素e

1. 代码

    // 查找链表中是否有元素e
    public boolean contains(E e){
        return contains(head, e);
    }
    // 在以node为头结点的链表中，查找是否存在元素e，递归算法
    public boolean contains(Node node, E e){
        if(node == null){
            return false;
        }
        if(node.e.equals(e)){
            return true;
        }
        return contains(node.next, e);
    }

2.  对其中递归的理解

 递归算法的基本原则

  • 求解最基本的问题：最基本的问题是含有这个节点，返回true。不含有这个值，返回false。
  • 更小的同一问题： 在以node为头结点的链表中，查找是否存在元素e

 

（五）从链表中删除index(0-based)位置的元素, 返回删除的元素

1. 代码

    // 从链表中删除index(0-based)位置的元素, 返回删除的元素
    public E remove(int index){
        if(index < 0 || index>=size){
            throw new IllegalArgumentException("remove failed. Illegal index.");
        }
        Pair<Node, E> pair= remove(head, index);
        head = pair.getKey();
        size--;
        return pair.getValue();
    }
    // 从以node为头结点的链表中，删除第index位置的元素，递归算法
    // 返回值包含两个元素，删除后的链表头结点和删除的值;
    public Pair<Node, E> remove(Node node, int index){
        if(index == 0){
            return new Pair<>(node.next, node.e);
        }
        Pair<Node,E> res = remove(node.next, --index);
        node.next = res.getKey();
        return new Pair<>(node, res.getValue());
    }
    // 从链表中删除第一个元素, 返回删除的元素
    public E removeFirst(){
        return remove(0);
    }

    // 从链表中删除最后一个元素, 返回删除的元素
    public E removeLast(){
        return remove(size - 1);
    }

2. 对这段递归代码的理解【个人意见】：

  • 求解最基本的问题：最基本的问题就是我们找到了这个index节点，然后改变这个节点的值。
  • 更小的同一问题： 修改以node为头结点的链表中，第index(0-based)个位置的元素为e，递归算法

（六）从链表中删除元素e

    // 从链表中删除元素e
    public void removeElement(E e){
        head = remove(head, e);
    }
    // 从以node为头结点的链表中，删除元素e，递归算法
    public Node remove(Node node, E e){
        if(node ==null){
            return null;
        }
        if(node.e.equals(e)){
            size--;
            return node.next;
        }
        node.next = remove(node.next, e);
        return node;
    }

思路参考：数据结构【九】- 递归【二】链表的天然递归性 / 用递归解决链表中删除元素的问题 /递归算法的调式

四。代码总和

package recursion;

import LinkedList.LinkedListRmove.ListNode;
import javafx.util.Pair;

import java.util.HashMap;

public class LinkedList_Recursion<E> {

    public class Node{
        public E e;
        public Node next;
        public Node(Node node, E e){
            this.e = e;
            this.next = node;
        }
        public Node(){
            this(null,null);
        }
        public Node(E e){
            this(null,e);
        }

        @Override
        public String toString() {
            return e.toString();
        }
    }
    private Node head;
    private int size;
    public LinkedList_Recursion() {
        head = null;
        size =0;
    }
    //获取元素个数
    public int getSize(){
        return size;
    }
    //判断链表时候为空
    public boolean isEmpty(){
        return size==0;

    }
    // 在链表的index(0-based)位置添加新的元素e
    public void add(int index, E e){
        if(index < 0 || index > size){
            throw new IllegalArgumentException("Add failed. Illegal index.");
        }
        head = add(head, index, e);
        size++;
    }
    //在以node为头结点的链表的index位置插入元素e，递归算法
    public Node add(Node node, int index, E e){
        if(index == 0){
            return new Node(node, e);
        }
        node.next = add(node.next, --index, e);
        return node;
    }
    // 在链表头添加新的元素e
    public void addFirst(E e){
        add(0, e);
    }
    // 在链表末尾添加新的元素e
    public void addLast(E e){
        add(size, e);
    }

    // 获得链表的第index(0-based)个位置的元素
    public E get(int index){
        if(index < 0 || index >= size){
            throw new IllegalArgumentException("Get failed. Illegal index.");
        }
        return get(head, index);
    }
    //在以node为头节点的链表，获得第index个位置的元素，递归算法
    public E get(Node node, int index){
        if(index ==0){
            return node.e;
        }
        return get(node.next, --index);
    }
    // 获得链表的第一个元素
    public E getFirst(){
        return get(0);
    }

    // 获得链表的最后一个元素
    public E getLast(){
        return get(size - 1);
    }
    // 修改链表的第index(0-based)个位置的元素为e
    public void set(int index, E e){
        if(index <0 || index >= size){
            throw new IllegalArgumentException("Set failed. Illegal index.");
        }
        set(head, index, e);
    }
    // 修改以node为头结点的链表中，第index(0-based)个位置的元素为e，递归算法
    public void set(Node node, int index, E e){
        if(index ==0){
            node.e = e;
            return;
        }
        set(node.next, --index, e);
    }

    // 查找链表中是否有元素e
    public boolean contains(E e){
        return contains(head, e);
    }
    // 在以node为头结点的链表中，查找是否存在元素e，递归算法
    public boolean contains(Node node, E e){
        if(node == null){
            return false;
        }
        if(node.e.equals(e)){
            return true;
        }
        return contains(node.next, e);
    }
    // 从链表中删除index(0-based)位置的元素, 返回删除的元素
    public E remove(int index){
        if(index < 0 || index>=size){
            throw new IllegalArgumentException("remove failed. Illegal index.");
        }
        Pair<Node, E> pair= remove(head, index);
        head = pair.getKey();
        size--;
        return pair.getValue();
    }
    // 从以node为头结点的链表中，删除第index位置的元素，递归算法
    // 返回值包含两个元素，删除后的链表头结点和删除的值;
    public Pair<Node, E> remove(Node node, int index){
        if(index == 0){
            return new Pair<>(node.next, node.e);
        }
        Pair<Node,E> res = remove(node.next, --index);
        node.next = res.getKey();
        return new Pair<>(node, res.getValue());
    }
    // 从链表中删除第一个元素, 返回删除的元素
    public E removeFirst(){
        return remove(0);
    }

    // 从链表中删除最后一个元素, 返回删除的元素
    public E removeLast(){
        return remove(size - 1);
    }
    // 从链表中删除元素e
    public void removeElement(E e){
        head = remove(head, e);
    }

    // 从以node为头结点的链表中，删除元素e，递归算法
    public Node remove(Node node, E e){
        if(node ==null){
            return null;
        }
        if(node.e.equals(e)){
            size--;
            return node.next;
        }
        node.next = remove(node.next, e);
        return node;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder("Head :");
        Node curr = head;
        while(curr != null){
            sb.append(curr.e+"-> ");
            curr = curr.next;
        }
        sb.append("NULL");
        return sb.toString();
    }
    public static void main(String[] args) {

        LinkedList_Recursion<Integer> list = new LinkedList_Recursion<>();
        for(int i = 0 ; i < 5 ; i ++){
            list.addFirst(i);
        }
        System.err.println(list);
        list.add(3,7);
        list.add(4,6);
        list.add(2,3);
        System.err.println(list);
        list.removeElement(3);
        list.remove(5);
        System.err.println(list);
        System.err.println("是否含有7："+list.contains(7));
        System.err.println("是否含有3："+list.contains(3));
        list.set(4,11);
        System.err.println(list);
        System.err.println("位置2的元素值："+list.get(2));

    }
}

五。测试代码

   public static void main(String[] args) {

        LinkedList_Recursion<Integer> list = new LinkedList_Recursion<>();
        for(int i = 0 ; i < 5 ; i ++){
            list.addFirst(i);
        }
        System.err.println(list);
        list.add(3,7);
        list.add(4,6);
        list.add(2,3);
        System.err.println(list);
        list.removeElement(3);
        list.remove(5);
        System.err.println(list);
        System.err.println("是否含有7："+list.contains(7));
        System.err.println("是否含有3："+list.contains(3));
        list.set(4,11);
        System.err.println(list);
        System.err.println("位置2的元素值："+list.get(2));

    }
Head :4-> 3-> 2-> 1-> 0-> NULL
Head :4-> 3-> 3-> 2-> 7-> 6-> 1-> 0-> NULL
Head :4-> 3-> 2-> 7-> 6-> 0-> NULL
是否含有7：true
是否含有3：true
Head :4-> 3-> 2-> 7-> 11-> 0-> NULL
位置2的元素值：2

 

参考：https://github.com/liuyubobobo/Play-with-Data-Structures/blob/master/05-Recursion/Optional-01-Recursive-LinkedList/src/LinkedListR.java

你的橙子
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
用递归算法实现无限极添加、删除、修改和移动菜单
12-11
用递归算法实现无限极添加、删除、修改和移动菜单
java递归删除链表_关于单链表的增删改查方法的递归实现(JAVA语言实现)
weixin_33301143的博客
02-23 144
1 public class LinkedList>{2 //链表节点内部类3 private classNode{4 E e;5 Node next;6 publicNode(E _e,Node _next){7 this.e =_e;8 this.next =_next;9 }10 publi...
关于单链表的增删改查方法的递归实现(JAVA语言实现)
weixin_30294709的博客
04-28 232
因为在学习数据结构,准备把java的集合框架底层源码,好好的过一遍,所以先按照自己的想法把单链表的类给写出来了; 写该类的目的: 1.练习递归 2.为深入理解java集合框架底层源码打好基础 学习的视频看的慕课网liuyubobo老师的课程:Java玩转数据结构 从入门到进阶 废话不多说,一下为源代码: 1 public class LinkedList<E exte...
简单链表实现增删改查(内部类＋递归)
七一
07-05 136
手写简单链表： package com.lili.link; /** * 链表： * 一种常见的的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到是下一个节点的指针(Pointer) * <p> * 链表与数组：线性数据结构 * 数组适合查找、遍历、固定长度 * 链表适合插入、删除、不宜过长、否则会导致遍历性能下降 * * @author: QiJingJing * @create: 2021/7/5 */ public class Te
链表的增删改查实现（递归与非递归实现）
╱/.独﹄無㈡oоΟ的博客
12-21 229
链表 1、链表的概念：链表是一种物理存储单元上非连续、非顺序的存储结构。 2、原理图： 3、增删改查操作实现（递归）： （1）、首先创建一个Node类： public class Node { int data; //结点中存储数据区域 Node next; //指向下一个结点 } （2）、增删改查（递归实现）： 增加 : （本例介绍在尾部插入）在增加的过程中，先找到最后一个结点（nex...
C语言数据结构库（队列，栈，链表，树的增删改查）
07-09
本资料包提供了一套完整的C语言数据结构库，特别关注于队列、栈、链表和树这四种基本数据结构的增删改查操作。 1. 队列：队列是一种先进先出（FIFO）的数据结构，类似于现实生活中的排队。在这个库中，你可以找到...
Java单链表增删改查的实现
08-15
下面我们将详细探讨如何在Java中实现单链表的增、删、改、查功能，以及如何进行选择排序、冒泡排序和反转排序。 1. **单链表的定义**： - 单链表的每个节点通常包括两部分：数据域（存储元素）和指针域（存储下一...
数据结构实验三-有关线性链表的操作_数据结构实验三-有关线性链表的操作_
10-03
线性链表是一种基本的数据结构，它在计算机科学中扮演着重要的角色，特别是在数据结构与算法的学习中。在这个数据结构实验三中，我们将探讨如何操作线性链表，包括建立、初始化、插入元素、删除元素、清空以及摧毁...
LUT算法与数据结构-- 递归替换和图书管理
12-10
1. **链表**：用于存储书籍信息，便于动态增删书籍。 2. **哈希表**：用于快速查找书籍，通过书名或其他唯一标识符进行索引。 3. **树结构**，如二叉搜索树：如果需要按某种顺序（如书名、作者）排列书籍，树结构...
链表_数据结构--链表_
10-01
链表是一种基础且重要的数据结构，它在计算机科学中扮演着关键角色，特别是在处理动态数据集合时。与数组不同，链表的元素不是在内存中连续存储，而是通过节点之间的引用连接起来。每个节点通常包含两个部分：数据...
数据结构-链表和递归篇
qq_33253337的博客
02-24 541
数据结构-链表和递归篇 一. 链表（Linked List） 动态数组、栈、队列底层依托静态数组；靠resize解决固定容量问题 链表 ：真正的动态数据结构 最简单的动态数据结构 更深入的理解引用（或者指针） 更深入的理解递归 辅助组成其他数据结构 数据存储在“节点”（Node）中 优点：真正的动态，不需要处理固定容量的问题 缺点：丧失了随机访问的能力 1. 数组和链表的对比 对比 数组 链表 适用场景 最好用于索引有语义的情况 不适用于索引有语音的情况 最大的
mysql数据库杂谈，增、删、改、查、sql递归、导出xls、授权
雨夜青草的博客
12-20 340
mysql数据库常用操作 这篇文章写得比较杂，主要是楼主这几年做后台开发，断断续续添加进去的，有一些很简单的操作也有部分比较难的 1、---------数据库导出Exec表格 ---------- select * into outfile './device.xls' from tlba.terminal_device where 1 order by id d
玩转数据结构（五）链表和递归
sinat_38368658的博客
07-03 349
5-1 Leetcode中和链表相关的问题 5-2 测试自己的Leetcode链表代码 5-3 递归基础与递归的宏观语意 5-4 链表的天然递归结构性质 5-5 递归运行的机制：递归的微观解读 5-6 递归算法的调试 5-7 更多和链表相关的问题 ...
递归建立链表和链表查重
MaLker的博客
04-07 2227
首先声明这个算法实在是不算什么高效的算法。 这个递归的主要目的是实现递归实现双层循环，数组和数组都可以，个人觉得数组需要增加一个长度。 双循环的模板个人认为这项 函数： 模板（外层循环数/*数组为相应的数，链表为指针*/,内层循环数/*同理*/,数组时需要增加数组和数组名和长度）{ //首先需要判断结束信号if（） //判断内层循环是否结束else if（）{ 内层循环道达时因为第一
C++递归单链表插入
MaLker的博客
04-09 1437
插入的方法头插法语言描述在单链表的头结点之前插入一个新的节点，使之成为一个从新节点开始的完整链表。 * 所以这个算法的时间复杂度为O1代码实现int headInsert(node *&/*特别强调这里有个引用*/head,int data) { node *temp = head;//这是存储了原有链表的头结点 head = new node;//生成了新链表的头结点，并且叫做h
链表插入元素的三种递归实现 -- 简单递归，数据累加器，函数累加器
jixuxjixu3的专栏
05-25 1688
函数式编程的一个强大之处在于递归
二、自己动手实现------------“链表”
十里の清风
05-12 232
参考文章： https://mp.weixin.qq.com/s?__biz=MzI4Njg5MDA5NA==&mid=2247484086&idx=1&sn=24127ceb5e0fed7f832f82579c4fbc19&chksm=ebd743b7dca0caa1dce912d47251548225aa59b4b48742a963ac52b05e13ec92...
递归实现双向链表
编程技巧分享
03-06 713
帮助你更好地理解链表与递归。
链表创建与遍历(递归)-C语言
qq_41301428的博客
12-19 1178
链表创建与遍历(递归) #include <stdio.h> #include <string.h> typedef struct link { char data; struct link *next; }Link; int a[]={3, 2, 5, 8, 4, 7, 6, 9, 10, 520}; void CreateLink(Link **Lk); void CreateLink1(Link **Lk, int *a); void PrintList(Link *L
数据结构程序增删改查
最新发布
09-29
好的，我可以帮你回答关于数据结构程序中增删改查的问题。在数据结构中，增删改查是常见的操作。要根据具体的数据结构选择正确的方法。我将分别解释这些操作的基本概念和思路。 1. 增加数据（Insert）： 在数据...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值