给你一个链表的头节点 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 输出:[]
提示:
- 列表中的节点数目在范围
[0, 104]
内 1 <= Node.val <= 50
0 <= val <= 50
简单题。需要注意的是如果要删第一个节点的情况。最好将一个哨兵节点dummy(剑指offer里将其称之为哨兵节点,其实个人习惯称呼其为哑节点)设置在头结点前面,最后返回dummy.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 removeElements(ListNode head, int val) {
// 设置哨兵节点
ListNode dummy = new ListNode(0, head);
ListNode node = dummy;
while (node.next != null){
while (node.next.val == val){
node.next = node.next.next;
if (node.next == null){
break;
}
}
node = node.next;
if (node == null){
break;
}
}
return dummy.next;
}
}
设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性:val
和 next
。val
是当前节点的值,next
是指向下一个节点的指针/引用。如果要使用双向链表,则还需要一个属性 prev
以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。
在链表类中实现这些功能:
- get(index):获取链表中第
index
个节点的值。如果索引无效,则返回-1
。 - addAtHead(val):在链表的第一个元素之前添加一个值为
val
的节点。插入后,新节点将成为链表的第一个节点。 - addAtTail(val):将值为
val
的节点追加到链表的最后一个元素。 - addAtIndex(index,val):在链表中的第
index
个节点之前添加值为val
的节点。如果index
等于链表的长度,则该节点将附加到链表的末尾。如果index
大于链表长度,则不会插入节点。如果index
小于0,则在头部插入节点。 - deleteAtIndex(index):如果索引
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
提示:
0 <= index, val <= 1000
- 请不要使用内置的 LinkedList 库。
get
,addAtHead
,addAtTail
,addAtIndex
和deleteAtIndex
的操作次数不超过2000
。
class MyLinkedList {
int size;
ListNode head;
public MyLinkedList() {
size = 0;
head = new ListNode(0);
}
public int get(int index) {
if (index < 0 || index >= size)
return -1;
ListNode cur = head;
while (index-- != -1) {
cur = cur.next;
}
return cur.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;
}
if (index < 0){
index = 0;
}
ListNode newNode = new ListNode(val);
size++;
ListNode pre = head;
while (index-- != 0){
pre = pre.next;
}
newNode.next = pre.next;
pre.next = newNode;
}
public void deleteAtIndex(int index) {
if (index < 0 || index >= size){
return;
}
size--;
if (index == 0){
head = head.next;
return;
}
ListNode pre = head;
while (index-- != 0){
pre = pre.next;
}
pre.next = pre.next.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);
*/
这题涵盖了多种链表操作。删除节点比较简单,找到待删除节点的前一个节点pre,直接pre.next = pre.next.next就行。如果是C++的话还需要释放删除节点空间啥的,Java就不用管了,自动帮你释放。添加节点需找到插入节点的前后两个节点,先让待插入节点的next指向后节点,再让前节点的next指向待插入节点。先让前节点的next指向待插入节点也行,不过就必须先设置一个新指针指向后节点,免得后节点丢了。说实话,这样多占空间也麻烦,还不如直接用我说的顺序处理节点。
另一个需要注意的问题是边界问题,……emmm,好像也不太容易出错,不像数组题那样容易超出边界。还有就是index-- != 0这样的函数,会先处理!=后处理index--,详情看java - what does while (n-- != 0){} is doing in this code? - Stack Overflow。
给你单链表的头节点 head
,请你反转链表,并返回反转后的链表。
示例 1:
输入: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
最经典的反转链表题,和后面的中间反转一小段、分段反转等等比起来,太轻松了。
/**
* 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 pre = null;
ListNode cur = head;
while (cur != null) {
ListNode next = cur.next;
cur.next = pre;
pre = cur;
cur = next;
}
return pre;
}
}
这道题的主要目的除了熟悉链表操作,更重要的是了解递归算法。我对递归的理解说实话有点烂,正好趁这个机会熟悉一下。
/**
* 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) {
//最开始pre指向null,cur指向head
return reverse(null, head);
}
private ListNode reverse(ListNode pre, ListNode cur){
// cur指向null时结束递归,此时头结点是原链表最后一个节点,也是此时pre指向的节点
// 如果cur指向原链表最后一个节点就结束递归,链表就会看起来向这样:
// ← 〇 ← 〇 ← ... ← 〇 〇
// pre cur(已指向了next)
if (cur == null){
return pre;
}
ListNode next = cur.next;
cur.next = pre;
// pre指向cur,cur指向next,和双指针法思路一样
// 重要的是对递归函数中参数怎么变,心中要有数
return reverse(cur, next);
}
}
递归还是要练要理解的,不然后面二叉树遍历递归就要寄了。