代码随想录（链表）

最新推荐文章于 2024-09-13 16:27:15 发布
最新推荐文章于 2024-09-13 16:27:15 发布
阅读量926 收藏 27
点赞数 21
文章标签： 链表 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/stormxie/article/details/139199919
版权

203.移除链表元素

题目：

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

示例 1：

img

输入：head = [1,2,6,3,4,5,6], val = 6
输出：[1,2,3,4,5]

示例 2：

输入：head = [], val = 1
输出：[]

示例 3：

输入：head = [7,7,7,7], val = 7
输出：[]

提示：

  • 列表中的节点数目在范围 [0, 104] 内
  • 1 <= Node.val <= 50
  • 0 <= val <= 50

代码：

（不使用虚拟头结点）

class Solution {
    public ListNode removeElements(ListNode head, int val) {
		//判断头结点是否需要删除
		while(head != null && head.val == val){
			head = head.next;
		}
		//删除非头结点
		ListNode cur = head;
		while(cur != null && cur.next != null){
			if(cur.next.val == val){
				cur.next = cur.next.next;
			}else{
				cur = cur.next;
			}
		}
		return head;
    }
}

（使用虚拟头结点，一个指针）

class Solution {
    public ListNode removeElements(ListNode head, int val) {
		ListNode dummy = new ListNode(-1,head);
		ListNode cur = dummy;
		while(cur.next != null){
			if(cur.next.val == val){
				cur.next = cur.next.next;
			}else{
				cur = cur.next;
			}
		}
		return dummy.next;  //因为head有可能被删除了，所有返回head是错误的，应该返回dummy.next
    }
}

（使用虚拟头结点，两个指针）

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode dummy = new ListNode(-1,head);
        ListNode pre = dummy;
        ListNode cur = head;
        while(cur != null){
            if(cur.val == val){
                pre.next = cur.next;
                cur = cur.next;
            }else{
                pre = pre.next;
                cur = cur.next;
            }
            
        }
        return dummy.next;   //因为head有可能被删除了，所有返回head是错误的，应该返回dummy.next
    }
}

707.设计链表

题目：

你可以选择使用单链表或者双链表，设计并实现自己的链表。

单链表中的节点应该具备两个属性：val 和 next 。val 是当前节点的值，next 是指向下一个节点的指针/引用。

如果是双向链表，则还需要属性 prev 以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。

实现 MyLinkedList 类：

  • MyLinkedList() 初始化 MyLinkedList 对象。
  • int get(int index) 获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1 。
  • void addAtHead(int val) 将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。
  • void addAtTail(int val) 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
  • void addAtIndex(int index, int val) 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。如果 index 比长度更大，该节点将 不会插入 到链表中。
  • void deleteAtIndex(int index) 如果下标有效，则删除链表中下标为 index 的节点。

示例 ：

输入
["MyLinkedList", "addAtHead", "addAtTail", "addAtIndex", "get", "deleteAtIndex", "get"]
[[], [1], [3], [1, 2], [1], [1], [1]]
输出
[null, null, null, null, 2, null, 3]

解释
MyLinkedList myLinkedList = new MyLinkedList();
myLinkedList.addAtHead(1);
myLinkedList.addAtTail(3);
myLinkedList.addAtIndex(1, 2);    // 链表变为 1->2->3
myLinkedList.get(1);              // 返回 2
myLinkedList.deleteAtIndex(1);    // 现在，链表变为 1->3
myLinkedList.get(1);              // 返回 3

提示：

  • 0 <= index, val <= 1000
  • 请不要使用内置的 LinkedList 库。
  • 调用 get、addAtHead、addAtTail、addAtIndex 和 deleteAtIndex 的次数不超过 2000 。

代码：

(单链表)

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 MyLinkedList {
    int size;
    ListNode dummy;

    public MyLinkedList() {
        this.size = 0;
        this.dummy = new ListNode(-1,null);
    }
    
    public int get(int index) {
        if(index < 0 || index >= size){
            return -1;
        }
        ListNode cur = dummy;
        for(int i = 0;i < index;i ++){
            cur = cur.next;
        }
        return cur.next.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;
        }
        size ++;
        ListNode newNode = new ListNode(val,null);
        ListNode cur = dummy;
        for(int i = 0;i < index;i ++){
            cur = cur.next;
        }
        newNode.next = cur.next;
        cur.next = newNode;
    }
    
    public void deleteAtIndex(int index) {
        if(index < 0 || index >= size){
            return;
        }
        size --;
        ListNode cur = dummy;
        for(int i = 0;i < index;i ++){
            cur = cur.next;
        }
        cur.next = cur.next.next;
    }
}

(双链表)

public class ListNode{
    int val;
    ListNode next;
    ListNode prev;
    ListNode(){}
    ListNode(int val){
        this.val = val;
    }
    ListNode(int val,ListNode prev,ListNode next){
        this.val = val;
        this.prev = prev;
        this.next = next;
    }
}
class MyLinkedList {
    int size;
    ListNode dummyHead;
    ListNode dummyTail;

    public MyLinkedList() {
        this.size = 0;
        dummyHead = new ListNode(-1);
        dummyTail = new ListNode(-1);
        dummyHead.next = dummyTail;
        dummyTail.prev = dummyHead;
    }
    
    public int get(int index) {
        if(index < 0 || index >= size){
            return -1;
        }
        ListNode cur = dummyHead;
        for(int i = 0;i < index;i ++){
            cur = cur.next;
        }
        return cur.next.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;
        }
        size ++;
        ListNode newNode = new ListNode(val,null,null);
        ListNode cur = dummyHead;
        for(int i = 0;i < index;i ++){
            cur = cur.next;
        }
        newNode.next = cur.next;
        newNode.prev = cur;
        cur.next.prev = newNode;
        cur.next = newNode;
    }
    
    public void deleteAtIndex(int index) {
        if(index < 0 || index >= size){
            return;
        }
        size --;
        ListNode cur = dummyHead;
        for(int i = 0;i < index;i ++){
            cur = cur.next;
        }
        cur.next.next.prev = cur;
        cur.next = cur.next.next;
    }
}

206.反转链表

题目：

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例 1：

img

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

示例 2：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

输入：head = [1,2]
输出：[2,1]

示例 3：

输入：head = []
输出：[]

提示：

  • 链表中节点的数目范围是 [0, 5000]
  • -5000 <= Node.val <= 5000

**进阶：**链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题？

代码：

(双指针法)

class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode pre = null;
        ListNode cur = head;
        while(cur != null){
            ListNode temp = cur.next;
            cur.next = pre;
            pre = cur;
            cur = temp;
        }
        return pre;
    }
}

(递归法)

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

    public ListNode reverse(ListNode pre,ListNode cur){
        if(cur == null){
            return pre;
        }
        ListNode temp = cur.next;
        cur.next = pre;
        return reverse(cur,temp);
    }
}

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

题目：

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

示例 1：

img

输入：head = [1,2,3,4]
输出：[2,1,4,3]

示例 2：

输入：head = []
输出：[]

示例 3：

输入：head = [1]
输出：[1]

提示：

  • 链表中节点的数目在范围 [0, 100] 内
  • 0 <= Node.val <= 100

代码：

class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode dummy = new ListNode(-1,head);
        ListNode cur = dummy;
        while(cur.next != null && cur.next.next != null){
            ListNode temp1 = cur.next;
            ListNode temp2 = cur.next.next.next;
            cur.next = cur.next.next;
            cur.next.next = temp1;
            temp1.next = temp2;
            cur = cur.next.next;
        }
        return dummy.next;
    }
}

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

题目：

给你一个链表，删除链表的倒数第 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
  • 1 <= sz <= 30
  • 0 <= Node.val <= 100
  • 1 <= n <= sz

**进阶：**你能尝试使用一趟扫描实现吗？

代码：

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
		ListNode dummy = new ListNode(-1,head);
		ListNode fast = dummy;
		ListNode slow = dummy;
		for(int i = 0;i <= n;i ++){     //移动了n+1步，slow才能指向要删除节点的前一个节点
			fast = fast.next;
		}
		while(fast != null){
			fast = fast.next;
			slow = slow.next;
		}
		slow.next = slow.next.next;
		return dummy.next;
    }
}

面试题 02.07. 链表相交

题目：

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

图示两个链表在节点 c1 开始相交**：**

img

题目数据 保证 整个链式结构中不存在环。

注意，函数返回结果后，链表必须 保持其原始结构 。

示例 1：

img

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at '8'
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

示例 2：

img

输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Intersected at '2'
解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。
在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。

示例 3：

img

输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。
由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
这两个链表不相交，因此返回 null 。

提示：

  • listA 中节点数目为 m
  • listB 中节点数目为 n
  • 0 <= m, n <= 3 * 104
  • 1 <= Node.val <= 105
  • 0 <= skipA <= m
  • 0 <= skipB <= n
  • 如果 listA 和 listB 没有交点，intersectVal 为 0
  • 如果 listA 和 listB 有交点，intersectVal == listA[skipA + 1] == listB[skipB + 1]

**进阶：**你能否设计一个时间复杂度 O(n) 、仅用 O(1) 内存的解决方案？

代码：

（Hash表法）

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

(双指针法)

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode p1 = headA;
        ListNode p2 = headB;
        while(p1 != p2){
            if(p1 == null){
                p1 = headB;
            }else{
                p1 = p1.next;
            }
            if(p2 == null){
                p2 = headA;
            }else{
                p2 = p2.next;
            }
        }
        return p1;
    }
}

(先行移动长链表实现同步移动)

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        int lenA = 0;
        int lenB = 0;
        ListNode temp = headA;
        while(temp != null){
            lenA ++;
            temp = temp.next;
        }
        temp = headB;
        while(temp != null){
            lenB ++;
            temp = temp.next;
        }
        ListNode curA = headA;
        ListNode curB = headB;
        if(lenB > lenA){
            int temp1 = lenA;
            lenA = lenB;
            lenB = temp1;

            ListNode tempNode = curA;
            curA = curB;
            curB = tempNode;
        }

        int gap = lenA - lenB;
        while(gap -- > 0){
            curA = curA.next;
        }
        while(curA != null){
            if(curA == curB){
                return curA;
            }
            curA = curA.next;
            curB = curB.next;
            
        }
        return null;
    }
}

142.环形链表II

题目：

给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。

示例 1：

img

输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：

img

输入：head = [1,2], pos = 0
输出：返回索引为 0 的链表节点
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

img

输入：head = [1], pos = -1
输出：返回 null
解释：链表中没有环。

提示：

  • 链表中节点的数目范围在范围 [0, 104] 内
  • -105 <= Node.val <= 105
  • pos 的值为 -1 或者链表中的一个有效索引

**进阶：**你是否可以使用 O(1) 空间解决此题？

代码：

public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode slow = head;
        ListNode fast = head;
        while(fast != null && fast.next != null){
            slow = slow.next;
            fast = fast.next.next;
            if(slow == fast){     //说明有环
                ListNode index1 = head;
                ListNode index2 = slow;
                while(index1 != index2){
                    index1 = index1.next;
                    index2 = index2.next;
                } 
                return index1;
            }
        }
        return null;
    }
}

更多详情，请访问我的博客 bgemini.cc

Bgemini
关注
代码随想录-八股文 pdf
04-25
代码随想录-八股文 PDF 代码随想录-八股文 PDF 是一个涵盖了程序员学习必备的内容的知识星球精华，总结了包括 C++、Java、Go 在内的多种编程语言，数据结构和算法、操作系统、数据库、计算机网络、设计模式、Linux ...
代码随想录算法PDF.zip
05-29
《代码随想录》是一本深受程序员喜爱的算法学习书籍，其PDF版本为读者提供了方便的电子阅读体验。这本书主要针对准备参加编程面试或者想要提升自己算法能力的开发者，通过实例解析和实战演练，帮助读者深入理解算法...
代码随想录 链表
m0_74267125的博客
01-04 1034
Java中并没有定义ListNode这个节点类，包括单向链表，双向链表，循环链表，都需要去学习它的写法，自定义 在处理链表的题目时，要注意通过画图的方法来摸清楚各个节点的应用和处理模式
代码随想录链表篇
weixin_44964855的博客
10-26 494
数据结构链表
代码随想录 链表—链表相交
qq_61579397的博客
03-03 640
如果链表相交的话，那肯定最后一段是重合的，所以可以直接按两段链表中长度较短的一个开始遍历。所以先求出A链表和B链表的长度，这里设置curA指针永远指向链表较长的一个链表，如果链表A长度小于B的，那么就交换lenA和lenB，使操作的都是A（较长的一段链表，可能是A也可能是B），求出链表A和B长度的差值，让curA向前移动这个差值的步数，这样两段链表长度得到统一，就开始比较值是否相同，相同就返回当前两指针的一个，不同两个指针就向后移。
代码随想录 链表—反转链表
qq_61579397的博客
03-02 296
一个pre指针指向null放在头节点前，cur指针指向头节点head，直接开始反转，cur->next=pre；那pre和cur要往后移动再进行反转，此时需要temp指针保存cur的下一个节点，这样才能建立链接，最后当cur指向的为空就可以不用进行反转，此时pre指向的就是最后一个节点，由此可以得到while的终止条件。如果需要建立新的节点，如上一个题目中dummyhead，就需要new listnode，如果只是用指针就直接等于要指向的节点即可。
代码随想录链表篇——环形链表II
qq_39473176的博客
09-06 315
刷题总结
代码随想录链表篇——反转链表
qq_39473176的博客
09-05 418
刷题总结
代码随想录 链表+代码可本地编译器运行
luckyme_的博客
07-07 638
代码随想录中的链表部分，代码可在本地编译器运行
代码随想录 链表章节总结
BBTJDDY的博客
07-09 915
每次cur是需要操作的两个节点的其中一个节点。每次记录下cur->next和cur->next->next->next。使用快慢指针，快指针先走n步，然后快慢指针同时走，直到快指针下一个是null，在慢指针这个位置slow->next = slow->next->next。需要用临时变量temp记录下一个需要操作的节点，左边那个尾pre，右边那个是cur，到了cur是nullptr的时候结束。首先求出两个链表的长度，求出二者之差为n，把长的链表头指针移动n步，然后两个头指针同时移动，相等的时候中断返回。
代码随想录：链表
平什么阿的博客
04-19 229
题目来自《代码随想录》 203.移除链表元素 https://leetcode-cn.com/problems/remove-linked-list-elements/ public ListNode removeElements(ListNode head, int val) { if(head == null) return head; ListNode dummy = new ListNode(0, head); ListNode pre = dummy; ListNode cur
代码随想录链表--005
hsysweetie的博客
08-14 89
链表：链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）。双链表：每一个节点有两个指针域，一个指向下一个节点，一个指向上一个节点。循环链表：顾名思义，就是链表首尾相连，循环链表可以用来解决约瑟夫环问题。链表的入口节点称为链表的头结点也就是head。单链表：中的指针域只能指向节点的下一个节点。双链表 既可以向前查询也可以向后查询。学不明白，delay。
代码随想录 面试大厂必备八股文
07-03
《代码随想录》是众多程序员面试准备的重要参考资料，尤其对于目标是大厂的开发者来说，这本书中的“面试大厂必备八股文”更是不容忽视的内容。这里的“八股文”并非传统意义上的文学形式，而是指在编程面试中经常被...
代码随想录算法PDF.rar
08-06
《代码随想录》是一本深受程序员喜爱的算法学习书籍，尤其对于初学者来说，它提供了深入浅出的讲解和实战演练。这本书的核心是通过实际编程来帮助读者理解和掌握算法，提升编程技能，特别是C++语言的应用。在C++这个...
算法刷题：300. 最长递增子序列、674. 最长连续递增序列、718. 最长重复子数组、1143. 最长公共子序列
qq_61936886的博客
09-12 504
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。但dp[i][0] 和dp[0][j]要初始值，因为 为了方便递归公式dp[i][j] = dp[i - 1][j - 1] + 1;2.递推公式：当A[i - 1] 和B[j - 1]相等的时候，dp[i][j] = dp[i - 1][j - 1] + 1;
输出一个三位数
最新发布
2301_77501988的博客
09-13 389
本题要求编写程序，输入一个三位数，输出其个位数字、十位数字和百位数字。
算法知识点——常用输入输出数据的方式
5233的博客
09-12 295
除了换行之外，还会清空缓存区，而清空缓存区这件事情会耗时很久，因此为了提高速度，一般直接：cout << “\n”;2、n组输入输出(n不确定）1、n组输入输出(n确定）3、 复杂的输入输出。
Java数据结构（十）——冒泡排序、快速排序
xiaokuer_的博客
09-11 1189
文章介绍了冒泡排序和快速排序，快速排序的内容包括：划分方式、优化策略以及非递归实现
算法基础-约数
qq_65186476的博客
09-11 324
试除法求约数、约数个数、约数之和、最大公约数
代码随想录的python版本
07-27
抱歉，我无法理解你的问题。你可以提供更多的上下文或者明确你的问题吗？谢谢！ #### 引用[.reference_title] - *1* [leetcode 刷题记录，链表部分，代码随想录刷题顺序（python实现）](https://blog.csdn.net/yyy199869/article/details/121777716)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Bgemini

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值