leetcode刷题打卡(链表)

1. 移除链表元素（简单）

   给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

   示例 1：

   输入：head = [1,2,6,3,4,5,6], val = 6 输出：[1,2,3,4,5] 示例 2：

   输入：head = [], val = 1 输出：[] 示例 3：

   输入：head = [7,7,7,7], val = 7 输出：[]

//正常删除
class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode tmpHead=new ListNode(0);//注意第一个找到返回空，所以需要弄个假节点
        tmpHead.next=head;
        ListNode tmp=tmpHead;
        while(tmp.next!=null){
            if(tmp.next.val==val){
                tmp.next=tmp.next.next; 
                continue;//比else好一些
            }
            tmp=tmp.next;
        }
        return tmpHead.next;
    }
}

2.设计链表（中等）

设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：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 个节点。

示例：

MyLinkedList linkedList = new MyLinkedList(); linkedList.addAtHead(1); linkedList.addAtTail(3); linkedList.addAtIndex(1,2); //链表变为1-> 2-> 3 linkedList.get(1); //返回2 linkedList.deleteAtIndex(1); //现在链表是1-> 3 linkedList.get(1); //返回3

class ListNode{
    ListNode next;
    int val;
    ListNode(){}
    ListNode(int val){
        this.val=val;
    }
}
class MyLinkedList {
    ListNode head;
    int size;
​
    public MyLinkedList() {
        size=0;
        head=new ListNode(0);
    }
    
    public int get(int index) {
        if(index<0||index>=size)return -1;
        
        ListNode tmp=head;
        while(index!=-1){
            tmp=tmp.next;
            index--;
        }
        return tmp.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;
        if(index<0)index=0;
        size++;
        ListNode tmp=head;
        while(index!=0){
            tmp=tmp.next;
            index--;
        }
        ListNode addIndex=new ListNode(val);
        addIndex.next=tmp.next;
        tmp.next=addIndex;
    }
    
    public void deleteAtIndex(int index) {
        if(index<0||index>=size)return;
        size--;
        ListNode tmp=head;
        while(index!=0){
            tmp=tmp.next;
            index--;
        }
        tmp.next=tmp.next.next;
    }
}
​

3.反转链表（简单）

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

class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode pred=null,cur=head;
        while(cur!=null){
            ListNode tmp=cur.next;
            cur.next=pred;
            pred=cur;
            cur=tmp;
        }
        return pred;
    }
}

4.两两交换链表中的节点（中等）

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

由于有空链表，所以初始化一个哑节点dummyNode指向头节点，两两翻转

class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode dummyNode=new ListNode(0);//哑节点初始化
        dummyNode.next=head;
        ListNode tmp = dummyNode;/
        while(tmp.next!=null && tmp.next.next != null){//两两互换需要三个指针tmp->node1->node2
            ListNode node1 = tmp.next;
            ListNode node2 = tmp.next.next;
            tmp.next = node2;//将第一个不用交换的指向要交换的第二个节点tmp->node2
            node1.next = node2.next;//先将第一个要交换的指向第二个节点的下一个，不能先把要交换第二个节点指向要交换的第一个node1->next->node2->next
            node2.next = node1;//再把第二个要交换的节点指向第一个要交换的node2->node1
            tmp = node1;//此时之前的第一个节点已经被交换到node2的位置，所以将tmp更新到node1
        }
        return dummyNode.next;
    }
}

5.删除链表的倒数第 N 个结点（中等）

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

示例 1：

输入：head = [1,2,3,4,5], n = 2 输出：[1,2,3,5] 示例 2：

输入：head = [1], n = 1 输出：[] 示例 3：

输入：head = [1,2], n = 1 输出：[1]

先后指针

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummyNode = new ListNode(0);
        dummyNode.next = head;
        ListNode fast = dummyNode;
        while(n--!=0){//先指针先行
            fast = fast.next;
        }
        ListNode slow = dummyNode;
        while(fast.next!=null){//先指针提前一步停止，防止后指针多走
            slow = slow.next;
            fast = fast.next;
        }
        slow.next = slow.next.next;//后指针删除节点
        return dummyNode.next;
    }
}

6.环形链表 II（中等）

给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。

输入：head = [3,2,0,-4], pos = 1 输出：返回索引为 1 的链表节点 解释：链表中有一个环，其尾部连接到第二个节点。

输入：head = [1,2], pos = 0 输出：返回索引为 0 的链表节点 解释：链表中有一个环，其尾部连接到第一个节点。

快慢指针：找环用快慢指针是套路

思路：先找快慢相遇点，然后从头节点和相遇节点一起走，相遇就是环入口(必定会相遇)

循环找快慢第一次相遇(其实有环一直走的话每次都会在同一个点相遇)

终止条件：1.fast==null和fast.next==null(没找到环)

1. fast==slow(找到环)

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

链接：https://leetcode-cn.com/
来源：力扣（LeetCode）