第一章节--链表专题

链表专题

概念

堆和栈的区别？

数组：将元素在内存中连续存放，由于每个元素占用内存相同，可以通过下标迅速访问数组中任何元素。一般来说，数组适合查找元素而不是增加或者删除元素

链表：链表中的元素在内存中不是顺序存储的，而是通过存在元素中的指针联系到一起，每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针。如果要访问链表中一个元素，需要从第一个元素始，一直找到需要的元素位置。但是增加和删除一个元素对于链表数据结构就非常简单了，只要修改元素中的指针就可以了。

数组与链表的区别？

区别：

存储位置：数组逻辑上相邻的元素在物理存储位置上也相邻，而链表不一定；
存储空间：数组是连续的一段内存空间，而链表的存储空间不一定连续。一般情况下存放相同多的数据数组占用较小的内存，因为链表还需要存放其前驱和后继的空间。
长度可变性：链表的长度是按实际需要可以伸缩的，而数组的长度是在定义时要决定，如果存放的数据个数超过了数组的初始大小，则会出现溢出现象。
按序号查找时，数组可以随机访问，时间复杂度为O(1)，而链表不支持随机访问，平均需要O(n)；
按值查找时，若数组无序，数组和链表时间复杂度均为O(n)，但是当数组有序时，可以采用折半查找将时间复杂度降为O(logn)；

数组遍历与链表遍历

数组

for(int i =0;i<=arr.length;i++){
    print(arr[i])
}

链表

for(ListNode cur = head; cur!=null; cur = cur.next){
print(cur.val)
}

逆序遍历

数组

for(int i = arr.length - 1; i > - 1;i--) {
    print(arr[i])
}

链表

for (ListNode cur = tail; cur != null; cur = cur.pre) {
    print(cur.val)
}

考点解析

指针修改

典型问题 --- 链表翻转

由于链表的递归性，实际上，我们只要反转其中相邻的两个，剩下的采用同样的方法完成即可。在这里插入图片描述

核心思想

next = cur.next;//先储存next节点的值
cur.next = pre; //修改cur的next指针
pre = cur;//移动pre到cur
cur = next;//移动cur到下一个节点

链表拼接

注意事项

出现了环，造成死循环
分不清边界，导致边界条件出错 --- 虚拟头dummy的运用
搞不懂递归怎么做

技巧

1.dummy head

作用：

将头节点变成中间节点，简化判断。
通过在合适的时候断开链接，返回链表的中间节点

如果我们用一个虚拟头指向头节点，虚拟头就是新的头节点了，而虚拟头不是题目给的节点，不参与运算，因此不需要特殊判断，虚拟头就是这个作用。

例题

lc206. 给你单链表的头节点 head ，请你反转链表，并返回反转后的链表

class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode prev = null;
        ListNode cur = head;
        while(cur!=null){
            ListNode next = cur.next;
            cur.next = prev;
            prev = cur;
            cur = next;
            

        }
        return prev;
        

    }
}

2.快慢指针

典型题目：寻找距离尾部第K个节点、寻找环入口、寻找公共尾部入口等

算法流程：设两指针 fast，slow 指向链表头部 head，fast 每轮走 2 步，slow 每轮走 1 步；

第一种结果： fast 指针走过链表末端，说明链表无环，直接返回 null；

TIPS: 若有环，两指针一定会相遇。因为每走 1 轮，fast 与 slow 的间距 +1，fast 终会追上 slow；
第二种结果：当fast == slow时，两指针在环中第一次相遇。下面分析此时fast 与 slow走过的步数关系：

设链表共有 a+b个节点，其中链表头部到链表入口有 a 个节点（不计链表入口节点），链表环有 b个节点；

设两指针分别走了 f，s 步，则有： fast 走的步数是slow步数的 2 倍，即 f = 2s； fast 比 slow多走了 n 个环的长度，即 f = s + nb；以上两式相减得：f = 2nb，s = nb，

目前情况分析：

如果让指针从链表头部一直向前走并统计步数k，那么所有走到链表入口节点时的步数是：k=a+nb。而目前，slow 指针走过的步数为 nb 步。因此，我们只要想办法让 slow 再走 a 步停下来，就可以到环的入口。但是我们不知道 a 的值，该怎么办？

依然是使用双指针法。我们构建一个指针，此指针需要有以下性质：此指针和slow 一起向前走 a 步后，两者在入口节点重合。那么从哪里走到入口节点需要 a 步？答案是链表头部head。

双指针第二次相遇：

slow指针位置不变，将fast指针重新指向链表头部节点；slow和fast同时每轮向前走 1 步；此时 f = 0，s = nb ；

当 fast 指针走到f = a 步时，slow 指针走到步s = a+nb，此时两指针重合，并同时指向链表环入口。返回节点

复杂度分析：时间复杂度 O(N) 空间复杂度 O(1) ：双指针使用常数大小的额外空间。

例题

lc142.环形链表II
给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode fast = head, slow = head;
        while (true) {
            if (fast == null || fast.next == null) return null;
            fast = fast.next.next;
            slow = slow.next;
            if (fast == slow) break;
        }
        fast = head;
        while (slow != fast) {
            slow = slow.next;
            fast = fast.next;
        }
        return fast;
    }
}

3.归并排序 --自顶向下和自底向上

归并排序基于分治算法。最容易想到的实现方式是自顶向下的递归实现，考虑到递归调用的栈空间，自顶向下归并排序的空间复杂度是 O(nlogn)。如果要达到 O(1)的空间复杂度，则需要使用自底向上的实现方式。

以leetcode148 排序链表为例

自顶向下

class Solution {
    public ListNode sortList(ListNode head) {
        return sortList(head, null);
    }
public ListNode sortList(ListNode head, ListNode tail) {
    if (head == null) {
        return head;
    }
    if (head.next == tail) {
        head.next = null;
        return head;
    }
    ListNode slow = head, fast = head;
    while (fast != tail) {
        slow = slow.next;
        fast = fast.next;
        if (fast != tail) {
            fast = fast.next;
        }
    }
    ListNode mid = slow;
    ListNode list1 = sortList(head, mid);
    ListNode list2 = sortList(mid, tail);
    ListNode sorted = merge(list1, list2);
    return sorted;
}

public ListNode merge(ListNode head1, ListNode head2) {
    ListNode dummyHead = new ListNode(0);
    ListNode temp = dummyHead, temp1 = head1, temp2 = head2;
    while (temp1 != null && temp2 != null) {
        if (temp1.val <= temp2.val) {
            temp.next = temp1;
            temp1 = temp1.next;
        } else {
            temp.next = temp2;
            temp2 = temp2.next;
        }
        temp = temp.next;
    }
    if (temp1 != null) {
        temp.next = temp1;
    } else if (temp2 != null) {
        temp.next = temp2;
    }
    return dummyHead.next;
}
}

Leetcode--链表总结