4.链表和递归

最新推荐文章于 2024-05-09 22:59:17 发布
最新推荐文章于 2024-05-09 22:59:17 发布
阅读量109 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41207499/article/details/80871784
版权

一. Leetcode中和链表相关的问题(203号问题)

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

示例:

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

解法1: 不使用虚拟头节点

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
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 null;
        }

        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;
    }
}

解法2:使用虚拟头节点

public class Solution2 {
    public ListNode removeElements(ListNode head, int val) {

        ListNode dummyHead = new ListNode(-1);  //创建虚拟头节点
        dummyHead.next = head;


        ListNode prev = dummyHead;   //这样就确定第一个元素不会是val
        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 dummyHead.next;
    }
}

python3版本

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def removeElements(self, head, val):
        """
        :type head: ListNode
        :type val: int
        :rtype: ListNode
        """
        dummyHead = ListNode(-1)
        dummyHead.next = head
        
        prev = dummyHead
        while prev.next != None:
            if prev.next.val == val:
                delNode = prev.next
                prev.next = delNode.next
                delNode.next = None
            else:
                prev = prev.next
        
        return dummyHead.next

二. 测试自己的Leetcode链表代码

在本地测试自己上一节的代码， 我们这样编辑代码：
ListNode.java

public class ListNode {
    int val;
    ListNode next;

    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 res = new StringBuilder();

        ListNode cur = this;

        while(cur != null){
            res.append(cur.val + "->");
            cur = cur.next;
        }

        res.append("NULL");

        return res.toString();
    }

Solution.java存放解法1， Solution2存放解法2. 我们在它们中增加测试代码
以Solution.java为例:

class Solution {
    public ListNode removeElements(ListNode head, int val) {

      ···
    }

    // 测试
    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

三. 递归基础与递归宏观语义

递归

  • 本质上，将原来的问题， 转化为更小的同一问题

image

将该例子用代码实现 Sum.java:

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));
    }

运行结果

36

四. 链表的天然递归结构性质

image

根据链表这样的特性， 我们来解决第一节的了额头从的203号问题。


编写对应代码

Solution3.java

public class Solution3 {
    public ListNode removeElements(ListNode head, int val) {
        if (head == null) {
            return null;
        }

        head.next = removeElements(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()).removeElements(head, 6);
        System.out.println(res);
    }
}

运行结果:

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

五. 递归算法的调试

推荐使用打印字符串的调试方式。
以Solution3.java为例子，我们这样修改：

public class Solution3 {
    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;
        }

        head.next = removeElements(head.next, val, depth + 1);  // depth表示递归深度，每次递归都+1
        System.out.print(depthString);
        System.out.println("After remove" + val + ":" + head.next);

        ListNode ret;
        if (head.val == val) {
            ret = head.next;
        } else {
            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 Solution3()).removeElements(head, 6, 0);
        System.out.println(res);
    }
}

运行结果:

1->2->6->3->4->5->6->NULL
call: remove6 in 1->2->6->3->4->5->6->NULL
--call: remove6 in 2->6->3->4->5->6->NULL
----call: remove6 in 6->3->4->5->6->NULL
------call: remove6 in 3->4->5->6->NULL
--------call: remove6 in 4->5->6->NULL
----------call: remove6 in 5->6->NULL
------------call: remove6 in 6->NULL
--------------call: remove6 in null
--------------return: null
------------After remove6: null
------------Return: null
----------After remove6: null
----------Return: 5->NULL
--------After remove6: 5->NULL
--------Return: 4->5->NULL
------After remove6: 4->5->NULL
------Return: 3->4->5->NULL
----After remove6: 3->4->5->NULL
----Return: 3->4->5->NULL
--After remove6: 3->4->5->NULL
--Return: 2->3->4->5->NULL
After remove6: 2->3->4->5->NULL
Return: 1->2->3->4->5->NULL
1->2->3->4->5->NULL
书山压力大EEE
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单链表的递归实现
xueAnother的博客
11-25 4451
可以将单链表看成是递归定义的，每个结点的next域指向由后诸结点组成的一条子单链表，最后一个结点的next域指向空链表。此时可以将单链表写成递归算法。 1、构造空链表public class LinkedRecursion<T> { public Node<T>head; //构造函数，构造空链表 public LinkedRecursion(){
4. 链表-最简单的递归结构1
08-03
答案隐藏在了题干中: 小青蛙每次能跳1阶或者2阶如果小青蛙第一次跳了1阶，那么还剩下n-1阶如果小青蛙第一次跳了2阶，那么还剩下n-2阶实现递归的关键就在于如何
链表性质判断
VanillaSky
03-30 438
判断单链表是否有环，如果有环的话请返回从头结点进入环的第一个节点，没有就返回null https://leetcode.com/problems/linked-list-cycle-ii/ 两个游标指针一起从头走，一个走一步，一个走两步，若能再次相遇，就说明有环. 两个指针分别从头和相遇处走，再次相遇处就是相交点。public ListNode detectCycle(ListNode hea
234.回文链表-递归
最不正经的计算机专业学生
11-05 394
给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false 。 示例 1： 输入：head = [1,2,2,1] 输出：true 示例 2： 输入：head = [1,2] 输出：false 提示： 链表中节点数目在范围[1, 105] 内 0 <= Node.val <= 9 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/palindrome-li...
反转链表-递归反转法
有朋自远方来，不亦乐乎。
07-30 2082
（1）思想：和迭代反转法的思想恰好相反，递归反转法的实现思想是从链表的尾节点开始，依次向前遍历，遍历过程依次改变各节点的指向，即另其指向前一个节点。 （2）实现（建议先看代码，再看图解，使理解更加深刻）：开始递归： new_head经过三次函数递归的调用来到了链表的最后一个结点，因为new_head=head->next,所以head始终保持在new_head的前一个结点处。递归到最后一层时： 开始逐层出递归： 递归结束。最后的结果为： 代码片段： 完整代码： 输出结果：...
翻转链表——递归法
weixin_43400091的博客
01-26 3065
来看看实现翻转链表的第2种方法——递归法 这种方法更简洁一些，但是比较难于理解，可以借助下图： Solution: class Solution{ public ListNode reverseList(ListNode head){ if(head == null) || head->next == null) //如果最后一个结点不操作 return head; ListNode node = reverseList.
链表反转【递归法】
kiround的博客
05-20 3954
链表反转是一道非常热门的算法基础题，让我们来一起看一看这道题吧。本次解题使用的是递归法
合并两个有序链表(递归和迭代)
xinkuaile的专栏
04-26 1510
彻底弄懂 链表的合并算法，递归和代码
反转链表问题的递归解法
m0_50987960的博客
11-25 1738
反转整个链表和部分链表的递归解法
反转链表· 递归
wuxiaoyu0806的博客
02-06 457
【代码】反转链表· 递归。
数据结构和算法：链表栈递归
12-23
链表栈递归。 给定两个链表，分别表示两个非负整数。它 们的数字逆序存储在链表中，且每个结点只 存储一个数字，计算两个数的和，并且返回 和的链表头指针
剑指Offer #03 从尾到头打印链表（递归）
01-20
因为题目要求返回的顺序是从尾到头，所以我们可以采用递归的形式访问链表，在回归的过程才将节点的值存入ArrayList中，以达到逆序的目的。 /** * public class ListNode { * int val; * ListNode next = null; * * ...
C 语言链表逆置，递归算法.pdf
11-13
部分逆置 pta c语言
如何使用递归和非递归方式反转单向链表
09-05
以下是对使用递归和非递归方式反转单向链表的示例进行了详细的分析介绍，需要的朋友可以过来参考下
链表反转-迭代和递归
someInNeed的博客
03-13 205
要求很简单，输入一个链表，反转链表后，输出新链表的表头。   反转链表是有2种方法(递归法，遍历法)实现的，面试官最爱考察的算法无非是 斐波那契数列和单链表反转，递归方法实现链表反转比较优雅， 但是对于不了解递归的同学来说还是有理解难度的。 遍历法 遍历法就是在链表遍历的过程中将指针顺序置换 ...
数据结构-栈
2302_81705247的博客
05-02 959
栈底层逻辑的理解和模仿实现。逆波兰表达式
顺序表的实现（迈入数据结构的大门）（2）
最新发布
老师我想进步
05-09 299
书接上文。
【数据结构】详解栈
Qiwaw的博客
05-09 832
对栈模糊？一键带你吃透！
C语言以链表和递归建立一个已知的二叉树
06-02
下面是 C 语言代码，使用链表和递归方式建立二叉树： ```c #include <stdio.h> #include <stdlib.h> typedef struct Node { int data; struct Node *left; struct Node *right; } Node; Node* createNode(int ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值