代码随想录 链表

题目概览

1.移除链表元素：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

2. 设计链表：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

3. 翻转链表：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

4. 两两交换链表结点：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

5.删除链表倒数第N个节点： 力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

6.链表相交：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台 

7. 环形链表2：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

虚拟头节点的使用：可避免对头节点进行特殊操作，头节点的删减和其他结点操作相同。

一些特殊情况下，头结点的位置发生改变，虚拟头结点依旧可以定位到新链表的头节点。 

移除链表元素

 顺序遍历一遍链表，找出其中值为val的节点，将其前置节点指向后继节点

关键：找出前置结点 创建一个新的指针用于暂存每个结点的前置结点

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        if(head==null) return null;
        ListNode dummyNode=new ListNode(0,head);
        ListNode p=dummyNode;
        ListNode q=head;
        while(q!=null){
            if(q.val==val){
                p.next=q.next;
                q=q.next;
            }else{
                p=q;
                q=q.next;
            }
            
        }
        return dummyNode.next;
    }
}

时间复杂度：O(n)

空间复杂度：O(1)

设计链表

题目描述：

1.get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。

2.addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。

3.addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。

4.addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val  的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。 

5.deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

1.get(index)直接遍历链表即可 如果index超出链表长度 返回-1

2.addAtHead(val)可以看作是4的特殊情况 直接调用addAtIndex(0,val)

3.addAtTail(val)可以看作是4的特殊情况 直接调用addAtIndex(size,val)

注：这边设计链表的时候需要定义一个变量用来存储链表的长度

4.addAtIndex(index,val)首先先对index判断一下，如果等于链表长度，直接在链表结尾加入一个新节点，如果大于链表长度，返回空。一般情况下，定义一个结点存储其他节点的前置节点，顺序遍历。新节点指向后继结点，前置结点指向新结点。

5.deleteAtIndex(index)首先对index判断一下，如果大于链表长度或小于0，返回空。一般情况下，定义一个节点存储其他结点的前置节点，前置节点指向其后继节点即可。

class ListNode{
    int val;
    ListNode next;
    public ListNode(){}
    public ListNode(int val){
        this.val=val;
    }
}
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 currentNode=head;
       for(int i=0;i<=index;i++){
           currentNode=currentNode.next;
       }
        return currentNode.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;
        else if(index<0) index=0;
        else{
        ListNode p=head;
        for(int i=0;i<index;i++){
        p=p.next;
        }
        ListNode q=new ListNode(val);
        q.next=p.next;
        p.next=q;
        size++;
        }
    }
    
    public void deleteAtIndex(int index) {
        if(index>=size||index<0) return;
        ListNode p=head;
        for(int i=0;i<index;i++){
            p=p.next;
        }
        p.next=p.next.next;
        size--;
    }
}

 时间复杂度：O(index)

空间复杂度：O(n)

翻转链表

 第一个节点指向空，定义一个新指针用来保存每个节点的后继节点，需要修改的节点指向前置结点。循环遍历，遍历的出口是当前节点指向空。

class Solution {
    public ListNode reverseList(ListNode head) {
       ListNode p=head;
       ListNode q=null;
       ListNode temp=null;
       while(p!=null){
           temp=p.next;
           p.next=q;
           q=p;
           p=temp;
       }
       return q;
    }
}

时间复杂度：O(n)

空间复杂度：O(1)

两两交换链表中的节点

不能单纯交换链表节点的值，需要有实际节点的交换。

交换节点后的链表 

上述操作

cur节点初始指向虚拟头结点（此处头结点需要交换 交换完成之后 头结点位置发生变化）

定义三个临时节点用于存储 

first用来存储要交换的第一个节点 即 first=cur.next；

second用来存储要交换的第二个节点 即 second=cur.next.next；

temp用来存储下次交换节点的第一个节点 即temp=second.next；

步骤一：cur.next=second；

步骤二：second.next=first；

步骤三：first.next=temp；

更新cur的位置 指向将要交换两个节点的前置节点 即cur=first；

遍历的出口：1.链表节点个数为偶数 cur.next为空

                      2.链表节点个数为奇数 cur.next.next为空

class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode dummyhead=new ListNode(-1);
        dummyhead.next=head;
        ListNode cur=dummyhead;
        while(cur.next!=null&&cur.next.next!=null){
            ListNode temp=cur.next;
            ListNode temp1=cur.next.next.next;
            cur.next=cur.next.next;
            cur.next.next=temp;
            temp.next=temp1;
            cur=temp;

        }
        return dummyhead.next;
    }
}

时间复杂度：O(n)

空间复杂度：O(1)

删除链表倒数第N个节点

快慢指针

fast指针先行n+1个结点 目的是为了使slow结点指向要删除结点的上一个结点

fast和slow同时向后移动

直到移动到链表结尾 slow.next=slow.next.next；

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
       ListNode dummyNode=new ListNode(-1); 
       dummyNode.next=head;
       ListNode slow=dummyNode;
       ListNode fast=dummyNode;
       for(int i=0;i<=n;i++){
           fast=fast.next;
       }
       while(fast!=null){
           fast=fast.next;
           slow=slow.next;
       }
       slow.next=slow.next.next;
       return dummyNode.next;
    }

时间复杂度：O(n)

空间复杂度：O(1) 

链表相交

首先为了规范链表操作，定义A链为较长链，B链为较短链

分别求出两条链表的长度 

如果B链长度大于A链长度 交换节点名称

定义两个节点p，q分别进行节点的遍历

让p先遍历（链表A的长度-链表B的长度）

然后p和q同时开始遍历，当p和q节点值相同时返回，p，q所指向的节点即相交的初始节点

如果p，q指向节点值不相同，双双往后移动，若遍历到链表结尾也未找到，返回null；

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode p=headA;
        ListNode q=headB;
        int lenA=0,lenB=0;
        while(p!=null){
            lenA++;
            p=p.next;
        }
        while(q!=null){
            lenB++;
            q=q.next;
        }
        p=headA;
        q=headB;
        if(lenB>lenA){
            int temp=lenA;
            lenA=lenB;
            lenB=temp;
            ListNode tem=p;
            p=q;
            q=tem;

        }
        int k=lenA-lenB;
        while(k-->0){
            p=p.next;
        }
        while(p!=null){
            if(p==q) return p;
            p=p.next;
            q=q.next;
            
        }
        return null;
    }
}

时间复杂度：O(n+m)    (n和m是链表的长度)

空间复杂度：O(1)

环形链表2

1.如何判断链表有没有环呢？

快慢指针

fast指针每次行动两个单位，slow指针每次行动一个单位 如果fast和slow相遇了则说明链表有环

但是不能判断链表有环的起始节点

2.如何寻找链表有环的起始节点呢？

slow走过的距离长度为 x+y；

fast走过的距离长度为 x+y+n(y+z)；

得到等式：2(x+y)=x+y+n(y+z)；

化简之后得到 x=(n-1)y+nz ；

当n=1时 x=z

x=z代表着当fast和slow指针相遇时，有一个节点p从相遇节点出发，有一个节点q从头结点出发，两者相遇的地方即为环形入口节点。

public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode fast=head;
        ListNode slow=head;
        while(fast!=null&&fast.next!=null){
            slow=slow.next;
            fast=fast.next.next;
            if(fast==slow){
                ListNode p=head;
                ListNode q=fast;
                while(p!=q){
                    p=p.next;
                    q=q.next;
                }
                return p;
            }
        }
        return null;
    }
}

时间复杂度：O(n)

空间复杂度：O(1)

总结

链表相关题目常见的解决方案

1.对链表进行操作时（包含对头节点的操作），通常在头节点之前插入一个新的虚拟头节点，避免操作过程中，头节点位置发生变化，最终只需返回dummyNode.next(新链表的头节点)

2.如果改变指针朝向的过程中出现了无法定位的结点，可以定义新的指针暂存关键节点，缺少几个就补充几个。

3.快慢指针 链表相交，链表有无环常用

4.链表有无环的判定？环形的入口判定的推导？