单链表刷题小结
- 注意头节点的使用
- java中没有直接访问内存地址的用法，每个节点都是引用，可以 .val 或者 .next进行访问
- 如果是需要返回结果，最好是返回一个新建的链表，如果返回旧的结果那么在head长度为1时是无论怎样都消不掉的，我遇到这样的情况比如说，p2.next = p1; p2.next = p2.next.next; return head; 那么我这样操作目的是想通过p2来删除链表中的某个节点，大但是当head长度为1时，p2的改变是改变不了head的，就算p2=null，head仍然长度为1
- 学会了优先级队列这个概念
- 还有一些比较新奇的思路，比如补全链表，双指针，都需要常常回顾
21. 合并两个有序链表
class Solution {
public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
ListNode dummy = new ListNode(-1), p = dummy;
ListNode p1 = l1, p2 = l2;
while (p1!=null && p2!=null){
if (p1.val<p2.val){
p.next = p1;
p1 = p1.next;
}
else{
p.next = p2;
p2 = p2.next;
}
p = p.next;
}
if (p1!=null){
p.next = p1;
}
if (p2!=null){
p.next = p2;
}
return dummy.next;
}
}
86. 分隔链表
class Solution {
public ListNode partition(ListNode head, int x) {
ListNode p0 = head;
ListNode dummy1 = new ListNode(-1), p1 = dummy1;
ListNode dummy2 = new ListNode(-1), p2 = dummy2;
while(p0 != null){
if(p0.val < x){
p1.next = p0;
p1 = p1.next;
p0 = p0.next;
p1.next = null;
}
else{
p2.next = p0;
p2 = p2.next;
p0 = p0.next;
p2.next = null;
}
}
p1.next = dummy2.next;
return dummy1.next;
}
}
23. 合并 K 个升序链表
- 这个题直接看的时候，思路就是给k个链表都安排一个指针，取三个指针中最小的值给到新的列表，需要注意读取链表的数量，或者将链表指针存到数组里边；要不就是递归？
- 但是难点是在于求k个节点的最小节点？？？答案中是用优先级队列（二叉堆）数据结构。每次移动一个指针到下一个位置，堆的数据结构可以直接给出最小的值而不需要重新排列，原先的时间复杂度是M序列N总序列长度，现在的复杂度是O(NlogM)
- lists.length 求长度不需要加括号
- // 优先队列的用法
- PriorityQueue<ListNode> pq = new PriorityQueue<>(lists.length,(a,b)->(a.val-b.val));
- // 定义方式
- ListNode dummy = new ListNode(-1);
/**
* 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) {
if(lists.length==0){
return null;
}
ListNode dummy = new ListNode(-1);
ListNode p = dummy;
PriorityQueue<ListNode> pq = new PriorityQueue<>(lists.length,(a,b)->(a.val-b.val)); // 如果是负数，a小
for (ListNode head : lists){
if(head!=null){
pq.add(head);
}
}
while(!pq.isEmpty()){
ListNode temp = pq.poll();
p.next = temp;
if(temp.next!=null){
pq.add(temp.next);
}
p = p.next;
p.next = null;
}
return dummy.next;
}
}
19. 删除链表的倒数第 N 个结点（被困住一晚上的结果返回问题）
- 考虑的方法是：在进行正向读取的时候，就将整个列表逆序，要么就是新读取一个节点就插入到前边，读取结束之后从头节点开始读取k个即可（反思：这种情况只能读到k节点的值，无法读到next）
- 如果是删除该节点，那么就是设置成双向节点，读到尾巴之后，返回来修改倒数第k个（很繁琐）
- 正确答案是两个人赛跑，其中一个人先放到k处，然后两人同时开始，在两人速度一致的情况下，一人到达
我的方法：
class Solution {
public ListNode removeNthFromEnd(ListNode head, int n) {
ListNode p1 = head;
ListNode p2 = new ListNode(0, head);
ListNode p3 = p2;
// 安全，这里我的思路是只有走n-1步骤，才会正确达到第n个数，所以我的p1一直指向了安全区域
for (int i=0;i<(n-1);i++){
p1 = p1.next;
}
// 当p1的下一个是null，那说明p1到了结尾节点
while(p1.next!=null){
p1 = p1.next;
p2 = p2.next;
}
// 在此过程中 p1 和 p2 的长度一直为n+1，所以当p1到达结尾，p2在倒数n+1上停着，这时将p2后边的数字删除掉即可
// 在删除的时候尤其注意，不能直接返回head，否则当只有一个值的时候，永远无法被删除，所以需要重新开启一个链表即p2，最后的返回结果也是p2
p2.next = (p2.next).next;
return p3.next;
}
}
答案结果
class Solution {
public ListNode removeNthFromEnd(ListNode head, int n) {
ListNode dummy = new ListNode(0, head);
ListNode first = head;
ListNode second = dummy;
// first可以指向n个数的后边null，first和second之间的距离是n+2，所以需要first到达null，second才到达n+1
for (int i = 0; i < n; ++i) {
first = first.next;
}
while (first != null) {
first = first.next;
second = second.next;
}
second.next = second.next.next;
ListNode ans = dummy.next;
return ans;
}
}
876. 链表的中间结点
class Solution {
public ListNode middleNode(ListNode head) {
ListNode p1 = head;
ListNode p2 = head;
while(p2.next!=null){
p1 = p1.next;
p2 = p2.next;
if(p2.next!=null){
p2 = p2.next;
}
}
return p1;
}
}
142. 环形链表 II （一遍AC）
- 这个思路之前有学过，所以简单推导一下就得到了：简单来说就是环形操场跑步的问题，同时出发，一个速度为v另一个速度为2v，两人相遇的时候，说明快的人比慢的人多走了一圈，相遇的点也正好是快的人一半路程的位置。
- 这对比环形链表问题也是同理的，即开始节点到相遇节点距离 = 相遇节点环形到下次该节点 = 环形的长度
- 有了以上推断，那么在开始位置设置指针 p1， 相遇位置设置指针p2， 两个指针相遇的地方就是这个豁口啦
- 引用labuladong的图解
public class Solution {
public ListNode detectCycle(ListNode head) {
ListNode p1 = head;
ListNode p2 = head;
if (head==null) return null;
while(true){
if(p2.next == null){
return null;
}
else if(p2.next.next == null){
return null;
}
else{
p1 = p1.next;
p2 = p2.next.next;
}
if (p1 == p2){
break;
}
}
ListNode p3 = head;
while(p2!=p3){
p2 = p2.next;
p3 = p3.next;
}
return p2;
}
}
160. 相交链表
- 直接想法是，遍历一个链表存为hash，遍历另一个链表检查是否有重复，但是这样的时间复杂度为 O(m+n).,空间复杂度为O(n).
- 答案的思路是补齐，因为现在的问题是两个链表不同步，如果在每个链表的前边加上与另一链表相同的长度（里边的值无所谓），那么两个链表在评估的时候就是对齐的，这里不用担心前边加的链表会影响结果，因为前边的链表是在不对齐的状态下，如果真的有相同位置的值相同，那么说明两条链表的长度是一样的，因此不会对结果产生影响。
- leecode评论区：对的人错过了还是会相遇， 错的人相遇了也是NULL
public class Solution {
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
ListNode p1 = headA;
ListNode p2 = headB;
int flag1 = 0;
int flag2 = 0;
if (headA == null || headB == null) return null;
while(p1 != null || flag1==0){
if (flag1==0 && p1 == null){
p1 = headB;
flag1 = 1;
}
if(flag2==0 && p2 == null){
p2 = headA;
flag2 = 1;
}
if (p1 == p2) return p1;
p1 = p1.next;
p2 = p2.next;
}
return null;
}
}
-
官方题解
-
最开始不太理解，为什么没有处理 第一次为null和第二次为null的情况，
- 第一次：如果在过程中二者同时为null，那么其实不需要再遍历拼接段之后的链表，因为两个链表的长度一致，遍历过一次没有重复那么返回null即可
- 第二次：如果前期都没有匹配，那么最后Pa = null Pb= null一定是同时到达的，满足截至条件
public class Solution {
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
if (headA == null || headB == null) return null;
ListNode pA = headA, pB = headB;
while (pA != pB) {
pA = pA == null ? headB : pA.next;
pB = pB == null ? headA : pB.next;
}
return pA;
}
}
- 看到题解中还有一种很巧妙的思路就是把某一链表的首尾连接起来，变成上述寻找豁口的问题，但是这样会改变链表原有的结构
463
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
