文章目录
https://leetcode-cn.com/explore/learn/card/linked-list/
建议先学习学习 力扣链表入门
1 LC:702入门级设计链表
原题位置:707. 设计链表
设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性: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 个节点。
来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/design-linked-list
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。
//节点类;
class ListNode{
int value;
ListNode next;
public ListNode(int value){
this.value = value;
}
}
//单向链表;
class MyLinkedList {
//头结点;
ListNode head;
//节点个数;
int size;
//构造方法;
public MyLinkedList() {
head = new ListNode(0);
size = 0;
}
//获取链表中第 index 个节点的值。如果索引无效,则返回-1。
public int get(int index) {
//若当前索引明显不在链表范围内或者此时为空链表;
if(head==null ||index >=size ||index<0){
return -1;
}
ListNode node = head.next;
for(int i =0;i<index;i++){
node = node.next;
}
return node.value;
}
//在链表的第一个元素之前添加一个值为 val 的节点。
//插入后,新节点将成为链表的第一个节点
public void addAtHead(int val) {
addAtIndex(0,val);
}
//将值为 val 的节点追加到链表的最后一个元素。
public void addAtTail(int val) {
addAtIndex(size,val);
}
//在链表中的第 index 个节点之前添加值为 val 的节点。
//如果 index 等于链表的长度,则该节点将附加到链表的末尾。
public void addAtIndex(int index, int val) {
//如果 index 大于链表长度,则不会插入节点;
if(index >size){
return;
}
//如果index小于0,则在头部插入节点。
if(index<0) {
index = 0;
}
size+=1;
//寻找之前的一位;
ListNode node = head;
for(int i =0;i<index;i++){
node= node.next;
}
//要添加的节点;
ListNode newNode = new ListNode(val);
//调整指向;
newNode.next = node.next;
node.next = newNode;
}
//如果索引 index 有效,则删除链表中的第 index 个节点。
public void deleteAtIndex(int index) {
//列出几种索引失效的场景;
if(index<0 || index >=size||head ==null){
return;
}
//操作的节点;
ListNode node = head;
//找到待删除结点的前一个结点;
for(int i= 0;i<index;i++){
node = node.next;
}
//改变指向;
node.next = node.next.next;
size-=1;
}
}
/**
* 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);
*/
2 LC: 2 两数相加
给你两个 非空 的链表,表示两个非负的整数。
它们每位数字都是按照 逆序 的方式存储的,并且每个节点只能存储 一位 数字。
请你将两个数相加,并以相同形式返回一个表示和的链表。
你可以假设除了数字 0 之外,这两个数都不会以 0 开头。
示例 2:
输入:l1 = [0], l2 = [0]
输出:[0]
示例 3:
输入:l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出:[8,9,9,9,0,0,0,1]
提示:
每个链表中的节点数在范围 [1, 100] 内
0 <= Node.val <= 9
题目数据保证列表表示的数字不含前导零
先把链表节点加到一个链表中,然后对于超过10的进行进位处理;
/**
* 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 addTwoNumbers(ListNode l1, ListNode l2) {
//用临时节点操作链表;
ListNode temp1 = l1;
ListNode temp2 = l2;
while(temp1!=null){
//先把值加到一个链表上;
if(temp2!=null){
temp1.val = temp1.val+temp2.val;
temp2 = temp2.next;
}
//注意特殊情况,链表1已经结束;直接把链表2接到后面;
if(temp1.next==null){
temp1.next = temp2;
break;
}
temp1 = temp1.next;
}
//对于节点的值进行计算;
toCarry(l1);
return l1;
}
//节点的值进位计算;
public void toCarry(ListNode node){
//在链表范围内;
while(node!=null){
//进位
if(node.val>=10){
//进位之后的余值作为当前节点值;
node.val = node.val%10;
//若已经到末尾,则要补0;
if(node.next == null){
node.next = new ListNode(0);
}
node.next.val+=1;
}
//链表向后移动;
node = node.next;
}
}
}
3 LC: 21. 合并两个有序链表
将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
示例 2:
输入:l1 = [], l2 = []
输出:[]
示例 3:
输入:l1 = [], l2 = [0]
输出:[0]
提示:
两个链表的节点数目范围是 [0, 50]
-100 <= Node.val <= 100
l1 和 l2 均按 非递减顺序 排列
采用类似于归并排序的比较法,拼接到一个链表中;
/**
* 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 mergeTwoLists(ListNode l1, ListNode l2) {
//类似于归并排序;对于链表的元素依次比较;
ListNode res = new ListNode();
//操作的节点;
ListNode curNode = res;
while(l1!=null && l2!=null){
if(l1.val<=l2.val){
curNode.next = l1;
l1=l1.next;
curNode=curNode.next;
}else{
curNode.next = l2;
l2=l2.next;
curNode = curNode.next;
}
}
//若出现一个链表已经为空;则拼接另一个;
if(l1==null){
curNode.next = l2;
}
if(l2==null){
curNode.next = l1;
}
//注意返回的节点由下一位开始;
return res.next;
}
}
4 LC: 23. 合并K个升序链表
给你一个链表数组,每个链表都已经按升序排列。
请你将所有链表合并到一个升序链表中,返回合并后的链表。
示例 1:
输入:lists = [[1,4,5],[1,3,4],[2,6]]
输出:[1,1,2,3,4,4,5,6]
解释:链表数组如下:
[
1->4->5,
1->3->4,
2->6
]
将它们合并到一个有序链表中得到。
1->1->2->3->4->4->5->6
示例 2:
输入:lists = []
输出:[]
示例 3:
输入:lists = [[]]
输出:[]
提示:
k == lists.length
0 <= k <= 10^4
0 <= lists[i].length <= 500
-10^4 <= lists[i][j] <= 10^4
lists[i] 按 升序 排列
lists[i].length 的总和不超过 10^4
一个比较容易理解的思路,将k个链表拆分,两两排序合并,最终合并到一个链表中即可;
/**
* 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 mergeKLists(ListNode[] lists) {
int n = lists.length;
//排除空用例;
if(lists==null || n==0){
return null;
}
//采用分治思想;
for(int i = 1;i<n;i*=2){
for(int j=0;j<n-i;j=j+i*2){
lists[j] = mergeTwo(lists[j],lists[j+i]);
}
}
//最终都合并到第一份链表中;
return lists[0];
}
//合并两个升序数组的做法;
public ListNode mergeTwo(ListNode l1,ListNode l2){
//类似于归并排序;
ListNode res = new ListNode(0);
//操作的节点;
ListNode curNode = res;
while(l1!=null && l2!=null){
if(l1.val<=l2.val){
curNode.next = l1;
l1 = l1.next;
}else{
curNode.next = l2;
l2 = l2.next;
}
curNode = curNode.next;
}
//可能一个链表已经遍历结束;
if(l1==null){
curNode.next = l2;
}
if(l2==null){
curNode.next = l1;
}
return res.next;
}
}
5 LC: 24. 两两交换链表中的节点
给你一个链表,两两交换其中相邻的节点,并返回交换后链表的头节点。
你必须在不修改节点内部的值的情况下完成本题(即,只能进行节点交换)。
提示:
链表中节点的数目在范围 [0, 100] 内
0 <= Node.val <= 100
可使用递归思路
/**
* 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 || head.next==null){
return head;
}
//简易递归;
ListNode curNode = head;
ListNode nextNode = head.next;
//第二个节点后面的节点递归结束;接到原来的头结点后;
curNode.next = swapPairs(nextNode.next);
nextNode.next = curNode;
//新的头结点;
return nextNode;
}
}
不递归;在循环内处理;
/**
* 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 || head.next==null){
return head;
}
//采用虚拟头节点;
ListNode dummy = new ListNode(0);
dummy.next=head;
ListNode curNode = dummy;
while(curNode.next!=null&&curNode.next.next!=null){
//注意刚开始这个curNode是空的;
//节点的交换过程实际就是,相邻的互换,当前指导后一个的后继节点;
ListNode oneNode = curNode.next;
ListNode twoNode = oneNode.next;
oneNode.next = twoNode.next;
//第二个节点会指向到第一个节点,依次类推;
twoNode.next = oneNode;
//当前的操作节点指向第二个节点;
curNode.next = twoNode;
//注意这里需要将操作节点位到一号节点(curNode的后继);
curNode = oneNode;
}
return dummy.next;
}
}
6 LC:25. K 个一组翻转链表
给你一个链表,每 k 个节点一组进行翻转,请你返回翻转后的链表。
k 是一个正整数,它的值小于或等于链表的长度。
如果节点总数不是 k 的整数倍,那么请将最后剩余的节点保持原有顺序。
进阶:
你可以设计一个只使用常数额外空间的算法来解决此问题吗?
你不能只是单纯的改变节点内部的值,而是需要实际进行节点交换。
示例 3:
输入:head = [1,2,3,4,5], k = 1
输出:[1,2,3,4,5]
示例 4:
输入:head = [1], k = 1
输出:[1]
提示:
列表中节点的数量在范围 sz 内
1 <= sz <= 5000
0 <= Node.val <= 1000
1 <= k <= sz
非常巧妙的思路;
先计算出链表的长度;然后根据K值,
首先对前K个节点进行反转处理,处理时,这部分链表暂时与整体链表分开;
在反转完成之后需要再链接到主链表上,移动操作节点,继续下一块K区域的链表处理;
注意,如果剩余的节点个数不足K值时,或已经到达链表末尾,那么就不对后面的进行反转处理;
/**
* 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 reverseKGroup(ListNode head, int k) {
//在之前24题的两两反转基础上;
//首先排除反转个数少于2的;
if(head==null||head.next==null||k<2){
return head;
}
ListNode dummy = new ListNode(0);
dummy.next = head;
//使用两个操作节点;对于一段区域进行查看;
ListNode curNode = dummy;
ListNode endNode = dummy;
while(endNode.next!=null){
//首先截取一段k长度的链表;
for(int i =0;i<k && endNode!=null;i++){
endNode=endNode.next;
}
//注意如果不足k个,可直接退出;
if(endNode == null) {
break;
}
//此时对于区域curNode.next--endNode 进行处理;
ListNode oneNode = curNode.next;
//注意标记此时endNode后的节点,一会还要再链接;
ListNode subNode = endNode.next;
//暂时断开这段链表与主链表;
endNode.next = null;
//反转当前k个节点后;再让curNode指向它;
curNode.next = reverseNode(oneNode);
//这里注意将断开的链表接上去;
oneNode.next = subNode;
//当前操作指针与k阶段末尾指针移动;
curNode = oneNode;
endNode = curNode;
}
return dummy.next;
}
//反转链表;
public ListNode reverseNode(ListNode node){
//前置节点与当前操作节点;
ListNode preNode = null;
ListNode curNode = node;
while(curNode!=null){
//注意反转;将当前节点指向前一个结点;
ListNode temp = curNode.next;
curNode.next = preNode;
preNode = curNode;
//向后继续操作;
curNode = temp;
}
//注意返回时,preNode已经不是null了;
return preNode;
}
}
7 LC: 61. 旋转链表
给你一个链表的头节点 head ,旋转链表,将链表每个节点向右移动 k 个位置。
提示:
链表中节点的数目在范围 [0, 500] 内
-100 <= Node.val <= 100
0 <= k <= 2 * 109
类似于螺旋数组的题型;
若k值正好是链表的节点个数倍数,那么不必要旋转处理,直接返回;
若k值超过了链表的节点个数,那么对k值进行取模运算;移动取模后的值;
旋转也是比较方便的,找到旋转之后的末尾节点,以及新的头结点,
将原链表首位相连,再根据新的头尾节点,决定在那里的链接指向进行断开;
/**
* 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 rotateRight(ListNode head, int k) {
if(head==null||head.next==null||k==0){
return head;
}
//类似于螺旋数组;
//若k值正好是链表的节点个数倍数,那么不必要旋转;
//若k值超过了链表的节点个数,那么对k值进行取模运算;
int len =1;
ListNode temp = head;
while(temp.next!=null){
temp = temp.next;
len++;
}
k = k%len;
if(k==0){
return head;
}
//找到移动之后的末尾节点;
ListNode newTail = head;
for(int i=1;i<len-k;i++){
newTail = newTail.next;
}
//标记新的头节点;
ListNode newHead = newTail.next;
//将原末尾和原头结点链接;
temp.next = head;
newTail.next = null;
return newHead;
}
}
8 LC: 82. 删除排序链表中的重复元素 II
给定一个已排序的链表的头 head , 删除原始链表中所有重复数字的节点,只留下不同的数字 。
返回 已排序的链表 。
提示:
链表中节点数目在范围 [0, 300] 内
-100 <= Node.val <= 100
题目数据保证链表已经按升序 排列
注意删除的是所有重复的节点,
那么具体在预先处理时,这个操作节点就要置身事外,即删除的是这个操作节点的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 deleteDuplicates(ListNode head) {
ListNode dummy = new ListNode(0);
dummy.next = head;
ListNode curNode = dummy;
while(curNode.next!=null && curNode.next.next!=null){
//若出现重复时需要处理;
if(curNode.next.val == curNode.next.next.val){
//注意;删除时先从第二个开始;
ListNode delNode = curNode.next.next;
//注意,这是已经排序的链表,顺便看看后面是否有重复的;
while(delNode.next!=null&&delNode.val ==delNode.next.val){
delNode = delNode.next;
}
//删掉这块重复的;
curNode.next = delNode.next;
delNode.next=null;
}else{
curNode=curNode.next;
}
}
return dummy.next;
}
}
9 LC: 83. 删除排序链表中的重复元素
给定一个已排序的链表的头 head , 删除所有重复的元素,
使每个元素只出现一次 。返回 已排序的链表 。
提示:
链表中节点数目在范围 [0, 300] 内
-100 <= Node.val <= 100
题目数据保证链表已经按升序 排列
这个题目的删除要求比较简单,仅删除重复多余的,可以保留下一个数;
那么在具体操作时,操作节点就得从自己进行比较了,若出现重复的,那么删掉这个数后面重复的部分即可;
/**
* 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 deleteDuplicates(ListNode head) {
if(head==null||head.next==null){
return head;
}
//注意;删除重复的多个,保留一个;
ListNode curNode = head;
while(curNode.next!=null){
//处理重复的;
if(curNode.val == curNode.next.val){
ListNode delNode = curNode.next;
curNode.next = delNode.next;
delNode.next = null;
}else{
curNode= curNode.next;
}
}
return head;
}
}