电信保温杯笔记——代码随想录 刷题攻略 链表

已于 2022-02-27 21:37:07 修改
阅读量758 收藏
点赞数
分类专栏： 算法与数据结构 文章标签： 链表 leetcode 数据结构
于 2022-01-21 14:44:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_39448069/article/details/122603521
版权

电信保温杯笔记——代码随想录 刷题攻略 链表

电信保温杯笔记——代码随想录 刷题攻略

代码随想录 刷题攻略
电信保温杯笔记——代码随想录 刷题攻略

1.关于链表，你该了解这些！

讲义地址

2.链表：听说用虚拟头节点会方便很多？

讲义地址

203.移除链表元素

leetcode地址

使用伪头：

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode dummyHead = new ListNode(0, head);
        ListNode temp = dummyHead;
        while (temp.next != null){
            if(temp.next.val == val){
                temp.next = temp.next.next;
            }else {
                temp = temp.next;
            }
        }
        return dummyHead.next;
    }
}

在这里插入图片描述

总结

伪头使用前提：需要定位一个节点的上一个节点并使用它的next指针。

3.链表：一道题目考察了常见的五个操作！

讲义地址

707.设计链表

leetcode地址

class MyLinkedList {
    int size;
    ListNode head;
    public MyLinkedList() {
        size = 0;
        head = null;
    }

    public int get(int index) {
        if(index < 0 || index >= size){
            return -1;
        }
        ListNode temp = head;
        while (index > 0){
            temp = temp.next;
            index--;
        }
        return temp.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;
        }
        ListNode dummyHead = new ListNode(0, head);
        ListNode temp = dummyHead;
        int loop = Integer.min(index, size);
        while (loop > 0){
            temp = temp.next;
            loop--;
        }
        // 此时temp指向该删节点的上一个节点
        ListNode newNode = new ListNode(val, temp.next);
        temp.next = newNode;
        size++;
        head = dummyHead.next;
    }

    public void deleteAtIndex(int index) {
        if (index >=0 && index < size){
            ListNode dummyHead = new ListNode(0, head);
            ListNode temp = dummyHead;
            while (index > 0){
                temp = temp.next;
                index--;
            }
            // 此时temp指向该删节点的上一个节点
            temp.next = temp.next.next;
            head = dummyHead.next;
            size--;
        }
    }
}

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

在这里插入图片描述

总结

如果要找索引为 index 的节点的话：

        ListNode temp = head;
        while (index > 0){
            temp = temp.next;
            index--;
        }
        // 此时temp就是要找的节点

如果要找索引为 index 的节点的上一个节点的话：

            ListNode dummyHead = new ListNode(0, head);
            ListNode temp = dummyHead;
            while (index > 0){
                temp = temp.next;
                index--;
            }
            // 此时temp指向该删节点的上一个节点

如果增加或者删除节点后，一定要重新定位head节点

            ListNode dummyHead = new ListNode(0, head);
            ListNode temp = dummyHead;
			使用temp变量进行增加或者删除节点操作后
            head = dummyHead.next;

4.链表：听说过两天反转链表又写不出来了？

讲义地址

206.反转链表

leetcode地址

方法1

三指针：last，cur，next
在这里插入图片描述

/**
 * Definition for singly-linked 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; }
 * }
 */
 // 三指针
class Solution {
    public ListNode reverseList(ListNode head) {
        if(head == null){
            return null;
        }
        ListNode last = null;
        ListNode cur = head;
        ListNode next = head.next;
        while (next != null){
            cur.next = last;
            last = cur;
            cur = next;
            next = next.next;
        }
        cur.next = last;
        return cur;
    }
}

在这里插入图片描述

方法2

官方：也是使用三指针，但以cur作为循环条件

/**
 * Definition for singly-linked 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; }
 * }
 */
// 三指针
class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode prev = null;
        ListNode cur = head;
        ListNode temp = null;
        while (cur != null) {
            temp = cur.next;// 保存下一个节点
            cur.next = prev;
            prev = cur;
            cur = temp;
        }
        return prev;
    }
}

在这里插入图片描述

5.链表：两两交换链表中的节点

讲义地址

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

leetcode地址

/**
 * Definition for singly-linked 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; }
 * }
 */
 class Solution {
    public ListNode swapPairs(ListNode head) {
        if (head == null){
            return null;
        }
        if(head.next == null){
            return head;
        }
        ListNode dummyHead = new ListNode(0, head);
        ListNode prev = dummyHead;
        ListNode cur1 = head;
        ListNode cur2 = null;
        ListNode temp = null;
        while (cur1 != null){
            cur2 = cur1.next;
            if(cur2 == null){
                break;
            }else {
                temp = cur2.next;
                cur2.next = cur1;
                cur1.next = temp;
                prev.next = cur2;
                prev = cur1;
                cur1 = temp;
            }
        }
        return dummyHead.next;
    }
}

在这里插入图片描述

总结

这题和上题都使用了prev，cur，temp指针，不同的是上一题一开始prev = null，这题prev = dummyHead，关键在于有没有使用到prev.next指针，用到则需要使用伪头。并且最好以cur作为循环条件。

核心代码

 class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode dummyHead = new ListNode(0, head);
        ListNode prev = dummyHead;
        ListNode cur = head;
        ListNode temp = null;
        while (cur1 != null){
        }
    }
}

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

讲义地址

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

leetcode地址

/**
 * Definition for singly-linked 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; }
 * }
 */
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        int size = 1;
        ListNode dummyHead = new ListNode(0, head);
        ListNode prev = dummyHead;
        ListNode cur = head;
        while (cur.next != null){
            cur = cur.next;
            prev = prev.next;
            size++;
        }
        if(n == 1){
            prev.next = null;
            return dummyHead.next;
        }
        prev = dummyHead;
        cur = head;
        while (size > n){
            cur = cur.next;
            prev = prev.next;
            size--;
        }
        prev.next = cur.next;
        return dummyHead.next;
    }
}

在这里插入图片描述

7.链表：链表相交

讲义地址

面试题 02.07. 链表相交

leetcode地址

方法1

2个链表都遍历，求出长度，和长度差，让长度长的链表先走长度差的遍历，然后2个链表再同时开始。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if (headA == null || headB == null) {
            return null;
        }
        int sizeA = 0;
        ListNode curA = headA;
        while (curA != null) {
            curA = curA.next;
            sizeA++;
        }
        int sizeB = 0;
        ListNode curB = headB;
        while (curB != null) {
            curB = curB.next;
            sizeB++;
        }
        curA = headA;
        curB = headB;
        int delta = Math.abs(sizeA - sizeB);
        int residue = Integer.min(sizeA, sizeB);
        if(sizeA > sizeB){
            while (delta > 0){
                curA = curA.next;
                delta--;
            }
        }else {
            while (delta > 0){
                curB = curB.next;
                delta--;
            }
        }
        while (residue > 0){
            if (curA == curB){
                return curA;
            }
            curA = curA.next;
            curB = curB.next;
            residue--;
        }
        return null;
    }
}

在这里插入图片描述

方法2

思路新奇，代码简洁
在这里插入图片描述

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

作者：jyd
链接：https://leetcode-cn.com/problems/intersection-of-two-linked-lists-lcci/solution/mian-shi-ti-0207-lian-biao-xiang-jiao-sh-b8hn/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

在这里插入图片描述

8.链表：环找到了，那入口呢？

讲义地址

142.环形链表II

leetcode地址

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode fast = head;
        ListNode slow = head;
        while (fast != null){
            if (fast.next != null){
                slow = slow.next;
                fast = fast.next.next;
                if(fast == slow){
                    break;
                }
            }else {
                return null;
            }
        }
        // 此时fast在环内，接下来用面试题 02.07. 链表相交的方法找环入口
        ListNode curA = head;
        while (curA != slow){
            curA = curA != null ? curA.next : fast;
            slow = slow != null ? slow.next : head;
        }
        return curA;
    }
}

在这里插入图片描述

小结

使用快慢指针，快指针走2步，慢指针走1步，使2指针在环中相遇，以相遇点作为新链表的头结点，与旧链表一起，使用上一题（面试题 02.07. 链表相交）的方法求环入口。

核心代码

链表使用快慢指针

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

9.链表：总结篇！

讲义地址

电信保温杯
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
代码随想录刷题思路与心得11|前序，中序和后序遍历二叉树
weixin_64693723的博客
10-04 405
代码随想录学习
《剑指Offer》刷题笔记——面试题24. 反转链表
01-20
3、代码实现 # Definition for singly-linked list. # class ListNode: # def __init__(self, x): # self.val = x # self.next = None from collections import deque class Solution: def reverseList(self, head:...
代码随想录训练营第十一天 | 题20 题1047 题150
weixin_44489598的博客
11-27 2014
代码随想录训练营第十一天 | 题20 题1047 题150
代码随想录一刷总结（leetcode解题整理）
m0_64144465的博客
04-24 967
不知不觉两个月过去了，陆陆续续还是把代码随想录一刷结束，很早之前就知道代码随想录的存在，但是一直没有能一股气把所有题目过一遍，刚开学的时候正好看到算法训练营的报名，想着趁此机会让自己的算法刷题踏上正轨，作为结尾，把这段时间的题目好好整理一遍思路，作为后面刷题的基石我的整理方式是模拟实战做题时的感受，主要想法是提取问题本质尽可能化为具象的数学模型往后会持续更新，主要是记录实战过程中遇到的题目将其归类到后面的思想方法中去。
一、代码随想录刷题——数组
Tommy__li的博客
08-08 707
给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值 target，返回 [-1, -1]。你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。............
面试题链表相交—代码随想录
usa_ham的博客
02-20 66
给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null。如图，若求AB两个链表的相交结点指针。即找到AB的长度查，然后按照差值移动较长链表的指针（这里是curA），使之与短链表指针对齐。第二步：对curA和curB进行遍历对比，如果有一样的值，直接return。第一步需要将AB两个链表尾部对齐。
LeetCode刷题笔记——19. 删除链表的倒数第N个节点
12-21
  这道题本质上和《剑指Offer》刷题笔记——面试题22. 链表中倒数第k个节点是一样的。都可以用单指针两次遍历或者双指针一次遍历解决。 2、代码实现 # Definition for singly-linked list. # class ListNode: # ...
LeetCode刷题笔记——#21. 合并两个有序链表
12-22
###### leetcode 代码主体 ###### class Solution: def mergeTwoLists(self, l1, l2): if l1 is None: return l2 elif l2 is None: return l1 elif l1.val ListNode: prenode = ListNode(0)
《剑指Offer》刷题笔记——面试题22. 链表中倒数第k个节点
12-22
3、代码实现 # Definition for singly-linked list. # class ListNode: # def __init__(self, x): # self.val = x # self.next = None class Solution: def getKthFromEnd(self, head: ListNode, k: int) -> ...
代码随想录链表篇——链表相交（三种方法）
qq_39473176的博客
09-06 586
刷题总结
代码随想录刷题思路与心得01| 704. 二分查找、27. 移除元素
weixin_64693723的博客
09-21 630
代码随想录学习心得
ProgrammerCarl总结
weixin_53833977的博客
05-06 1307
文章目录前言一、数组二、哈希表三、字符串四、栈和队列五、二叉树六、回溯七、贪心八、动态规划 前言 Carl哥在代码随想录的总结让人受益匪浅，仅基于个人理解的角度做部分总结，部分内容引用原文中的概念，所以建议配合原链接一同阅读。不定期完善。 原链接如下：《代码随想录》 一、数组 Tips： 看到数组是有序数组，都可以想一想是否可以使用二分法。 不要以为for里放一个while就以为是O(n^2)， 主要是看每一个元素被操作的次数，每个元素在滑动窗后进来操作一次，出去操作一次，每个元素都是被操作两次，所以时
leetcode 刷题记录，数组部分，代码随想录刷题顺序
yyy199869的博客
12-01 2574
看了好多攻略，打算第一遍刷题顺序跟着 代码随想录 ：数组、链表、哈希表、字符串、双指针法、栈与队列、二叉树、回溯算法 、贪心算法、动态规划、单调栈 题外话：小白一枚，打算刷题提高编程能力，由于现在在公司算法部门实习，所以使用python语言，打算明年秋招之前用java或者c++再刷一遍。下面纯记录个人刷题日记及代码。 代码随想录：代码随想录 (programmercarl.com) DAY 1 704.二分查找 704. 二分查找 - 力扣（LeetCode） cla...
火爆Github的刷题攻略，现在配套网站上线了！！力扣刷题网站，刷题路线
代码随想录
08-11 2603
你所期盼的，终将实现
BAT程序员总结的力扣刷题指南，已经在Github了！！刷题顺序，优质题解一网打尽！
代码随想录
01-23 4911
最强刷题攻略！！
电信保温杯笔记——代码随想录 刷题攻略（持续更新）
sinat_39448069的博客
01-20 743
代码随想录 刷题攻略 笔记 代码随想录 刷题攻略 代码随想录 刷题攻略 数组 笔记
刷leetcode不知道从哪里刷起？？ 来看看，我把刷题题目顺序都排好了，每道题还带详细题解！
热门推荐
代码随想录
12-27 6万+
相信很多小伙伴刷题的时候面对力扣上近两千到题目，感觉无从下手，我花了半年时间整理了这篇leetcode刷题最强指南，经典题目的顺序和对应题解来排好了，按照list一道一道刷就可以了，绝对是最强攻略！
《代码随想录1-7章》二刷题解及心得体会
qq_44732492的博客
03-15 1619
0 前言   昨天结束了《代码随想录》一刷（只看不上机操作，目的是对算法建立初步的认识），历时一个多月。在第一遍阅读之后，有许多不理解的地方，在书中用问号标识。第二遍阅读本书目的就是想通过上机训练将之前的疑惑解开。另外，本书题解和内容仍有一小部分错误，希望在此更正。 1 第一章 面试要知己知彼   本章主要介绍面试流程、如何写简历及代码规范。本书中的C++代码严格按照Google C++编程规范：     1.操作符左右一定有空格。     2.分隔符（,和;)的前一位没有空格，后一位有空格。     3.
代码随想录怎么样？我是这样刷的
代码随想录
05-23 6882
学习算法不迷路
代码随想录的python版本
最新发布
07-27
- *1* [leetcode 刷题记录，链表部分，代码随想录刷题顺序（python实现）](https://blog.csdn.net/yyy199869/article/details/121777716)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值