LeetCode---链表

最新推荐文章于 2024-06-14 15:02:13 发布
最新推荐文章于 2024-06-14 15:02:13 发布
阅读量91 收藏
点赞数
分类专栏： LeetCode 文章标签： 链表 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52675592/article/details/115165663
版权

文章目录

160.相交链表

题目大意

编写一个程序，找到两个单链表相交的起始节点。
在这里插入图片描述

解题思路

第一轮指针p走完ListNode A之后指向ListNode B的头，去走ListNode B的路，同理，指针q走完ListNode B之后指向ListNode A的头，去走ListNode A的路。第一轮走完之后，他们之间相差的刚好是两条链表的长度差，然后让他们再走一遍对方的路，如果相遇就表示有交点。长的走完走短的，短的走完走长的。

代码实现

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        //定义两个指针
        if(headA==null||headB==null){
            return headA==null?headA:headB;
        }
        ListNode p=headA;
        ListNode q=headB;
        while(p!=q){
            p=(p==null)?headB:p.next;
            q=(q==null)?headA:q.next; 
        }
        return p;
    }
}

206.反转链表

题目大意

反转一个单链表。
在这里插入图片描述

解题思路

（一）栈实现
遍历链表将其压入栈中，然后将栈中的元素输出就是对应反转链表之后的结果。
（二）迭代方式
对链表的指向进行改变，需要定义一个前驱节点prev和后继节点next。
（三）递归方式
递归的将整个链表进行反转。

代码实现

（一）栈实现：

class Solution {
    public ListNode reverseList(ListNode head) {
        if(head==null||head.next==null){
            return head;
        }
        //迭代用栈来解决
        LinkedList<ListNode> stack=new LinkedList<>();
        ListNode p=head;
        while(p!=null){
            stack.add(p);
            p=p.next;
        }
        ListNode q=stack.removeLast();
        ListNode newhead=q;
        while(!stack.isEmpty()){
            q.next=stack.removeLast();
            q=q.next;
        }
        q.next=null;
        return newhead;
    }
}

(二)迭代方式：

class Solution {
    public ListNode reverseList(ListNode head) {
        //迭代
        ListNode prev=null;
        ListNode curr=head;
        while(curr!=null){
            ListNode next=curr.next;
            curr.next=prev;
            prev=curr;
            curr=next;
        }
        return prev;       
    }
}

（三）递归版本：

class Solution {
    public ListNode reverseList(ListNode head) {
        //递归
        if(head==null||head.next==null){
            return head;
        }
        ListNode newhead=reverseList(head.next);
        head.next.next=head;
        head.next=null;
        return newhead;  
    }
}

21.合并两个有序链表

题目大意

将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
在这里插入图片描述

解题思路

（一）迭代实现：
因为是两个升序的链表，创建一个新链表p，依次比较两个链表上的每个元素，然后放到新链表上。最后将没遍历完的剩余的链表直接链接到新链表上。

 ListNode p=new ListNode(-1);

（二）递归实现：
比较两个链表上值得大小，然后递归的进行合并剩余的链表元素。

代码实现

（一）迭代

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if(l1==null||l2==null){
            return l1==null?l2:l1;
        }
        ListNode p=new ListNode(-1);
        ListNode q=p;
        while(l1!=null&&l2!=null){
            if(l1.val<=l2.val){
                p.next=l1;
                l1=l1.next;
                p=p.next;
            }else{
                p.next=l2;
                l2=l2.next;
                p=p.next;
            }
        }
        p.next=(l1==null)?l2:l1;
        return q.next;
    }
}

(二）递归实现

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if(l1==null||l2==null){
            return l1==null?l2:l1;
        }
        ListNode res=new ListNode();
        //递归实现
        if(l1.val<=l2.val){
            res=l1;
            res.next=mergeTwoLists(l1.next,l2);
        }else{
            res=l2;
            res.next=mergeTwoLists(l1,l2.next);
        }
        return res;
    }
}

83.删除排序链表中的重复元素

题目大意

存在一个按升序排列的链表，给你这个链表的头节点 head ，请你删除所有重复的元素，使每个元素 只出现一次 。
返回同样按升序排列的结果链表。

解题思路

(一）迭代法：
遍历链表，将重复的元素删除。
(二）递归实现:
如果头元素和头元素的下一个元素的值相等，那么就将头元素删除；如果不等，就对递归的对后面的元素进行重复元素的删除。

代码实现

(一）迭代法

class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        //使用双指针
        if(head==null||head.next==null){
            return head;
        }
        ListNode p=head;
        ListNode q=p.next;
        while(q!=null){
            if(p.val!=q.val){
                p=q;
                q=q.next;
            }else{
                p.next=q.next;
                q=q.next;
            }
        }
        return head;
    }
}

(二）递归实现

class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if(head==null||head.next==null){
            return head;
        }
        if(head.val!=head.next.val){
            head.next=deleteDuplicates(head.next);
        }else{
            head=deleteDuplicates(head.next);
        }      
        return head;
    }
}

19. 删除链表的倒数第 N 个结点

题目大意

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
进阶：你能尝试使用一趟扫描实现吗？
在这里插入图片描述

解题思路

（一）快慢指针：
利用快慢指针找到链表的倒数第k个元素，进行删除。注意：p.next才是倒数第k个元素。
（二）栈实现：
将链表的所有元素都压入栈中，然后出栈k个元素，即可得到倒数第k个元素。
注意：

  1. 出栈的元素的下一个元素才是要删除的元素。
  2. 栈的push和add方法是不同的，这里要使用push方法，push是尾插，add是头插。
    (三) 通过计算长度实现：
    计算整个链表的长度，然后通过for循环得到倒数第k个元素的前驱，进而进行删除。
for(int i=1;i<length-n+1;++i){
            p=p.next;
        }

代码实现

（一）快慢指针

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        //快慢指针
        if(head==null){
            return head;
        }
        ListNode q=head;
        while(n--!=0){
            q=q.next;
        }
        if(q==null){
            return head.next;
        }
        ListNode p=head;
        while(q.next!=null){
            q=q.next;
            p=p.next;
        }
        p.next=p.next.next;
        return head;
    }
}

（二）栈实现（此处需注意push方法和add方法的区别）

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        //栈实现
        LinkedList<ListNode> stack = new LinkedList<ListNode>();
        ListNode p=head;
        //入栈
        while(p!=null){
            stack.push(p);
            p=p.next;
        }
        for(int i=0;i<n;i++){
            stack.pop();
        }
        ListNode q=stack.peek();
        if(q==null){
            return head.next;
        }
        q.next=q.next.next;
        return head;  
    }
}

(三）计算长度实现

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        //利用长度实现
        ListNode m=new ListNode(0,head);
        ListNode p=m;
        int length=len(head);
        for(int i=1;i<length-n+1;++i){
            p=p.next;
        }
        if(p==null){
            return head.next;
        }
        p.next=p.next.next;
        return m.next;
    }
    public int len(ListNode head){
        int cnt=0;
        if(head==null){
            return cnt;
        }
        while(head!=null){
            cnt++;
            head=head.next;
        }
        return cnt;
    }
}

24.两两交换链表中的节点

题目大意

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。
你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
在这里插入图片描述

解题思路

(一）递归实现:
将相邻的元素互换，将head的后一个元素称为新的头元素newhead,head的后一个元素就变成了新的头元素newhead.next相邻元素交换后的结果，新的头元素newhead的下一个元素就变成了原来的head,实现了前两个元素的互换，其余的就交给递归来实现。返回新的头节点newhead即可。
(二）迭代实现：
构建一个新的链表节点dummyhead表示前驱节点，在原始链表上通过修改next指针的指向来交换相邻的两个节点。

代码实现

(一）递归实现:

class Solution {
    public ListNode swapPairs(ListNode head) {
        //递归实现
        if(head==null||head.next==null){
            return head;
        }
        ListNode newhead=head.next;
        head.next=swapPairs(newhead.next);
        newhead.next=head;
        return newhead;
    }
}

(二）迭代实现

class Solution {
    public ListNode swapPairs(ListNode head) {
        //迭代实现
        if(head==null||head.next==null){
            return head;
        }
        ListNode dummyhead=new ListNode(-1);
        ListNode newhead=dummyhead;
        dummyhead.next=head;
        while(dummyhead.next!=null&&dummyhead.next.next!=null){
            ListNode p=dummyhead.next;
            ListNode q=dummyhead.next.next;
            dummyhead.next=q;
            p.next=q.next;
            q.next=p;
            dummyhead=p;   
        }
       return  newhead.next;
    }
}

445.两数相加 II

题目大意

给你两个 非空 链表来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储一位数字。将这两数相加会返回一个新的链表。
你可以假设除了数字 0 之外，这两个数字都不会以零开头。
进阶：
如果输入链表不能修改该如何处理？换句话说，你不能对列表中的节点进行翻转。
在这里插入图片描述

解题思路

利用栈来实现，因为是在最低位开始运算存在进位的问题，所以可以使用栈来实现链表的反转，创建两个栈分别存储两个链表中的元素，依次取出两个栈中的元素进行加和并创建一个变量来记录进位，注意：先计算出来的是结果的末尾，所以后来计算的要进行链表的头插才会产生正确的结果。

代码实现

class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        //利用栈来解决
        if(l1==null||l2==null){
            return l1==null?l2:l1;
        }
        Stack<Integer> s1=buildStack(l1);
        Stack<Integer> s2=buildStack(l2);
        ListNode head=new ListNode(-1);
        //定义一个变量表示进位
        int carry=0;
        while(!s1.isEmpty()||!s2.isEmpty()||carry!=0){
            int x=s1.isEmpty()?0:s1.pop();
            int y=s2.isEmpty()?0:s2.pop();
            int sum=x+y+carry;
            carry=sum/10;
            ListNode node=new ListNode(sum%10);
            //注意最终的结果应该是往前插的
            node.next=head.next;
            head.next=node;
        }
        return head.next;

    }
    public Stack<Integer> buildStack(ListNode l){
        Stack<Integer> stack=new Stack<>();
        while(l!=null){
            stack.push(l.val);
            l=l.next;
        }
        return stack;
    }
}

234.回文链表

题目大意

请判断一个链表是否为回文链表。
在这里插入图片描述

解题思路

(一）利用栈来实现：
将整个链表中的元素放入栈中，然后比较出栈的元素和原始链表中的元素顺序是否相等。
空间复杂度：O(n)
(二）快慢指针：
利用快慢指针找到链表的中点，将链表的后半段进行反转，然后比较前半段和后半段元素是否相同。
注意快慢指针停止的条件：

ListNode slow=head;
ListNode fast=head;
while(fast.next!=null&&fast.next.next!=null){
            slow=slow.next;
            fast=fast.next.next;
        }

(三）递归
使用递归反向迭代节点，同时使用递归函数外的变量向前迭代，这样就可以判断链表是否是回文的了。

代码实现

(一)利用栈来实现

class Solution {
    public boolean isPalindrome(ListNode head) {
        if(head==null||head.next==null){
            return true;
        }
        ListNode node=head;
        Stack<ListNode> stack=new Stack<>();
        while(node!=null){
            stack.push(node);
            node=node.next;
        }
        ListNode p=head;
        ListNode q=stack.pop();
        while(!stack.isEmpty()&&p.next!=null){
            if(p.val!=q.val){
                return false;
            }
            p=p.next;
            q=stack.pop();
        }
        return true;
    }
}

(二）快慢指针找中间节点

class Solution {
    public boolean isPalindrome(ListNode head) {
        //利用快慢指针找到链表的中点
        //然后将链表的后半段翻转
        //进而比较链表的前后半段是否相等
        if(head==null||head.next==null){
            return true;
        }
        ListNode slow=head;
        ListNode fast=head;
        while(fast.next!=null&&fast.next.next!=null){
            slow=slow.next;
            fast=fast.next.next;
        }
        //偶数节点，让 slow 指向下一个节点
        if (fast.next != null) slow = slow.next;
        //切割链表
        cut(head,slow);
        return isEqual(head,reverse(slow));
    }
    public void cut(ListNode l1,ListNode l2){
        while(l1.next!=l2){
            l1=l1.next;
        }
        l1.next=null;
    }
    public ListNode reverse(ListNode head){
        //迭代翻转链表
        ListNode newhead=null;
        while(head!=null){
            ListNode nextnode=head.next;
            head.next=newhead;
            newhead=head;
            head=nextnode;
        }
        return newhead;
    }
    public boolean isEqual(ListNode l1,ListNode l2){
        if(l1==null&&l2==null){
            return true;
        }else if(l1==null||l2==null){
            return false;
        }
        while(l1!=null&&l2!=null){
            if(l1.val!=l2.val){
                return false;
            }
            l1=l1.next;
            l2=l2.next;
        }
        return true;
    }
}

(三）递归实现

class Solution {
    private ListNode frontPointer;
    public boolean recursivelyCheck(ListNode currentNode){
        if(currentNode!=null){
            if(!recursivelyCheck(currentNode.next)){
                return false;
            }
            if(currentNode.val!=frontPointer.val){
                return false;
            }
            frontPointer=frontPointer.next;
        }
        return true;
    }
    public boolean isPalindrome(ListNode head) {
        //递归来实现
        frontPointer=head;
        return recursivelyCheck(head);    
    }
}

725.分隔链表

题目大意

给定一个头结点为 root 的链表, 编写一个函数以将链表分隔为 k 个连续的部分。
每部分的长度应该尽可能的相等: 任意两部分的长度差距不能超过 1，也就是说可能有些部分为 null。
这k个部分应该按照在链表中出现的顺序进行输出，并且排在前面的部分的长度应该大于或等于后面的长度。
返回一个符合上述规则的链表的列表。
举例： 1->2->3->4, k = 5 // 5 结果 [ [1], [2], [3], [4], null ]
在这里插入图片描述

解题思路

计算整个链表元素的数目，算出每一部分的元素数，注意不能整除时的处理即可，一个个的加到每一段上。

代码实现

class Solution {
    public ListNode[] splitListToParts(ListNode root, int k) {
        //首先计算链表中的元素个数
        int num=0;
        ListNode node=root;
        while(node!=null){
            num++;
            node=node.next;
        }

        int mod=num%k;
        int size=num/k;
        ListNode[] res=new ListNode[k];
        node=root;
        for(int i=0;node!=null&&i<k;i++){
            res[i]=node;
            int curSize=size+(mod-->0?1:0);
            for(int j=0;j<curSize-1;j++){
                node=node.next;
            }
            ListNode next=node.next;
            node.next=null;
            node=next;
        }
        return res;
    }
}

328. 奇偶链表

题目大意

给定一个单链表，把所有的奇数节点和偶数节点分别排在一起。请注意，这里的奇数节点和偶数节点指的是节点编号的奇偶性，而不是节点的值的奇偶性。
请尝试使用原地算法完成。你的算法的空间复杂度应为 O(1)，时间复杂度应为 O(nodes)，nodes 为节点总数。
在这里插入图片描述

解题思路

定义指向奇数和偶数的两个节点，遍历原始的链表分别向两个节点上链接相应的奇偶元素即可。同时要注意循环得条件：偶数的next不要为空。

while(odd!=null&&even!=null&&even.next!=null){
}

代码实现

class Solution {
    public ListNode oddEvenList(ListNode head) {
        if(head==null||head.next==null){
            return head;
        }
        ListNode odd=head;
        ListNode even=head.next;
        ListNode next=even;
        while(odd!=null&&even!=null&&even.next!=null){
            odd.next=even.next;
            odd=odd.next;
            even.next=odd.next;
            even=even.next;
        }
        odd.next=next;
        return head;
    }
}
想当程序媛的秀妍
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode-链表笔记
02-06
leetcode-链表笔记
leetcode-java
03-21
leetcode-java 课程1：Java入门与基础算法 Fizz Buzz-> Java语言 字符串和数组 类和对象 参考 界面 数据结构： 链表 栈 阴离子 树 哈希表 算法： 枚举 递归 分治 排序 在IDE里打印输出，并输出分行-> System.out....
LeetCode-反转链表
zouyou07的博客
04-20 216
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 反转链表题目描述一、迭代法1.思路2.图示3.代码二、递归1.引入库2.读入数据总结 题目描述 反转一个单链表。 示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL LeetCode 206. 反转链表 一、迭代法 1.思路 标记head和cur均指向头结点 记录temp指向head的下个节点的next，即temp=head
LeetCode--链表
weixin_43323252的博客
11-25 207
记录一下刷题
LeetCode - 环形链表
小小太空人的博客
04-26 369
我们考虑使用追及相遇来解决。我们使用快慢指针fast和slow，初始化它们都为头结点，然后让slow一次走一步，fast一次走两步，当slow进环时，fast肯定在环里，这个时候它们开始追及。因为fast的步长是slow的两倍，所以它们之间的距离每走一次是减小1的，它们之间的距离逐渐逼近，这样slow和fast一定可以相遇。当它们距离减小到0时，即它们相遇，这个时候就可以确定链表肯定有环。
LeetCode--反转链表
Yshasd的博客
11-30 213
本题是LeetCode初级算法链表部分的题目，反转链表也是数据结构的基本操作之一
Leetcode- 环形链表 II
2302_78381559的博客
05-04 697
142. 环形链表 II - 力扣（LeetCode）
leetcode-回文链表
qq_38037870的博客
02-28 341
【代码】leetcode-回文链表。
leetcode-相交链表
qq_38037870的博客
02-28 103
【代码】leetcode-相交链表。
LeetCode--合并两个有序链表
Yshasd的博客
12-02 750
本题是LeetCode初级算法中一道关于链表的题，其中的方法包括但不限于递归、迭代等等，后续在寒假可能会使用不同的语言Java、Python、javascript等语言去实现这些算法。
Leetcode-链表的中间结点
随缘更新
12-07 245
C实现
leetcode-链表操作
github_39605284的博客
12-16 423
反转 部分反转 删除重复元素 删除倒数第k个节点 环形链表 环形链表入口 相交链表
leetcode-86 分隔链表
01-08
给定一个链表和一个特定值 x，对链表进行分隔，使得所有小于 x 的节点都在大于或等于 x 的节点之前。 你应当保留两个分区中每个节点的初始相对位置。 示例: 输入: head = 1->4->3->2->5->2, x = 3 输出: 1->2->2->4-...
【leetcode-链表】环形链表
12-21
给定一个链表，判断链表中是否有环。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。 示例 1： 输入：head = [3,2,0,-4...
LeetCode-[链表]-翻转链表
01-07
1. 双指针迭代翻转链表 翻转链表和交换两个变量的操作大同小异。 首先需要一个prev指针（指着当前节点的前一个节点），一个cur指针（指着当前节点） 翻转链表需要注意的一点是：链表之间靠指针连接，如果贸然将某个...
【仿真建模-anylogic】FlowchartPort原理解析
zhaoyaxuan001的博客
06-14 352
FlowchartPort是流图组件端口的基类，一般不会直接使用；如果需要自行封装组件库时会用到；FlowchartPort继承Port类，并定义了一系列抽象函数；用于输入端口判定此刻是否不能接收Agent。用于输出端口判定是否有Agent准备离开。判定端口是否发生错误。
（Javascript）AI数字人mp4转canvas播放并去除背景绿幕
lx_nhs的博客
06-12 507
去除前：去除后： 3、可能会出现的报错 （1）视频路径跨域问题：解决：vue开启代理
盲盒App开发时有哪些技术框架可以借鉴
最新发布
bytekj的博客
06-14 577
在开发盲盒App时，可以根据项目需求和团队技术栈选择合适的技术框架。前端可以选择微信小程序框架、React Native或Vue.js等；后端可以选择Node.js或Spring Boot等；数据库可以选择MySQL或MongoDB等。同时，还需要考虑缓存、消息队列、支付和物流接口等其他技术来完善应用的功能和性能。
【Java02】Java中数组的定义与初始化
饮冰室
06-10 626
推荐第一种方式。这种方式容易让人理解，数据类型是type[]，对象名称是arrayName。第二种方式有些老旧了。由于数组是一种引用变量（也就是一个指针），所以定义的时候还没有指向任何有效的内存空间，因此在定义数组的时候不能指定数组的长度，也不能直接使用。必须进行初始化。可以使用var让系统自动推断变量类型，既可以用于静态初始化，也可以用于动态初始化。
leetcode-5:实现链表的首尾链接
12-30
leetcode-5题要求我们实现链表的首尾链接，即将链表中最后一个节点的next指针指向链表中的第一个节点，并将链表中的第一个节点的prev指针指向链表中最后一个节点。 解题思路如下： 1. 首先，判断链表是否为空，若为...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值