Leetcode 刷题笔记(五) —— 链表篇之链表的基础操作和经典题目

已于 2022-02-10 12:28:04 修改
阅读量482 收藏
点赞数 2
分类专栏： 算法 文章标签： 链表 leetcode 数据结构
于 2022-01-23 00:56:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a1241692733/article/details/122638758
版权

文章目录

系列文章目录

一、 数组类型解题方法一：二分法
二、数组类型解题方法二：双指针法
三、数组类型解题方法三：滑动窗口
四、数组类型解题方法四：模拟
五、链表篇之链表的基础操作和经典题目
六、哈希表篇之经典题目
七、字符串篇之经典题目
八、字符串篇之 KMP
九、解题方法：双指针
十、栈与队列篇之经典题目
十 一、栈与队列篇之 top-K 问题
更新中 … …

刷题路线来自 ：代码随想录

1. 链表基本操作

707. 设计链表

Leetcode 链接

设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。

在链表类中实现这些功能：

get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
addAtHead(val)：头插
addAtTail(val)：尾插
addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
deleteAtIndex(index)：删除链表中的第 index 个节点。

示例：
MyLinkedList linkedList = new MyLinkedList();
linkedList.addAtHead(1);
linkedList.addAtTail(3);
linkedList.addAtIndex(1,2); //链表变为1-> 2-> 3
linkedList.get(1); //返回2
linkedList.deleteAtIndex(1); //现在链表是1-> 3
linkedList.get(1); //返回3

题解：

class Node {
	int val;
	Node next;
	public Node(int val) {
		this.val = val;
	}
}
class MyLinkedList {
	Node head = null;
	int size = 0;
    public MyLinkedList() {
    }
    
    // 获取链表中第 index 个节点的值。如果索引无效，则返回-1。
    public int get(int index) {
    	if (index + 1 > size || index < 0) return -1;
    	Node cur = this.head;
    	for (int i = 0; i < index; i ++) {
    		cur = cur.next;
    	}
		return cur.val;
    }
    
    // 头插
    public void addAtHead(int val) {
    	Node node = new Node(val);
    	if (this.head == null) {
    		this.head = node;
    	} else {
			node.next = this.head;
			this.head = node;
		}
		size++;
    }
    
    // 尾插
    public void addAtTail(int val) {
    	Node node = new Node(val);
    	if (this.head == null) {
    		this.head = node;
    	} else {
    		Node cur = this.head;
    		while (cur.next != null) {
    			cur = cur.next;
    		}
    		cur.next = node;
    	}
    	size++;
    }
    
    // index 个节点之前添加值为 val的节点。
    public void addAtIndex(int index, int val) {
    	// index 大于链表长度，节点不插入
    	if (index > size) return;
    	// index小于等于0，则在头部插入节点。
    	if (index <= 0) {
    		addAtHead(val);
    		return;
    	}
    	// 如果 index 等于链表的长度，则该节点将附加到链表的末尾。
    	if (index == size) {
    		addAtTail(val);
    		return;
    	}
    	// 中间位置插入
        Node node = new Node(val);
    	Node prev = head;
    	// prev 找到 要插入位置前一个结点
    	for (int i = 0; i < index - 1; i ++) {
    		prev = prev.next;
    	}
    	node.next = prev.next;
    	prev.next = node;
    	size++;
    }
    
    // 删除链表中的第 index 个节点。
    public void deleteAtIndex(int index) {
		if (index > size - 1 || index < 0) return;
		if (index == 0) {
			this.head = this.head.next;
			size--;
			return;
		}
		if (index == size- 1) {
			Node prev = this.head;
			for (int i = 0; i < index- 1; i ++) {
				prev = prev.next;
			}
			prev.next = null;
			size--;
			return;
		}
		
		Node prev = head;
		for (int i = 0; i < index - 1; i ++) {
			prev = prev.next;
		}
		prev.next = prev.next.next;
		size--;
    }
}

2. 双指针迭代法

203. 移除链表元素

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

示例 1：
输入：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
输出：[]

题解：
方法一：

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        if (head == null) return head;
        ListNode prev = head;
        ListNode cur = prev.next;
        while (cur != null) {
            if (cur.val == val) {
            	// 删除
                prev.next = cur.next;
                cur = prev.next; 
            } else {
            	// 不删除
                prev = cur;
                cur = prev.next;
            }
        }
        // 因为 cur 从第二个结点开始向后找，头节点还未判断是否为删除结点
        if (head.val == val) {
            return head.next;
        } else {
            return head;
        }
    }
}

方法二：添加虚拟头节点

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        if (head == null) return head;
        // 虚拟头结点
        ListNode newHead = new ListNode(-1);
        newHead.next = head;
        ListNode prev = newHead;
        ListNode cur = prev.next;
        // 迭代
        while (cur != null) {
            if (cur.val == val) {
                prev.next = cur.next;
            } else {
                prev = cur;
            }
            // 可以放在判断外边
            cur = prev.next;
        }
        return newHead.next;
    }
}

206. 反转链表

Leetcode 链接
定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。

示例:
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

题解：
注意初值和迭代结束条件

class Solution {
    public ListNode reverseList(ListNode head) {
        if (head == null) return null;
        // 反转后原来的头结点应指向 null
        ListNode prev = null;
        ListNode cur = head;
        // 如果让 curNext 初值为cur.next的话，最后回出现指针越界问题
        ListNode curNext = cur;
        while (cur != null) {
        	// 在每轮迭代的开始将 curNext 指向 cur.next
            curNext = cur.next;
            // 再进行反转
            cur.next = prev;
            prev = cur;
            cur = curNext;
            // 每轮迭代的结束 cur 是等于 curNext，这样便不会出现指针越界
        }
        // 最后一轮迭代 prev 指向原结点的尾，cur 和 curNext 为 null
        return prev;
    }
}

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

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

示例 1：
在这里插入图片描述

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

示例 2：
输入：head = []
输出：[]

示例 3：
输入：head = [1]
输出：[1]
题解：
因为链表和前后结点存在关系，所以交换相邻两个结点，影响到的结点除这两个外还有前边和后边各一个，一共4个结点。4个结点之间存在3个 next，画图推出这3个指针之间的迭代顺序即可解题。

class Solution {
    public ListNode swapPairs(ListNode head) {
        if (head == null) return null;
        // 虚拟头结点
        ListNode newHead = new ListNode(-1);
        newHead.next = head;
        ListNode prev = newHead;
		// 保证有两个结点可以交换才进入循环，若只剩下一个结点，无需交换
        while (prev.next != null && prev.next.next != null) {
        	// 两个相邻结点
            ListNode node1 = prev.next;
            ListNode node2 = node1.next; 
			// 更新3个指针
            prev.next = node2;
            node1.next = node2.next;
            node2.next = node1;
			// 更新下次迭代的前结点
            prev = node1;
        }
        // 返回真正头结点
        return newHead.next;
    }
}

3. 双指针之快慢指针

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

Leetcode 链接
给你一个链表，删除链表的倒数第 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]

题解：
快慢指针以相同速度，相距固定距离开始遍历。使得快指针越界时，慢指针指向要删除的前一个结点，再进行删除结点。

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
    	// 使用虚拟由结点，不用再去处理只有一个结点的特殊情况
        ListNode newHead = new ListNode(-1);
        newHead.next = head;
        ListNode fast = newHead;
        ListNode slow = newHead;
        // 快指针先走到预期位置
        while (n >= 0 && fast != null) {
            fast = fast.next;
            n--;
        }
        // 快慢指针一起走，直到快指针越界
        while (fast != null) {
            slow = slow.next;
            fast = fast.next;
        }
        // 此时慢指针指向要删除结点的前一个结点，进行删除结点
        slow.next = slow.next.next;
        return newHead.next;
    }
}

160. 相交链表

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

图示两个链表在节点 c1 开始相交：
在这里插入图片描述题目数据 保证 整个链式结构中不存在环。注意，函数返回结果后，链表必须 保持其原始结构 。

题解：
若两链表有相交结点，则先遍历完 A结点，再遍历 B结点到相交结点处和先遍历完 B结点，再遍历 A结点到相交结点处经过的结点数相同；
所以分别使用两个结点以相同速度，不同链表开始遍历，遍历完再去遍历另外一个链表，若有相加结点，会相遇，若没有，最后两结点会同时为 null.

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode nodeA = headA;
        ListNode nodeB = headB;
        while (nodeA != nodeB) {
            nodeA = nodeA.next;
            nodeB = nodeB.next;
            if (nodeA == null && nodeB == null) {
            	// 如果两链表不相交，且都各自遍历了一遍后此时都为 null，要是不 return 再执行的话就会死循环
                return null;
            }
            if (nodeA == null) {
                nodeA = headB;
            }
            if (nodeB == null) {
                nodeB = headA;
            }
        }
        return nodeA;
    }
}

简化：

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

141. 环形链表

Leetcode 链接
给你一个链表的头节点 head ，判断链表中是否有环。

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

如果链表中存在环，则返回 true 。 否则，返回 false 。

示例 1：
在这里插入图片描述输入：head = [3,2,0,-4], pos = 1输出：true解释：链表中有一个环，其尾部连接到第二个节点。
题解：
类比跑步，如果速度不同两人在直道同起点起跑，一定不会相遇；若先是直道后是环道，一定回相遇。

public class Solution {
    public boolean hasCycle(ListNode head) {
        ListNode fast = head;
        ListNode slow = head;
        while (fast != null && fast.next != null) {
        	// 快指针走两步，慢指针走一步
            fast = fast.next.next;
            slow = slow.next;
            // 相遇，返回true
            if (fast == slow) return true;
        }
        // 走到头(null)了, 没有相遇, 返会false
        return false;
    }
}

142. 环形链表 II

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

题解：
快慢指针在环内相遇后，快指针从 head 开始，慢指针从相遇开始，都一次走一步，最后会在入环结点相遇。

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) {
            	// 第一次相遇：环内相遇
                fast = head;
                while (fast != slow) {
                    fast = fast.next;
                    slow = slow.next;
                }
                // 第二次相遇：入环口
                return slow;
            }
        }
        return null;
    }
}

要是想不明白也可以使用哈希表解题：

public class Solution {
    public ListNode detectCycle(ListNode head) {
        Set<ListNode> set = new HashSet<>();
        ListNode cur = head;
        while (cur != null) {
            if (set.contains(cur)) {
            	// 找到入环结点
                return cur;
            } else {
            	// 第一次出现的结点，添加到 set里边
                set.add(cur);
            }
            cur = cur.next;
        }
        // 不是环形链表
        return null;
    }
}

4. 总结

  1. 因为头节点无 prev 结点，很多题都要去单独处理这一情况，而使用虚拟头节点，就不用去单独处理这一情况，方便简洁。
  2. 一定注意指针越界的问题，和特殊情况的考虑
a1241692733
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode刷题笔记——19. 删除链表的倒数第N个节点
12-21
  这道题本质上和《剑指Offer》刷题笔记——面试题22. 链表中倒数第k个节点是一样的。都可以用单指针两次遍历或者双指针一次遍历解决。 2、代码实现 # Definition for singly-linked list. # class ListNode: # ...
LeetCode刷题笔记——#21. 合并两个有序链表
12-22
一、题目描述： 二、解题分析：   递归是一个很直接的方法，想想斐波那契数列 from typing import List ###### leetcode 代码主体 ###### class Solution: def mergeTwoLists(self, l1, l2): if l1 is None: ...
数据结构实验之有序链表操作
horsetaill的博客
11-22 1649
一、 实验目的 1、 掌握有序链表的基本操作：插入、删除、查找。 2、 掌握链表遍历器的使用方法。 二、 实验内容 1、 输入n个不为零的整数作为节点元素值，遇到0代表输入结束（不创建元素值为0的节点），创建有序链表。输出整个链表。 2、 输入一个整数，将该数插入到有有序链表相应位置。输出整个链表。 3、 输入一个整数，在链表中进行搜索，输出其在链表中的第一个出现的位置。如果不存在输出0。 4、 再一次输入一个整数，在链表中进行搜索，输出其在链表中的第一个出现的位置。如果不存在输出0。 5、 再一次输入n.
链表的插入
guihaiyuan123的博客
12-28 3240
3.链表的插入： Description 给定一串数字，用链表结构进行存储。然后给定针对该链表的若干插入操作，要求将执行插入操作后的结果输出。 Input 第一行：输入一个整数n，表示这串数字有n个（n大于等于1)。 第二行：输入这n个整数。 第三行：输入一个整数m，表示需要执行m个插入操作。 后面m行：每行输入两个整数a和b，表示在这串数字的当前第a个数字之后插入数字b。（假设
int n1 = l1 ? l1-＞val: 0；是啥意思呢？
最新发布
2301_78146578的博客
04-06 373
这个条件表达式的意思是：如果指针 l1不为空，则将l1指向的节点的值赋值给变量n1；否则将0赋值给n1。这个网页还提供了相关问题和答案，以及其他用到条件表达式的例子。
链表的操作
m0_74070305的博客
02-16 543
输入n（n＞1）个由小到大的间断正整数，每次将输入的整数插入到链表头部，-1表示结束，在输入一个正整数，在链表中查找并删除该对应的节点，再输入一个正整数，进行比较后插入到该链表之中，再按要求输出进行删除和插入操作之后的所有列表中节点的值。 样例输入 2 3 5 6 9 11 -1 6 8 样例输出 11 9 8 5 3 2 #include<stdio.h> #include<stdlib.h> typedef str
链表的使用
weixin_47919250的博客
08-28 93
Description 定义学生结构体类型，封装的分量有姓名、学号、数学成绩、英语成绩、C语言成绩，其中姓名是字符串，其它都是整数形式。 根据给定的操作类型和数据建立链表，过程中进行增、删、改，最后输出。 其中操作类型是一个字符。"I"表示插入数据,"D"表示删除数据,"M"表示修改数据。插入操作后面给出一个学生的完整信息；删除操作后面给出删除学生的学号；修改操作后面给定学生的学号，以及其它对应的信息。 最后输出经过所有操作后构建的学生链表信息，需要保证学号按照从小到大的顺序输出。 说明： 1、如果
力扣热题100 第二题
weixin_55415374的博客
07-05 231
力扣热题100 第二题
【Leetcode刷题笔记03】203.移除链表元素 707.设计链表 206. 反转链表.md
01-13
内容概要:本文包含三道LeetCode链表算法题的刷题笔记,分别是203.移除链表元素、707.设计链表和206.反转链表,记录了详细的题目解析思路以及Java语言的参考代码。 适合人群:学习算法和数据结构的程序员或学生,尤其是...
LeetCode刷题笔记——#2. 两数相加
01-20
两个链表长度不一定相等   这两个就是编程的时候要注意的。接下来依次看看不同的代码写法。   flag 作为进位位，用if对不同的可能性进行分类。 from typing import List ###### leetcode 代码主体 ###### class ...
LeetCode:LeetCode 刷题笔记(C++, Python 实现)
04-12
LeetCode刷题笔记 ＃ 标题 标签 1个 两次总和 哈希表 2个 加两个数字 链表 3 最长子串，无重复字符 细绳 4 两个排序数组的中位数 大批 5 最长回文子串 细绳 6 之字形转换 细绳 7 反整数 数学 8 字符串到整数 ...
leetcode 2.两数相加
hhy20020202的博客
03-24 852
题目描述： 给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。 请你将两个数相加，并以相同形式返回一个表示和的链表。 你可以假设除了数字 0 之外，这两个数都不会以 0 开头。 思路： 设置两个指针分别指向两个链表的头结点，l1与l2 1.使用while循环来控制，判断条件为两个指针都指向NULL，while( l1 || l2 )，这里while循环中填的为继续的条件，所以为l1或l2。 2.分别是指三个参数，分别为.
2021-08-19 leetcode 数据结构 21.合并两个有序链表
weixin_51745630的博客
08-19 558
首先了解一下一些基础知识（就是我不会的点） mergeTwoLists 这个函数返回值为一个节点 l1 l2 虽然是以链表形式输入 但是表示的是其头指针 l1->val 表示 l1 的头节点的值 l2->val 同理 将l1 l2 放进mergeTwoLists函数里 将两值大小进行比较 若l1->val < l2->val 则 能得到第一个节点为l1的当前节点 l1的下一个节点为 mergeTwoLists(l1->next,l2)也就是将 l1的下一个和 l2的当.
两数相加（力扣）
weixin_54445968的博客
08-03 1718
给你两个非空 的链表，表示两个非负的整数。它们每位数字都是按照逆序的方式存储的，并且每个节点只能存储一位数字。
2.两数相加
ningmengccccc的博客
10-17 143
C++写链表的方式和C语言略有不同，new申请空间，struct内部写构造函数ListNode(int x) : val(x), next(NULL) {}，不用刻意把一个节点的next设为null了很方便。 /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode...
链表理论基础
wangzai32100的博客
07-18 1662
链表基础
【打卡】——【LeetCode学习计划】《数据结构入门-C++》第7天 链表
heart_6662的博客
12-14 1063
原文链接：【LeetCode学习计划】《数据结构入门-C++》第7天 链表_Wang_Xin_Ling的博客-CSDN博客 目录 141. 环形链表LeetCode: 141. 环形链表 分析： 方法一：哈希表 方法二： 快慢指针 21. 合并两个有序链表LeetCode 方法：递归 方法1优化就如同我们在【LeetCode学习计划】《算法-入门-C++》第8天 广度优先搜索 / 深度优先搜索中提到的问题一样，新链表的所有结点都是l1和l2的结点，如果l1或l2被释放了，那么..
(LeetCode) 两数相加-----C语言实现【详细讲解】
简十三的博客
06-08 2838
题目要求如下： 可以看出这题就是考察的结构体，以及链表的知识。链表跟上一篇哈希表有很大的联系，哈希表里存储的数据其实就是以链表的形式储存的。做题之前我们先来分析一下题目，看看我们究竟要做什么，怎么做？一：给了两个非空的链表，按照逆序的方式存储。OK ，我们先不管他是“逆序”还是“顺序”，对我们来说无所谓。两数相加嘛，很简单的加法计算，因此无论是“逆序”还是“顺序”我们都按照一一对应的位置进行相加就可以了，无所谓顺序如何。二：问题来了？仅仅是两数相加那么简单吗？如果是 9 + 2 呢？我们难道要输出这位的数字
leetcode刷题手册c++版
09-07
LeetCode刷题手册C版是一本针对程序员刷题的教材，旨在帮助他们提高编程能力、学习算法和数据结构。C语言作为一门广泛应用于系统编程和嵌入式开发的语言，在LeetCode刷题中也是非常重要的一种编程语言。 这本手册...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值