LeetCode链表——代码随想录

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

链表

203. 移除链表元素

初始版本：原始链表上操作
class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode cur = head;
        while(cur!= null && cur.val == val){
            cur = cur.next;
            head = cur;
        }//先判断头节点
        while(cur!= null && cur.next != null){
            if(cur.next.val == val){
                cur.next = cur.next.next;

            }else{
                 cur = cur.next;
            }
        }//确认此节点不为val后判断下一节点
        return head;

}
简化版本：虚拟头节点
class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode newhead = new ListNode(0,head);
        ListNode cur = newhead;
        while(cur.next!= null){
            if(cur.next.val == val){
                cur.next = cur.next.next;
            }
            else{
                cur = cur.next;
            }
        }//cur不会为空，所以不用判断 cur != null
        return newhead.next;
    }
}

在这里插入图片描述

707. 设计链表

初版设计
class MyLinkedList {

    public int val;
    public MyLinkedList next;

    public MyLinkedList() {
        val = -2;//表示无任何节点
    }
    
    public int get(int index) {
        MyLinkedList cur = this;
        for(int i=0; i<index && cur!= null ; i++ ) {
            cur = cur.next;
        }
        if(cur == null || cur.val == -2){
            return -1;
        }else{
            return cur.val;
        }     
    }
    
    public void addAtHead(int val) {
        if(this.val == -2){
            this.val = val;
        }else{
        MyLinkedList temp = new MyLinkedList();
        temp.val = this.val;
        temp.next = this.next;
        this.val = val;
        this.next = temp;
        }
    }
    
    public void addAtTail(int val) {
        if(this.val == -2){
            this.val = val;
        }else{
            MyLinkedList cur = this;
            MyLinkedList tail = new MyLinkedList();
            tail.val = val;
            while(cur.next != null){
                cur = cur.next;
            }
            cur.next = tail;
        }
    }
    
    public void addAtIndex(int index, int val) {
        if(index <= 0){
            addAtHead(val);
        }else{
            MyLinkedList cur = this;
            MyLinkedList beforeCur = cur;
            int i;
            for(i=0; i<index && cur!= null ; i++ ) {
                beforeCur = cur;
                cur = cur.next;
            }
            if(i == index){
                MyLinkedList temp = new MyLinkedList();
                temp.val = val;
                temp.next = beforeCur.next;
                beforeCur.next = temp;
            }
        }
    }
    
    public void deleteAtIndex(int index) {
       
        MyLinkedList newhead = new MyLinkedList();
        newhead.next =this;//新头节点
        MyLinkedList beforeCur = newhead;
        MyLinkedList cur = newhead.next;
        int i;
        if(index == 0){
            if(this.next != null){
                this.val = this.next.val;
                this.next = this.next.next;
                return;
            }
            else{
                this.val = -2;
            }
        }

        for(i=0; i<index && cur.next!= null ; i++ ) {
            beforeCur = cur;
            cur = cur.next;
        }
        if(i == index){
            beforeCur.next = cur.next;
        }

    }
}

/**
 * Your MyLinkedList object will be instantiated and called as such:
 * MyLinkedList obj = new MyLinkedList();
 * int param_1 = obj.get(index);
 * obj.addAtHead(val);
 * obj.addAtTail(val);
 * obj.addAtIndex(index,val);
 * obj.deleteAtIndex(index);
 */
代码随想录版

通过虚拟头节点来实现对所有结点的统一操作，引入size来实现链表的越界检查和方便的索引访问。

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

class MyLinkedList {
    int size; //方便越界检查
    ListNode sentinelHead; //虚拟头节点

    public MyLinkedList() {
        sentinelHead = new ListNode();
        sentinelHead.val = 0;
        size = 0;
    }

    public int get(int index) {
        if(index < 0 || index >= size){
            return -1;
        }
        ListNode position = sentinelHead;
        //虚拟头节点，所以需要<=
        for(int i = 0 ; i<=index ; i++){
            position = position.next;
        }
        return position.val;
    }

    public void addAtHead(int val) {
        addAtIndex(0,val);
    }

    public void addAtTail(int val) {
        addAtIndex(size,val);
    }

    public void addAtIndex(int index, int val) {
        if(index >size){
            return;
        }else if(index < 0){
            index = 0;
        }
        ListNode position = sentinelHead;
        //找到前驱,所以<
        for(int i = 0 ; i < index ; i++){
            position = position.next;
        }

        ListNode addPoint = new ListNode(val,position.next);
        position.next = addPoint;
        size++;
    }

    public void deleteAtIndex(int index) {
        if(index<0||index>=size){
            return;
        }
        ListNode position = sentinelHead;
        //找到前驱
        for(int i = 0 ; i < index ; i++){
            position = position.next;
        }
        position.next = position.next.next;
        size--;
    }

206. 反转链表

初版设计
class Solution {
    public ListNode reverseList(ListNode head) {
        
        ListNode cur = head;
        ListNode aftcur = null;
        ListNode precur = null;

        while(cur!= null){
            aftcur = cur.next;
            cur.next = precur;

            precur =cur;
            cur = aftcur;
        }

        return precur;
    }
}

在这里插入图片描述

递归法
class Solution {
    public ListNode reverse(ListNode pre,ListNode cur){
        if(cur == null){
            return pre;
        }
        ListNode aftcur = cur.next;
        cur.next = pre;

        return reverse(cur,aftcur);
    }

    public ListNode reverseList(ListNode head) {
        return reverse(null,head);
    }
}

第二种递归

// 从后向前递归
class Solution {
    ListNode reverseList(ListNode head) {
        // 边缘条件判断
        if(head == null) return null;
        if (head.next == null) return head;
        
        // 递归调用，翻转第二个节点开始往后的链表
        ListNode last = reverseList(head.next);
        // 翻转头节点与第二个节点的指向
        head.next.next = head;
        // 此时的 head 节点为尾节点，next 需要指向 NULL
        head.next = null;
        return last;
    } 
}

在这里插入图片描述

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

初版设计

无虚拟头节点

class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode pre = new ListNode();
        ListNode aft = null;
        ListNode cur = head;
        if(head != null && head.next!= null){
            head = head.next;
        }
        while(cur!=null){
            if(cur.next != null){
                pre.next = cur.next;
                aft = cur.next.next;;
                cur.next.next =cur;
                cur.next = aft;
                pre = cur;
                cur = aft;
            }else{
                cur= cur.next;
            }
        }
        return head;

    }
}
优化版

优化了判断条件，引入dummy头节点来实现头结点的转换

class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode dummyHead = new ListNode(0,head);
        ListNode pre = dummyHead;        
        ListNode aft = null;
        ListNode cur = head;
        while(cur!=null && cur.next != null){
            pre.next = cur.next;
            aft = cur.next.next;
            cur.next.next =cur;
            cur.next = aft;
            pre = cur;
            cur = aft;
        }
        return dummyHead.next;
    }
}

在这里插入图片描述

递归版
class Solution {
    public ListNode swapPairs(ListNode head) {

        if(head == null || head.next == null){
            return head;
        }

        ListNode next = head.next;//head是第一个节点,next是第二个节点，newNode是第三个节点。
        
        ListNode newNode = swapPairs(next.next);//递归到链尾

        next.next = head;
        head.next = newNode;//从队尾三个元素开始操作

        return next;//返回原第二个节点，即交换后的头节点

    }
}

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

初版双指针

双指针思想，满足条件时慢指针开始动

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummyHead = new ListNode(0,head);
        ListNode cur = head;
        ListNode preDeletecur = dummyHead;
        ListNode deletecur = head;

        for(int i=0; cur != null ; i++) {
            if(i - n>=0) {//每次判断快指针走的长度，进而更改慢指针。
                preDeletecur = deletecur;
                deletecur = deletecur.next;//可以优化，因为删除不用记本节点只需要记前驱节点
            }
            cur = cur.next;
        }
        preDeletecur.next = deletecur.next;
        return dummyHead.next;
    }
}
代码随想录版本

因为初版在每次循环中都需要额外的以此判断，而如果快指针已经满足条件后面就无需判断，所以可以优化，让快指针先走·。

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {

        ListNode dummyHead = new ListNode(0,head);
        ListNode preDeletecur = dummyHead;
        ListNode cur = head;
        while(--n > 0){
            cur = cur.next;
        }
        cur = cur.next;//再走一步，记忆需删除节点的前驱。
        while(cur != null){
            cur = cur.next;
            preDeletecur = preDeletecur.next;
        }
        preDeletecur.next = preDeletecur.next.next;
        return dummyHead.next;
    }
}

在这里插入图片描述

面试题 02.07. 链表相交

暴力解法，遍历两链表

时间复杂度为O(n^2)，重复取值严重。（732ms）

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {

        ListNode curA = headA;
        while(curA != null){
            ListNode curB = headB;
            while(curB != null){
                if(curA == curB){
                    return curB;
                }
                curB = curB.next;
            }
            curA = curA.next;
        }
        return null;
    }
}
代码随想录，尾部对齐

可以利用相交后，后续节点重复的原则，将链表尾部对齐后，同时遍历两链表即可找出重复部分。

时间复杂度O(3n)。（1ms）

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode curA = headA;
        ListNode curB = headB;
        int lenghtA = 0;
        int lenghtB = 0;
        while(curA != null) {
            curA = curA.next;
            lenghtA++;
        }//先两遍遍历得出两个链表的长度大小
        while(curB != null) {
            curB = curB.next;
            lenghtB++;
        }
        int gap;
        if(lenghtB >lenghtA){
            curA = headB;
            curB = headA;
            gap = lenghtB - lenghtA;
        }else{
            curA = headA;
            curB = headB;
            gap = lenghtA - lenghtB;
        }
        while(gap-- > 0){
            curA = curA.next;
        }
        while(curA != curB ){
            curA = curA.next;
            curB = curB.next;
        }
        return null;
    }
}

在这里插入图片描述

哈希解法

时间复杂度O(m+n)，空间复杂度O(m)

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        Set<ListNode> visited = new HashSet<ListNode>();
        ListNode temp = headA;
        while (temp != null) {
            visited.add(temp);
            temp = temp.next;
        }
        temp = headB;
        while (temp != null) {
            if (visited.contains(temp)) {
                return temp;
            }
            temp = temp.next;
        }
        return null;
    }
}
双指针法

其实也等价于尾部对齐，让两指针遍历完自己的指针后在遍历对方的，如果相交，则在交点相遇，如果不相交，则返回null。

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode pA = headA, pB = headB;
        while (pA != pB) {
            pA = pA == null ? headB : pA.next;
            pB = pB == null ? headA : pB.next;
        }
        return pA;
    }
}

在这里插入图片描述

142. 环形链表 II

初版：HashSet

借鉴链表相交思想，利用新空间存储节点，来判断重复出现的节点。

时间复杂度O(n)，空间复杂度O(n)

public class Solution {
    public ListNode detectCycle(ListNode head) {        
        ListNode cur = head;        
        Set<ListNode> visited = new HashSet<ListNode>();        
        while( cur != null) {            
            if(visited.contains(cur)) {                
                return cur;            
            }            
            visited.add(cur);            
            cur = cur.next;        
        }        
        return null;    
    }
}
双指针法

还可以利用环的性质，如果存在环，则一快一慢指针向后遍历一定会在环中相遇，而相遇的点与环的入口存在关系，如下图所示，(x + y) * 2 = x + y + n (y + z)，则可以得到 x = n (y + z) - y 或 x = (n - 1) (y + z) + z，表示如果一指针从头节点走，一指针从相遇点走（步长都为1），则一定会在入口相遇，即可得到环的入口节点。

时间复杂度O(n)，空间复杂度O(1)

我的:

public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode fast = head;
        ListNode slow = head;
        while(fast != null && fast.next != null){
            fast = fast.next.next;
            slow = slow.next;
            if(fast == slow){
                break;
            }
        }
        if(fast == null || fast.next == null){
            return null;
        }
        slow = head;
        while(slow != fast){
            slow = slow.next;
            fast = fast.next;
        }
        return fast;
    }
}

代码随想录:

public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode fast = head, slow = head;
        while(fast!= null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
            if(fast == slow) {//相遇节点
                slow = head;//调整一指针到头部
                while( slow != fast){
                    slow = slow.next;
                    fast = fast.next;
                }//x = (n - 1) (a + b) + b,相遇时即环入口
                return fast;
            }
        }
        return null;
    }
}

在这里插入图片描述

洋间
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode——重排链表
weixin_64394633的博客
05-09 310
题目原型： 给定一个单链表 L 的头节点 head ，单链表 L 表示为： L0→ L1→ … → Ln-1→ Ln 请将其重新排列后变为： L0→Ln→L1→Ln-1→L2→Ln-2→ … 不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。 示例 1: 输入: head = [1,2,3,4] 输出: [1,4,2,3] 示例 2: 输入: head = [1,2,3,4,5] 输出: [1,5,2,4,3] 中心思路： 如果我们认真观...
LeetCode 初级 - 回文链表
whdAlive 's blog
05-19 873
回文链表 请判断一个链表是否为回文链表。 示例 1: 输入: 1-&gt;2 输出: false 示例 2: 输入: 1-&gt;2-&gt;2-&gt;1 输出: true 分析 没有想到空间O(1)的算法，不过可以满足O(n)时间复杂度。 设置快慢两个指针遍历链表，并逆序记录前半段节点的值，与后半段节点顺次对比。 代码 /** * Definition for...
LeetCode代码随想录
死也不承认自己笨的博客
05-07 1119
代码随想录 (programmercarl.com) java 35.搜索插入位置 34.在排序数组中查找元素的第一个和最后一个位置 java 69.X的平方根 java java 27移除元素 c++ java 283.移动零 java 844.比较含退格的字符串 java:双指针版 java:栈版 97.有序数组的平方 c++ java
【leetcode刷题总结】——代码随想录（链表总结）
lingxw的博客
05-18 2939
什么是链表，链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）。
【leetcode刷题总结】——代码随想录（数组总结）
lingxw的博客
05-02 2297
按照数组-> 链表-> 哈希表->字符串->栈与队列->树->回溯->贪心->动态规划->图论->高级数据结构，再从简单刷起，做了几个类型题目之后，再慢慢做中等题目、困难题目。
Leetcode刷题记录——代码随想录
m0_56664025的博客
01-05 921
假设循环变量i代表终止位置，当i向后移动时，i前面的元素即是子数组序列即[0,i]，当i前面的元素满足条件时，从下标0开始依次前移起始位置改变滑动窗口的大小，找到最后一个满足条件的子数组，该子数组的长度即最小长度。可以采用暴力求解的方法，利用两个for循环，外层for循环负责遍历数组，控制子数组的起始下标，内层for循环负责控制子数组的终止下标（即满足子数组之和>=target时的下标）。其中需要注意的是，因为移除元素后下标为i的数组全部前移一位，因此外层for循环中的循环变量i也需要减一。
代码随想录-力扣刷题笔记
m0_49651195的博客
03-12 2001
数组是存放在连续内存空间上的相同数据类型的集合。要查找数组里的数据一般通过查找数据的下标索引的方式来查找。由于数组的这个特性，所以数组删除或添加元素的时候，不能直接进行删除操作。在增加或删除元素的时候，需要通过移动其他元素的地址来达到目的。给定一个n个元素有序的（升序）整型数组nums和一个目标值target，写一个函数搜索nums中的target，如果目标值存在返回下标，否则返回-1。输入：nums = [-1,0,3,5,9,12]输出：4解释：9 出现在nums中并且下标为4。
LeetCode解析——715.Range模块
01-08
题目： Range 模块是跟踪数字范围的模块。你的任务是以一种有效的方式设计和实现以下接口。 addRange(int left, int right) 添加半开区间 [left, right)，跟踪该区间中的每个实数。添加与当前跟踪的数字部分重叠的...
LeetCode刷题——Complex multiplication复数乘法
12-21
复数乘法题目的思路探讨与源码 复数乘法的题目如下图，该题属于字符串类的题目，主要考察split函数以及字符串函数转整型以及四则运算，虽然属于中级但是难度相对较低。只要区分实数部分和虚数部分即可。...
LeetCode刷题——91. 解码方法
12-20
题目 一条包含字母 A-Z 的消息通过以下方式进行了编码： ‘A’ -> 1 ‘B’ -> 2 … ...来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/decode-ways 思路 这个题有点像爬楼梯，但是
LeetCode刷题——矩阵置零
12-21
矩阵置零题目的思路探讨与源码 矩阵置零的题目如下图，核心把矩阵中当前0元素所在的行和列都重置为0，并且只能在当前矩阵上改动，不能新建矩阵，所以要使用下标进行标记，并最终重新赋值。 原创文章 40获赞 41访问...
LeetCode解题心得——反转链表（python）
12-21
题目 反转一个单链表。 示例： 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL 思路 1.递归 class Solution: def reverseList(self, head: ListNode) -> ListNode: if head == None or head.next == None: ...
LeetCode字符串——代码随想录
qq_45568467的博客
05-16 91
如果 s[i] 与 s[j + 1] 相同，那么就同时向后移动i 和j 说明找到了相同的前后缀，同时还要将j（前缀的长度）赋给next[i], 因为next[i]要记录相同前后缀的长度。如何判断在文本串s里出现了模式串t呢，如果j指向了模式串t的末尾，那么就说明模式串t完全匹配文本串s里的某个子串了。那么 s[i] 与 s[j+1] 不相同，就要找 j+1前一个元素在next数组里的值（就是next[j]）。因为j初始化为-1，那么i就从1开始，进行s[i] 与 s[j+1]的比较。
LeetCode数组——代码随想录
qq_45568467的博客
05-16 74
当用它作为算法的最坏情况运行时间的上界，就是对任意数据输入的运行时间的上界。递归算法的时间复杂度本质上是要看:。**那么思考一下 什么时候空间复杂度是 O(logn)呢？递归 **相当于从头加，用first和second来记录当前的两个数值，而不是重复计算同样的值。时间复杂度为O(2^n)，大量重复计算。空间复杂度就是O(n)。（递归深度为O(n)）
LeetCode回溯算法——代码随想录
qq_45568467的博客
06-09 260
回溯法也可以叫做回溯搜索法，它是一种搜索的方式，回溯是递归的副产品，只要有递归就会有回溯。回溯法解决的问题都可以抽象为树形结构，因为回溯法解决的都是在集合中递归查找子集，集合的大小就构成了树的宽度，递归的深度，都构成的树的深度。递归就要有终止条件，所以必然是一棵高度有限的树（N叉树）。大家可以从图中看出for循环可以理解是横向遍历，backtracking（递归）就是纵向遍历，这样就把这棵树全遍历完了，一般来说，搜索叶子节点就是找的其中一个结果了。一般模板如下： 时间复杂度 子集问题分析：排列问题分析：组合
代码随想录第五天|LeetCode242 & LeetCode349 & LeetCode202 & LeetCode1
weixin_62620458的博客
04-10 70
2023年4月10日22:18:15任务未完成，明天继续。2023年4月14日22:29:11缺乏C++语法知识学习，应尽快学习，弥补知识短板，否则代码不会写，也看不懂时隔5天才将这一任务完成。时间安排规划！！！
Leetcode刷题记录（代码随想录day12）
一个小码农
02-28 101
二叉树
代码随想录LeetCode | 一刷总结
weixin_40142386的博客
01-29 550
刷题要先完成，后完美：1.保持整体进度 >> 补之前进度 2.简单输出>>不输出。痛苦思考，以慢为快：1.先默写刷题，全部刷完再统一看题解 2.默写刷题虽好，但要计时保证进度 3.隔2-3天再默写检验掌握情况 4.后期复习时，可将多个章节穿插刷题
LeetCode：经典题之206、92 题解及延伸
最新发布
Chiefavefan
06-22 1067
LeeCode经典题之206、92｜反转链表 I 和 II｜类与结构体｜访问修饰符
rust leetcode 链表
05-10
例如，针对 LeetCode 中的链表题目，我们可以用 Rust 语言来编写解法，例如，反转链表，合并两个有序链表，删除链表中的重复元素等等，这样可以更好地熟悉 Rust 语言的使用和链表的操作，提高算法和编程能力。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值