基础链表问题练习1
Posted 小智RE0
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了基础链表问题练习1相关的知识，希望对你有一定的参考价值。
文章目录
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)