203.移除链表元素
题目链接:203. 移除链表元素 - 力扣(LeetCode)
题目描述
给你一个链表的头节点
head
和一个整数val
,请你删除链表中所有满足Node.val == val
的节点,并返回 新的头节点 。
这个题涉及到 虚拟头节点 ,虚拟头节点通常被放置在链表的头部,作为一个新的头节点。这样,即使原来的头节点被删除,链表仍然有一个头节点,使得操作统一,不需要对头节点进行特殊处理。虚拟头节点的下一个节点是原来的头节点。
思路分析
- 首先判断头节点head是否为null,如果是null则是空链表,没有任何可执行的操作,直接返回head
- 创建一个虚拟头节点
dummy
,其值设为-1
,并将其下一个节点指向链表的头节点head
。这样做的目的是为了方便操作,特别是当需要删除的节点是头节点时。 - 创建一个指针 pre,将 虚拟头节点dummy 赋值给指针 pre。pre 指针将用于指向当前节点
cur
的前一个节点 - 创建一个指针
cur
,并将其初始化为链表的头节点head
。这个指针将用于遍历链表中的每个节点。 -
开始一个 while 循环,只要
cur
不为null
(即还没有遍历完链表),就执行循环体中的代码。 -
如果当前节点
cur
的值等于要删除的值val
,就将前一个节点pre
的next
指针指向当前节点cur
的下一个节点,从而跳过当前节点cur
,实现删除操作。 -
如果当前节点
cur
的值不等于要删除的值val
,则将pre
指针移动到当前节点cur
,为下一次迭代做准备。 -
接着将
cur
指针移动到下一个节点,继续链表的遍历。 -
循环结束后,返回虚拟头节点
dummy
的下一个节点,即新链表的头节点。由于所有值等于val
的节点都已被删除,返回的链表不包含这些节点。
代码实现(Java)
class Solution {
public ListNode removeElements(ListNode head, int val) {
if(head == null){
return head;
}
ListNode dummy = new ListNode(-1,head);
ListNode pre = dummy;
ListNode cur = head;
while(cur != null){
if(cur.val == val){
pre.next = cur.next;
}else{
pre = cur;
}
cur = cur.next;
}
return dummy.next;
}
}
707.设计链表
题目链接:. - 力扣(LeetCode)
题目描述
你可以选择使用单链表或者双链表,设计并实现自己的链表。
单链表中的节点应该具备两个属性:
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
的节点。
思路分析
类和方法解释:
-
ListNode 类:
val
:存储当前节点的值。next
:指向下一个节点的指针。- 构造函数:用于创建一个新的节点,可以传入一个初始值。
-
MyLinkedList 类:
size
:表示链表中的元素数量。head
:一个虚拟头节点,方便操作,它的next
指向真正的头节点。MyLinkedList()
:构造函数,初始化链表,设置size
为0,创建一个虚拟头节点。get(int index)
:获取指定位置的节点值,index
从0开始。如果index
不合法,返回-1。addAtHead(int val)
:在链表头部添加一个新节点。addAtTail(int val)
:在链表尾部添加一个新节点。addAtIndex(int index, int val)
:在指定位置添加一个新节点。如果index
等于链表长度,新节点将成为尾节点。如果index
大于长度,操作无效。deleteAtIndex(int index)
:删除指定位置的节点。
方法详细解释:
-
get(int index):
- 检查
index
是否在有效范围内(即大于等于0且小于size
)。 - 从虚拟头节点开始,遍历链表直到
index
位置,返回该位置的节点值。
- 检查
-
addAtIndex(int index, int val):
- 如果
index
大于size
,不执行任何操作。 - 如果
index
小于0,将新节点添加到头部。 - 遍历链表找到
index
位置的前一个节点。 - 创建一个值为
val
的新节点,并将其插入到链表中。
- 如果
-
deleteAtIndex(int index):
- 检查
index
是否在有效范围内。 - 如果
index
为0,直接将虚拟头节点的next
指向第二个节点,即删除真正的头节点。 - 否则,遍历链表找到
index
位置的前一个节点,并将其next
指向下下个节点,从而实现删除操作。
- 检查
代码实现(Java)
//单链表
class ListNode {
int val;
ListNode next;
ListNode(){}
ListNode(int val) {
this.val=val;
}
}
class MyLinkedList {
//size存储链表元素的个数
int size;
//虚拟头结点
ListNode head;
//初始化链表
public MyLinkedList() {
size = 0;
head = new ListNode(0);
}
//获取第index个节点的数值,注意index是从0开始的,第0个节点就是头结点
public int get(int index) {
//如果index非法,返回-1
if (index < 0 || index >= size) {
return -1;
}
ListNode currentNode = head;
//包含一个虚拟头节点,所以查找第 index+1 个节点
for (int i = 0; i <= index; i++) {
currentNode = currentNode.next;
}
return currentNode.val;
}
//在链表最前面插入一个节点,等价于在第0个元素前添加
public void addAtHead(int val) {
addAtIndex(0, val);
}
//在链表的最后插入一个节点,等价于在(末尾+1)个元素前添加
public void addAtTail(int val) {
addAtIndex(size, val);
}
// 在第 index 个节点之前插入一个新节点,例如index为0,那么新插入的节点为链表的新头节点。
// 如果 index 等于链表的长度,则说明是新插入的节点为链表的尾结点
// 如果 index 大于链表的长度,则返回空
public void addAtIndex(int index, int val) {
if (index > size) {
return;
}
if (index < 0) {
index = 0;
}
size++;
//找到要插入节点的前驱
ListNode pred = head;
for (int i = 0; i < index; i++) {
pred = pred.next;
}
ListNode toAdd = new ListNode(val);
toAdd.next = pred.next;
pred.next = toAdd;
}
//删除第index个节点
public void deleteAtIndex(int index) {
if (index < 0 || index >= size) {
return;
}
size--;
if (index == 0) {
head = head.next;
return;
}
ListNode pred = head;
for (int i = 0; i < index ; i++) {
pred = pred.next;
}
pred.next = pred.next.next;
}
}
206.反转链表
题目描述
给你单链表的头节点
head
,请你反转链表,并返回反转后的链表。
思路分析
一、双指针
类和方法解释:
-
Solution 类:
reverseList(ListNode head)
:这是对外公开的接口,用于反转链表。它使用两个指针prev
和cur
来遍历链表并进行反转。
-
ListNode 类:
val
:存储当前节点的值。next
:指向下一个节点的指针。
- 方法详细解释:
- reverseList(ListNode head):
- 初始化两个指针
prev
和cur
,其中prev
初始为null
,cur
初始为链表的头节点head
。 - 进入一个循环,只要
cur
不是null
,就执行以下操作:- 保存
cur
的下一个节点到temp
,因为接下来要改变cur.next
的指向,需要先保存下一个节点。 - 将
cur.next
指向prev
,实现当前节点的反转。 - 将
prev
移动到cur
的位置,即prev = cur
。 - 将
cur
移动到temp
的位置,即cur = temp
,这样cur
就指向了下一个要反转的节点。
- 保存
- 当循环结束时,
cur
为null
,此时prev
指向的是反转后链表的头节点,返回prev
。
- 初始化两个指针
- reverseList(ListNode head):
二、递归
类和方法解释:
-
Solution 类:
reverseList(ListNode head)
:这是对外公开的接口,用于反转链表。它调用私有的辅助函数reverse
来执行实际的反转操作。
-
reverse(ListNode prev, ListNode cur):
prev
:指向当前节点cur
的前一个节点。cur
:指向当前需要处理的节点。- 这个函数是递归函数,它会一直递归到链表的末尾,然后开始反转链表的指针。
-
reverse(ListNode prev, ListNode cur):
- 这个方法是递归反转链表的核心。它接受两个参数,当前节点的前一个节点
prev
和当前节点cur
。 - 递归终止条件:如果当前节点
cur
为null
,说明已经到达了链表的末尾,此时返回prev
,即反转后链表的头节点。 - 在每次递归调用之前,先保存当前节点的下一个节点
temp = cur.next
,因为接下来要改变cur.next
的指向。 - 反转链表:将当前节点的
next
指针指向前一个节点prev
,即cur.next = prev
。 - 递归调用:将当前节点
cur
作为新的prev
,将之前保存的下一个节点temp
作为新的cur
,继续递归反转剩余的链表。
- 这个方法是递归反转链表的核心。它接受两个参数,当前节点的前一个节点
-
reverseList(ListNode head):
- 这个方法是递归反转链表的主入口。它调用私有的
reverse
方法,初始时prev
为null
,cur
为链表的头节点head
。
- 这个方法是递归反转链表的主入口。它调用私有的
代码实现(Java)
// 双指针
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;
}
}
// 递归
class Solution {
public ListNode reverseList(ListNode head) {
return reverse(null, head);
}
private ListNode reverse(ListNode prev, ListNode cur) {
if (cur == null) {
return prev;
}
ListNode temp = null;
temp = cur.next;// 先保存下一个节点
cur.next = prev;// 反转
// 更新prev、cur位置
// prev = cur;
// cur = temp;
return reverse(cur, temp);
}
}