数据结构 4 之链表和递归

最新推荐文章于 2021-09-23 22:40:45 发布
最新推荐文章于 2021-09-23 22:40:45 发布
阅读量165 收藏 1
点赞数
分类专栏： DataStructure 文章标签： 链表和递归
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38339124/article/details/103073789
版权

数据结构 4 之链表和递归


  

1 leetcode第23题

题目描述

删除链表中等于给定值 val 的所有节点。

示例:

输入: 1->2->6->3->4->5->6, val = 6
输出: 1->2->3->4->5

public class ListNode {

    public int val;
    public ListNode next;

    public ListNode(int x) {
        val = x;
    }
}

class Solution {

    public ListNode removeElements(ListNode head, int val) {

        //判断头节点就是该val值
        while(head != null && head.val == val){
            ListNode delNode = head;
            //头节点后移
            head = head.next;
            delNode.next = null;
        }

        if(head == null)
            return head;

        ListNode prev = head;
        while(prev.next != null){
            if(prev.next.val == val) {
                ListNode delNode = prev.next;
                prev.next = delNode.next;
                delNode.next = null;
                //注意这里prev 不用后移，因为删除之后prev的下一个节点已经删除
            }
            else
                prev = prev.next;
        }

        return head;
    }

    /**
     * 在lettcode中提交代码不用考虑内存回收的问题，代码可以简化
     * @param head
     * @param val
     * @return
     */
    public ListNode removeElements2(ListNode head, int val) {

        //判断头节点就是该val值
        while(head != null && head.val == val){
            head = head.next;
        }

        if(head == null)
            return head;

        ListNode prev = head;
        while(prev.next != null){
            if(prev.next.val == val) {
                prev.next = prev.next.next;
            }
            else
                prev = prev.next;
        }

        return head;
    }
    /*
     * 使用虚拟头节点 简化代码
     */
    public ListNode removeElements3(ListNode head, int val) {

        ListNode dummyHead = new ListNode(-1);
        dummyHead.next = head;

        ListNode prev = dummyHead;
        while(prev.next != null){
            if(prev.next.val == val)
                prev.next = prev.next.next;
            else
                prev = prev.next;
        }

        return dummyHead.next;
    }
}

2 本地调试

public class ListNode {

    public int val;
    public ListNode next;

    public ListNode(int x) {
        val = x;
    }

    // 链表节点的构造函数
    // 使用arr为参数，创建一个链表，当前的ListNode为链表头结点
    public ListNode(int[] arr){

        if(arr == null || arr.length == 0)
            throw new IllegalArgumentException("arr can not be empty");

        this.val = arr[0];
        ListNode cur = this;
        for(int i = 1 ; i < arr.length ; i ++){
            cur.next = new ListNode(arr[i]);
            cur = cur.next;
        }
    }

    // 以当前节点为头结点的链表信息字符串
    @Override
    public String toString(){

        StringBuilder s = new StringBuilder();
        ListNode cur = this;
        while(cur != null){
            s.append(cur.val + "->");
            cur = cur.next;
        }
        s.append("NULL");
        return s.toString();
    }
}

class Solution {

    public ListNode removeElements(ListNode head, int val) {

        while(head != null && head.val == val){
            ListNode delNode = head;
            head = head.next;
            delNode.next = null;
        }

        if(head == null)
            return head;

        ListNode prev = head;
        while(prev.next != null){
            if(prev.next.val == val) {
                ListNode delNode = prev.next;
                prev.next = delNode.next;
                delNode.next = null;
            }
            else
                prev = prev.next;
        }

        return head;
    }

    public static void main(String[] args) {

        int[] nums = {1, 2, 6, 3, 4, 5, 6};
        ListNode head = new ListNode(nums);
        System.out.println(head);

        ListNode res = (new Solution()).removeElements(head, 6);
        System.out.println(res);
    }
}

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

Process finished with exit code 0

class Solution2 {

    public ListNode removeElements(ListNode head, int val) {

        while(head != null && head.val == val)
            head = head.next;

        if(head == null)
            return head;

        ListNode prev = head;
        while(prev.next != null){
            if(prev.next.val == val)
                prev.next = prev.next.next;
            else
                prev = prev.next;
        }

        return head;
    }

    public static void main(String[] args) {

        int[] nums = {1, 2, 6, 3, 4, 5, 6};
        ListNode head = new ListNode(nums);
        System.out.println(head);

        ListNode res = (new Solution2()).removeElements(head, 6);
        System.out.println(res);
    }
}

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

Process finished with exit code 0

class Solution3 {

    public ListNode removeElements(ListNode head, int val) {

        ListNode dummyHead = new ListNode(-1);
        dummyHead.next = head;

        ListNode prev = dummyHead;
        while(prev.next != null){
            if(prev.next.val == val)
                prev.next = prev.next.next;
            else
                prev = prev.next;
        }

        return dummyHead.next;
    }

    public static void main(String[] args) {

        int[] nums = {1, 2, 6, 3, 4, 5, 6};
        ListNode head = new ListNode(nums);
        System.out.println(head);

        ListNode res = (new Solution3()).removeElements(head, 6);
        System.out.println(res);
    }


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

Process finished with exit code 0

3 递归基础和递归的宏观语义

1、本质上就是将原来的问题转化为更小的同一问题

在这里插入图片描述

public class Sum {

    public static int sum(int[] arr){
        return sum(arr, 0);
    }

    // 计算arr[l...n)这个区间内所有数字的和
    private static int sum(int[] arr, int l){
        if(l == arr.length)
            return 0;
        return arr[l] + sum(arr, l + 1);
    }

    public static void main(String[] args) {

        int[] nums = {1, 2, 3, 4, 5, 6, 7, 8};
        System.out.println(sum(nums));
    }
}

在这里插入图片描述

4 链表的天然递归结构性质

在这里插入图片描述
用递归解决链表中删除元素的问题
在这里插入图片描述

class Solution3 {

    public ListNode removeElements(ListNode head, int val) {

        if (head == null) {
            return null;
        }
        ListNode res = removeElements(head.next,val);
        //如果当前head的值就是要查找的值，则返回更小的链表
        if(head.val == val) {
            return res;
        } else {
            head.next = res;
            return head;
        }
    }
    //将上一步进行化简
    public ListNode removeElements2(ListNode head, int val) {

        if (head == null) {
            return null;
        }
        head.next = removeElements2(head.next,val);
        return head.val == val ? head.next : head;
    }



    public static void main(String[] args) {

        int[] nums = {1, 2, 6, 3, 4, 5, 6};
        ListNode head = new ListNode(nums);
        System.out.println(head);

        ListNode res = (new Solution3()).removeElements2(head, 6);
        System.out.println(res);
    }
}

5 递归的的微观解读

1、递归函数的调用，本质就是普通函数的调用
2、只不过调用的函数是自己本身

回顾之前的数组求和函数的递归调用

public class Sum {

    public static int sum(int[] arr){
        return sum(arr, 0);
    }

    // 计算arr[l...n)这个区间内所有数字的和
    private static int sum(int[] arr, int l){
        if(l == arr.length)
            return 0;
        int x = sum(arr,l + 1);
        int res = arr[l] + x;
        return res ;
    }
}

在这里插入图片描述
再回顾使用递归方法删除链表中相同元素的问题
在这里插入图片描述
开始进行返回
在这里插入图片描述

总结：
1、递归的调用是有代价的：函数调用 + 系统栈空间

6 递归算法的调试

public class Solution {

    public ListNode removeElements(ListNode head, int val, int depth) {

        String depthString = generateDepthString(depth);

        System.out.print(depthString);
        System.out.println("Call: remove " + val + " in " + head);

        if(head == null){
            System.out.print(depthString);
            System.out.println("Return: " + head);
            return head;
        }

        ListNode res = removeElements(head.next, val, depth + 1);
        System.out.print(depthString);
        System.out.println("After remove " + val + ": " + res);

        ListNode ret;
        if(head.val == val)
            ret = res;
        else{
            head.next = res;
            ret = head;
        }
        System.out.print(depthString);
        System.out.println("Return: " + ret);

        return ret;
    }

    private String generateDepthString(int depth){
        StringBuilder res = new StringBuilder();
        for(int i = 0 ; i < depth ; i ++)
            res.append("--");
        return res.toString();
    }

    public static void main(String[] args) {

        int[] nums = {1, 2, 6, 3, 4, 5, 6};
        ListNode head = new ListNode(nums);
        System.out.println(head);

        ListNode res = (new Solution()).removeElements(head, 6, 0);
        System.out.println(res);
    }

}

1->2->6->3->4->5->6->NULL
Call: remove 6 in 1->2->6->3->4->5->6->NULL
--Call: remove 6 in 2->6->3->4->5->6->NULL
----Call: remove 6 in 6->3->4->5->6->NULL
------Call: remove 6 in 3->4->5->6->NULL
--------Call: remove 6 in 4->5->6->NULL
----------Call: remove 6 in 5->6->NULL
------------Call: remove 6 in 6->NULL
--------------Call: remove 6 in null
--------------Return: null
------------After remove 6: null
------------Return: null
----------After remove 6: null
----------Return: 5->NULL
--------After remove 6: 5->NULL
--------Return: 4->5->NULL
------After remove 6: 4->5->NULL
------Return: 3->4->5->NULL
----After remove 6: 3->4->5->NULL
----Return: 3->4->5->NULL
--After remove 6: 3->4->5->NULL
--Return: 2->3->4->5->NULL
After remove 6: 2->3->4->5->NULL
Return: 1->2->3->4->5->NULL
1->2->3->4->5->NULL

Process finished with exit code 0

7 链表的其他形式

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

ChengZi~
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构（四）--链表和递归
JayBillions的博客
07-09 1180
（一）递归递归：本质上，将原来的问题，转化为更小的问题 应用：数组求和package cn.leetCode; public class Sum { public static int sum(int[] arr){ return sum(arr,0); } //计算arr[l..n)这个区间(从l到n-1)内所有数字的和,私有化 private static int sum(i...
【数据结构与算法】四 链表 反转
maguochao_Mark的博客
02-20 551
【数据结构与算法】四 链表 reverse链表前面我们提到数组,今天我们来聊一聊链表,链表也是一基础数据结构,在很多语言原生纯在.好了,我们不废话直接自己来实现个链表练练手…C++#include <iostream>struct node{ int num; node* next; };void out(node* head){ node* iterator = head
数据结构-------链表（递归）操作
weixin_51578598的博客
09-23 2773
数据结构中的链表估计很多人会觉得简单，我也是怕记不住所以就尝试整理一下笔记吧 1.创建链表（初始化） struct ListNode { //链表结点类 int data; //数据域，当然int类型可以改为自定义类型T等等 ListNode * next; //主要讨论单链表 }; typedef ListNod
递归实现链表操作
weixin_48276298的博客
05-13 1619
链表是一种很简单数据结构，但是在面试题中常常出现。链表的每个节点包含一个指向下一个节点的指针，跟串糖葫芦似得穿起来。 struct Node { int val; Node* next; } 链表结构简单，但是却很漂亮，因为它具有天生的递归结构，所以几乎所有链表的操作都有一个递归的实现方式，这也是本篇文章的主要目的：教大家递归地处理链表。 这篇文章主要写两个链表最常考察的两个操作，包括链表翻转和两个有序链表的合并，并且给出迭代和递归两种解法。 首先来简单热下身，给一个链表头，求这个链表的长
链表的递归思路与分析步骤
qq_40664019的博客
04-15 1615
链表的递归思路与分析步骤： 我们以一道力扣上的经典题目为例子????： 删除排序链表中的重复元素 题目描述 存在一个按升序排列的链表，给你这个链表的头节点 head ，请你删除所有重复的元素，使每个元素只出现一次 。 返回同样按升序排列的结果链表。 图片: 输入：head = [1,1,2,3,3] 输出：[1,2,3] 解题思路： 递归法： 第一步：明白递归函数定义 递归最基本的是要明白递归函数的定义！ 递归函数为 deleteDuplicates(head) ，它的含义是处理 head 作为开头的有序
五 链表与递归2 递归数组求和 递归链表求和
liu14116的博客
07-16 600
文章目录
大连理工数据结构上机 链表递归
09-23
链表递归
010 数据结构逆向—链表1
最新发布
08-03
在逆向工程中，数据结构的理解至关重要，尤其是链表这种动态数据结构。本文将深入探讨如何从给定的代码片段中解析链表结构，并提供相关的编程实现和逆向分析技巧。 链表是一种线性数据结构，它由一系列节点组成，每...
数据结构-链表相关功能和算法
06-11
链表是一种基础且重要的数据结构，它在计算机科学和编程中扮演着不可或缺的角色。相比于数组，链表在处理动态数据集合时提供了更大的灵活性。在这个"数据结构-链表相关功能和算法"的主题中，我们将深入探讨链表的...
数据结构的双链表算法
09-27
总结来说，双链表是一种高效的数据结构，尤其适用于需要频繁进行双向遍历和插入删除操作的场景。通过理解和熟练掌握双链表及其算法，对于提升编程能力，尤其是解决复杂数据处理问题的能力，具有重要意义。
数据结构之链表和递归
咸蛋超人
06-24 457
一、 链表数据结构 1、链表是一种常见的基础数据结构，是一种线性表，但是并不会按照线性的顺序存储数据，而是在每一个节点里存储了下一个节点的指针， 二、 算法 1、递归算法是一种直接或者间接调用自身算法的过程， 链表： /** 链表数据结构 */class LinkListDemo { public static void main(String[] args)
玩转数据结构（五）链表和递归
sinat_38368658的博客
07-03 349
5-1 Leetcode中和链表相关的问题 5-2 测试自己的Leetcode链表代码 5-3 递归基础与递归的宏观语意 5-4 链表的天然递归结构性质 5-5 递归运行的机制：递归的微观解读 5-6 递归算法的调试 5-7 更多和链表相关的问题 ...
关于链表的递归操作
parting_soul的专栏
11-07 1462
不带头结点链表翻转 思路： 假设有1,2,3,4,5,6，这样6个数构成一个链表，要进行翻转操作，结果应为6,5,4,3,2,1， 假设要翻转1 ，那就要先翻转2,，要翻转2，就要翻转3，直到要翻转6，就是当剩下一个元素或者链表为空时作为结束条件 假设2,3,4,5,6,已经翻转，此时结果为1,6,5,4,3,2，可见，我们只需将1移到2后面就行了，还可以看到1一直是指向2的，所以找到2的位
C语言实现链表中的递归
qq_45359086的博客
03-10 1288
链表中的递归 什么是递归呢？函数在运行时调用自己，这个函数就叫递归函数，调用的过程叫做递归。比如定义函数f(x)=x+f(x-1) 递归的三个要点： 终止条件，递归应该在什么条件终止？ 返回值，当前应该给上一级返回什么？ 递归方法，在这一级递归中，应该完成什么任务？ 例1： 将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的，例如： 输入：1...
递归实现链表的一些操作
xinanbo的博客
04-19 1445
递归作为一种重要的算法思想，在链表中也有特别大的作用，特别是逆序输出时，代码更加简单。以一个题为例：设head指向一个非空单向链表：1.输出链表所有结点的值2.逆向输出所有结点的值3.返回链表所有结点的和4.返回链表奇数的个数5.返回数据为key的结点地址，若未找到，返回NULL首先，我们需要用递归创建一个链表。ElemSN *CreatLink(int a[] , int n){ ElemSN ...
数据结构_5：链表与递归
编程小透明的博客
11-10 290
链表与递归 链表元素删除问题的解答 问题描述：在链表[1, 2, 6, 3, 4, 5, 6] 中删除值为 6 的元素 ListNode.java 结构说明 public class ListNode { int val; ListNode next; ListNode(int x) {val = x;} /** * 链表节点构造函数，自定义 ...
数据结构基础：链表与双向链表解析
"本文主要介绍了数据结构中的基础概念，包括数组、链表、栈和队列，并特别关注了链表中的单链表和双向链表。此外，还提到了字符串在不同编程环境下的使用方式。" 在计算机科学中，数据结构是组织和存储数据的方式，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值