这里写自定义目录标题

• 203. 移除链表元素
• • 1、递归
  • 2、删除头结点时另做考虑
  • 3、虚拟头结点
• 707. 设计链表
• • 方法一：单链表
  • 方法二：双链表
• 206. 反转链表
• • 方法一：双指针法
• 24. 两两交换链表中的节点—（中等）
• • 方法一：递归
  • 方法二：虚拟头结点
• 19. 删除链表的倒数第 N 个结点—（中等）
• • 方法一：双指针
• 面试题 02.07. 链表相交
• • 双指针
• 142. 环形链表 II
• • 双指针

203. 移除链表元素

力扣题解地址

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

输入：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
输出：[]

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 removeElements(ListNode head, int val) {
        if(head==null){
            return head;
        }
        head.next = removeElements(head.next, val);
        return head.val == val ? head.next : head; 
    }
}

2、删除头结点时另做考虑

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        // 判断头结点是否为空
        while(head !=null && head.val == val){
            head = head.next;
        }
        if(head == null) return head;
        // 判断头结点是否为目标值
        ListNode pre=head;
        while(pre.next!=null){
            //值相等，换下一个节点
            if(pre.next.val == val){
                pre.next = pre.next.next;  // 把下一个节点的指向地址——这个节点的指向地址
            }else{
                pre = pre.next;  // 换下一个节点的值进行判断，没有改变链表
            }
        }
        return head;
    }
}

3、虚拟头结点

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode x = new ListNode(1);  // 创建虚拟节点
        x.next = head;
        ListNode pre = x;
        while(pre.next!=null){
            if(pre.next.val == val){
                pre.next = pre.next.next;
            }else{
                pre = pre.next;
            }
        }
        return x.next;
    }
}

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 个节点。

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

方法一：单链表

public class ListNode{
    int val;
    ListNode next;
    ListNode(int x){
        val = x;
    }
} 

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;
        //第index节点的值
        ListNode pre = head;
        for(int i =0; i<index+1; ++i){
            pre = pre.next;
        }
        return pre.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 pre = head;
        for(int i =0; i < index; ++i){
            pre = pre.next;
        }
        ListNode x = new ListNode(val);
        x.next = pre.next;
        pre.next = x;

    }
    
    public void deleteAtIndex(int index) {
        if(index<0 || index>= size) return;
        size--;
        ListNode pre = head;
        for(int i =0; i < index; ++i){
            pre = pre.next;
        }
        pre.next = pre.next.next;
    }
}

/**
 * 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);
 */

方法二：双链表

class MyLinkedList {
    class ListNode{
        int val;
        ListNode next,prev;
        ListNode(int x){val=x;}
    }

    int size;
    ListNode head,tail;  //伪头结点.尾结点

    public MyLinkedList() {
        size = 0;
        head = new ListNode(0);
        tail = new ListNode(0);
        head.next = tail;
        tail.prev = head;
    }
    
    public int get(int index) {
        if(index < 0 || index >= size) return -1;
        //第index节点的值
        ListNode b = head;
        if(index < (size-1)/2){
            for(int i=0; i<=index; ++i){
                b = b.next;
            }
        }else{
            b = tail;
            for(int i =0; i<=size-index-1; ++i){
                b = b.prev;
            }
        }
        return b.val;

    }
    
    public void addAtHead(int val) {
        ListNode cur = head;
        ListNode newNode = new ListNode(val);
        newNode.next = cur.next;
        cur.next.prev = newNode;
        cur.next = newNode;
        newNode.prev = cur;
        ++size;
    }
    
    public void addAtTail(int val) {
        ListNode cur = tail;
        ListNode newNode = new ListNode(val);
        newNode.next = tail;
        newNode.prev = cur.prev;
        cur.prev.next = newNode;
        cur.prev = newNode;
        ++size;
    }
    
    public void addAtIndex(int index, int val) {
        if(index > size) return;
        if(index < 0) index = 0;
        ListNode cur = head;
        ListNode newNode = new ListNode(val);
        for(int i =0; i <index; ++i){
            cur=cur.next;
        }
        ++size;
        // cur为 第index节点在，在之后插入节点
        newNode.prev = cur;
        newNode.next = cur.next;
        cur.next.prev = newNode; 
        cur.next = newNode;
    }
    
    public void deleteAtIndex(int index) {
        if(index<0 || index>=size) return ;
        ListNode cur = head;
        for(int i =0; i<index; ++i){
            cur = cur.next;
        }
        cur.next.next.prev = cur;
        cur.next = cur.next.next;
    
        --size;
    }
}

/**
 * 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);
 */

206. 反转链表

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

示例 1：

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

示例 2：

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

示例 3：

输入：head = []
输出：[]

方法一：双指针法

/**
 * 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 reverseList(ListNode head) {
        ListNode pre = null;
        ListNode cur = head;
        ListNode temp = null;
        //双指针法
        while(cur != null){
            temp = cur.next;
            cur.next = pre;
            pre = cur;
            cur = temp;
        }
        return pre;
    }
}

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

力扣题解

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

示例 1：

输入：head = [1,2,3,4]
输出：[2,1,4,3]

示例 2：

输入：head = []
输出：[]

示例 3：

输入：head = [1]
输出：[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 swapPairs(ListNode head) {
        if(head == null || head.next == null){
            return head;  // 1
        }
        // 1--2--3--4
        ListNode next = head.next; //next为2 
        head.next = swapPairs(next.next); //  head.next 指向4  2--->4
        next.next = head;   // 1-->2
        return next;  // 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 swapPairs(ListNode head) {
        ListNode dummyNode = new ListNode(0);
        dummyNode.next = head;
        ListNode prev = dummyNode ;
        // prev-- 1--2--3--4
        while(prev.next != null && prev.next.next != null){
            ListNode start = prev.next;    // 1
            ListNode end = prev.next.next;  // 2
            prev.next = end; // 0--2
            start.next = end.next; // 1--3
            end.next = start;   // 2--1
            prev = start;   //开始为 1 
        }
        return dummyNode.next;
    }
}

19. 删除链表的倒数第 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]

方法一：双指针

/**
 * 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 removeNthFromEnd(ListNode head, int n) {
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode slow = dummy;
        ListNode fast = head;
        for(int i=0; i<n; ++i){
            fast = fast.next;
        }
        while(fast!=null){
            slow = slow.next;
            fast = fast.next;
        }
        slow.next = slow.next.next;
        return dummy.next;

    }
}

面试题 02.07. 链表相交

力扣

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

图示两个链表在节点 c1 开始相交：

题目数据 保证 整个链式结构中不存在环。
注意，函数返回结果后，链表必须 保持其原始结构 。

示例 1：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at '8'
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

示例 2：

输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Intersected at '2'
解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。
在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。

示例 3：

输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。
由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
这两个链表不相交，因此返回 null 。

双指针

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode A = headA;
        ListNode B = headB;
        while(A != B){
            A= A!=null ? A.next:headB;
            B= B!=null ? B.next:headA;
        }
        return A;
    }
}

142. 环形链表 II

力扣

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

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

不允许修改 链表。

示例 1：

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

示例 2：

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

示例 3：

输入：head = [1], pos = -1
输出：返回 null
解释：链表中没有环。

双指针

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode fast = head;  //双指针
        ListNode slow = head;
        //找到两个指针相遇的节点 f=2s f=s+nb ----> s=nb
        while(true){
            if(fast==null || fast.next==null) return null;
            fast = fast.next.next;
            slow = slow.next;
            if(fast==slow) break;
        }
        fast = head; // slow走了nb，再走a就是入口
        // 在一次相遇  就是环形入口 
        while(slow != fast){
            fast = fast.next;
            slow = slow.next;
        }
        return slow;
    }
}