Java学习第十五天 链表和递归

最新推荐文章于 2022-04-19 22:38:35 发布
最新推荐文章于 2022-04-19 22:38:35 发布
阅读量151 收藏 2
点赞数
文章标签： 链表 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_58070636/article/details/117716014
版权

LeetCode 删除链表中某个元素

package com.LeetCodeProblem.ListNodeRemoveElement;

public class ListNode {
    int val;
     ListNode next;
     ListNode() {}
     ListNode(int val) { this.val = val; }
     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
}

package com.LeetCodeProblem.ListNodeRemoveElement;

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

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

或者

package com.LeetCodeProblem.ListNodeRemoveElement;

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

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

或者使用虚拟头节点

package com.LeetCodeProblem.ListNodeRemoveElement;

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

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

本地调试算法

package com.LeetCodeProblem.ListNodeRemoveElement;

import java.util.List;

public class ListNode {
    int val;
     ListNode next;
     ListNode() {}
     ListNode(int val) { this.val = val; }
     ListNode(int val, ListNode next) { this.val = val; this.next = next; }

    //链表节点的构造函数
    //使用arr为参数，创建一个链表，当前的ListNode为链表头节点
    public ListNode(int[]arr){
         if(arr==null||arr.length==0)
             throw new IllegalArgumentException("链表为空或链表长度为0");

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

}

 

package com.LeetCodeProblem.ListNodeRemoveElement;

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

        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,3,45,6,6,6,8,2};
        ListNode head=new ListNode(nums);
        System.out.println(head);
       ListNode res= (new Solution()).RemoveElements(6,head);
        System.out.println(res);

    }
}

递归

本质：将原来的问题转化为同一更小的问题

package com.LeetCodeProblem;

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

 

链表天然的递归性

解决链表中删除元素的问题

package com.LeetCodeProblem.ListNodeRemoveElement;

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

        if(head==null) return head;

        ListNode res=RemoveElements(val,head.next);
        if (head.val==val) return res;
        else {
            head.next=res;
            return head;
        }
    }

    public static void main(String[] args) {

        int[] nums={1,2,3,45,6,6,6,8,2};
        ListNode head=new ListNode(nums);
        System.out.println(head);
        ListNode res= (new Solution()).RemoveElements(6,head);
        System.out.println(res);

    }
}

package com.LeetCodeProblem.ListNodeRemoveElement;

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

        if(head==null) return head;

        head.next=RemoveElements(val,head.next);
        return head.val==val?head.next:head;
    }

    public static void main(String[] args) {

        int[] nums={1,2,3,45,6,6,6,8,2};
        ListNode head=new ListNode(nums);
        System.out.println(head);
        ListNode res= (new Solution()).RemoveElements(6,head);
        System.out.println(res);

    }
}

递归函数的微观解读

从左到右，再从右到左。

本质是函数调用，只不过调用的是自己。

递归调用的代价：函数调用+系统栈空间

对于线性递归调用，如果计算如十万个数字的累加，系统栈空间就不够用了

递归算法的调试

递归深度depth

package com.LeetCodeProblem.ListNodeRemoveElement;

 class Solution2 {
    public ListNode RemoveElements(int val,ListNode head,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(val,head.next,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 Solution2()).RemoveElements(6,head,6);
        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 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

 

双链表

循环链表

数组链表

按顺序合并两个链表并输出

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        // 类似归并排序中的合并过程
        ListNode dummyHead = new ListNode(0);
        ListNode cur = dummyHead;
        while (l1 != null && l2 != null) {
            if (l1.val < l2.val) {
                cur.next = l1;
                cur = cur.next;
                l1 = l1.next;
            } else {
                cur.next = l2;
                cur = cur.next;
                l2 = l2.next;
            }
        }
        // 任一为空，直接连接另一条链表
        if (l1 == null) {
            cur.next = l2;
        } else {
            cur.next = l1;
        }
        return dummyHead.next;
    }

 

从零开始的码农生活01
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Java算法面试题(001) 如何使用循环和递归计算单链表的长度
Bob Liu的程序人生
11-23 3400
本文为本博主翻译，未经允许，严禁转载。 简介 这是我第一次接受跨国投资银行面试时所问的经典编程问题之一。之后，这个问题在其他编程工作面试中也多次被问到。让这个问题有趣的是，与C ++开发人员相比，Java开发人员在数据结构方面并不是那么棒，这显然是因为这两种语言之间的根本区别。 C ++更多的是系统编程语言，而Java更多的是应用程序编程，也有一套丰富的Java API允许程序员跳过这种基本的
Java数据结构和算法(第二版).zip
07-27
全书共分为15章，分别讲述了基本概念、数组、简单排序、堆和队列、链表、递归、进阶排序、二叉树、红黑树、哈希表及图形等知识。附录中则提供了运行专题Applet和例程、相关书籍和问题解答。《Java数据结构和算法》...
【LeetCode】C++ ：中等题 - 链表 19. 删除链表的倒数第 N 个结点
weixin_44566432的博客
01-26 212
中等题训练开始啦！！！紧张 19. 删除链表的倒数第 N 个结点 难度中等1188 给你一个链表，删除链表的倒数第n个结点，并且返回链表的头结点。 进阶：你能尝试使用一趟扫描实现吗？ 示例 1： 输入：head = [1,2,3,4,5], n = 2 输出：[1,2,3,5] 示例 2： 输入：head = [1], n = 1 输出：[] 示例 3： 输入：head = [1,2], n = 1 输出：[1] 提示： 链表中结点的数目为sz ...
java单链表的使用总结
孙霸天的专栏
03-02 1347
链表的概念: 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列节点(链表中的每一个元素称为节点)组成，节点可以在运行时动态生成。每个节点包含两个部分:一个是存储数据元素的数据域，另一个是存储下一个节点地址的指针域。相对于线性表顺序结构，操作复杂。由于不必按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得...
java数据结构-链表递归（学习链表笔记三）
xiaoxin0630的博客
12-27 689
链表递归针对力扣的203题来进行学习 首先我们用链表解出来 链表的创建代码   package com.binglian.LinkedList.digui; public class ListNode { public int val; public ListNode next; public ListNode(int x){ val=x; } //链表...
java递归基本结构_Java链表的天然递归结构性质图文与实例分析
weixin_33292780的博客
02-13 76
本文实例分析了Java链表的天然递归结构性质。分享给大家供大家参考，具体如下：要求：使用递归删除链表中指定的所有元素值。一、图文分析假设有这么一个链表，如下图：分析：基于链表的宏观语意(递归是问题更小的子过程)进行分析我们可以把上述链表看成是一个头结点后面挂接了一个更小的链表组成，如下图：此时我们可以把链表概括成如下的链表结构：1、在一个头结点+更小的链表基础上，从更小的链表中删除指定元素，得到一...
java数据结构和算法.（第二版）
11-11
全书共分为15章，分别讲述了基本概念、数组、简单排序、堆和队列、链表、递归、进阶排序、二叉树、红黑树、哈希表及图形等知识。附录中则提供了运行专题Applet和例程、相关书籍和问题解答。《Java数据结构和算法》...
Java数据结构和算法(第二版)
01-05
全书共分为15章，分别讲述了基本概念、数组、简单排序、堆和队列、链表、递归、进阶排序、二叉树、红黑树、哈希表及图形等知识。附录中则提供了运行专题Applet和例程、相关书籍和问题解答。本书提供了学完一门编程...
Java数据结构和算法 （第二版）
03-01
《Java数据结构和算法（第二版）》是深入学习计算机科学和编程的必备参考资料，尤其对于使用Java语言的开发者来说，这本书提供了丰富的理论知识和实践经验。数据结构与算法是计算机科学的基础，它们决定了如何有效地...
JAVA递归思想解决链表删除元素问题
m0_38005852的博客
10-08 769
问题描述： 删除链表中等于给定值 val 的所有节点。 示例: 输入: 1-&gt;2-&gt;6-&gt;3-&gt;4-&gt;5-&gt;6, val = 6 输出: 1-&gt;2-&gt;3-&gt;4-&gt;5   解决方法，递归思想： /** * Definition for singly-linked list. * public class ListNode...
【算法世界】（九）LeetCode -- Add Two Numbers by ListNode
暂七师师长常乃超
10-06 1898
一、问题展示        正如题目所述，昨天我做了一道LeetCode上的算法题，题干大概是这样：            如图，用两个非空的链表代表两个非负整数。在队列存储中数字是以倒置的顺序存储，并且链表的每一个节点里包含一个单个的数字，要求把两个这样的链表相加，返回一个新的链表，同时这个新的链表中的值，就是实际上连个非负整数的和，举例：       输入：（2 -> 4 -> 3） + (5
JAVA ListNode链表
热门推荐
摸金校尉的博客
03-06 7万+
链表结构，在Java中用需要自己定义一个ListNode类来生成链表对象。 自定义的ListNode链表类如下： public class ListNode { int val; ListNode next; // 下一个链表对象 ListNode(int x) { val = x; } //赋值链表的值 } leetcode第2题...
day14//删除链表的倒数第N个节点
ChenChenYang_int的博客
04-19 352
方法一：暴力法（先遍历得到长度，再用长度减去N即可获得需要删除节点前的节点位置） classSolution{ public: ListNode*removeNthFromEnd(ListNode*head,intn){ ListNode*dummyhead=newListNode(0); dummyhead->next=head; ListNode*cur=head; intm=0...
java的listnode_在java中使用ListNode
weixin_28916013的博客
02-12 4353
ListNode是由自己定义的java中的链表对象类结构如下public class ListNode{int val;ListNode next;public ListNode(int x){val=x;}}初始化时必须传值有一列 1.给出 Input: (2 -> 4 -> 3) + (5 -> 6 -> 4) 要求Output: 7 -> 0 -> ...
在java中使用ListNode
SuperHero521的博客
08-02 5万+
ListNode是由自己定义的java中的链表对象 类结构如下 public class ListNode { int val; ListNode next; public ListNode(int x){ val=x; } } 初始化时必须传值 有一列  1.给出 Input: (2 -> 4 -> 3) + (5 -> 6
java遍历链表元素_java-如何从链表中递归删除所有第三个元素...
weixin_39693662的博客
02-23 222
如果您递归执行,则无需进行迭代.将问题简化为一次迭代,然后将其应用于当前状态,然后应用于列表的其余部分.似乎没有节点类,因此必须使用索引来完成.删除第三个元素意味着保留当前的两个元素,然后删除后面的一个元素.我们还必须考虑到删除列表时该列表将“移动”,因此删除后不必前进.下一个“当前”将与我们从中删除的索引相同.public void removeElements(List list, int c...
（LeetCode）2. 两数相加
田野中的锋芒
08-27 212
给出两个非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照逆序的方式存储的，并且它们的每个节点只能存储一位数字。 如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。 您可以假设除了数字 0 之外，这两个数都不会以 0开头。 示例： 输入：(2 -> 4 -> 3) + (5 -> 6 -> 4) 输出：7 -> 0 -&...
【数据结构Java实现】链表和递归
memcpy0的博客
03-12 381
文章目录一、递归思想介绍二、链表的天然递归结构性质三、推而广之四、总结 递归是极其重要的组建程序逻辑的一种方式，是作为程序员，编写计算机程序，学习计算机科学绕不过的一个话题。后面的【数据结构Java实现】都和递归脱不开关系。 我不会将递归作为算法的一个专栏，因为递归实际上是编写程序的一种结构，和循环是等价的。递归真正难的地方，在于与算法思想相结合——如排序，分治，搜索，图论算法，动态规划等；在于与...
深入学习Java数据结构与算法
本书涵盖了15个章节，包括基本概念、数组、排序算法、堆和队列、链表、递归、高级排序、二叉树、红黑树、哈希表以及图形算法等内容，并在附录中提供Applet和例程的运行指南，以及相关问题解答和书籍推荐。...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值