代码随想录五刷day2

最新推荐文章于 2026-06-23 21:03:17 发布

原创最新推荐文章于 2026-06-23 21:03:17 发布 · 294 阅读

4 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

标签

#java #算法 #数据结构 #leetcode

力扣题解专栏收录该内容

296 篇文章

订阅专栏

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

前言
一、力扣203. 移除链表元素
二、力扣707. 设计链表
三、力扣206. 反转链表
四、力扣24. 两两交换链表中的节点
五、力扣19. 删除链表的倒数第 N 个结点
六、力扣面试题 02.07. 链表相交
七、力扣 142. 环形链表 II

前言

链表的经典操作有，1、虚拟头结点，2、双指针不同时起步，3、快慢指针

一、力扣203. 移除链表元素

移除链表中指定值的节点，新建一个头结点，然后遍历原链表，同时使用一个尾指针，进行尾插法，最后返回结果

/**
 * 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) {
        ListNode res = new ListNode(-1,null);
        ListNode p = head, r = res;
        while(p != null){
            if(p.val != val){
                r.next = p;
                r = r.next;
            }
            p = p.next;
        }
        r.next = null;
        return res.next;
    }
}

二、力扣707. 设计链表

自定义一个链表内部类，作为自己的一个虚拟头结点的属性，再加上一个count属性用于计数，在自定义一个获取指定下标的前置节点的方法，就可以完成题目

class MyLinkedList {
    class Node{
        int val;
        Node next;
        public Node(){

        }
        public Node(int val, Node next){
            this.val = val;
            this.next = next;
        }
    }
    Node head;
    int count;

    public MyLinkedList() {
        this.head = new Node(-1,null);
        count = 0;
    }
    
    public int get(int index) {
        if(index < 0 || index >= count){
            return -1;
        }
        Node p = getPreIndexNode(index);
        return p.next.val;
    }
    
    public void addAtHead(int val) {
        Node p = new Node(val,null);
        p.next = head.next;
        head.next = p;
        count ++;
    }
    
    public void addAtTail(int val) {
        Node r = getPreIndexNode(count);
        Node p = new Node(val,null);
        r.next = p;
        count ++;
    }
    
    public void addAtIndex(int index, int val) {
        if(index < 0 || index > count){
            return;
        }
        Node r = getPreIndexNode(index);
        Node p = new Node(val,null);
        p.next = r.next;
        r.next = p;
        count ++;
    }
    
    public void deleteAtIndex(int index) {
        if(index < 0 || index >= count){
            return;
        }
        Node r = getPreIndexNode(index);
        r.next = r.next.next;
        count --;
    }
    private Node getPreIndexNode(int index){
        Node p = head;
        for(int i = 0; i < index; i ++){
            p = p.next;
        }
        return p;
    }
}

/**
 * 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. 反转链表

直接使用头插法就可以反转链表

/**
 * 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 L = new ListNode(-1,null);
        ListNode p = head;
        while(p != null){
            ListNode r = p;
            p = p.next;
            r.next = L.next;
            L.next = r;
        }
        return L.next;
    }
}

四、力扣24. 两两交换链表中的节点

通过设置前置头结点，前置指针，每次使用两个指针进行遍历，遍历过程中，使用两个新指针记录这两个指针的值，同时，进行那两个循环指针的位置重置，两个新指针的位置交换和前置指针位置的重置

/**
 * 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;
        }
        ListNode res = new ListNode(-1,head);
        ListNode pre = res, p1 = pre.next, p2 = p1.next;
        while(p1 != null && p2 != null){
            ListNode s1 = p1, s2 = p2;
            pre.next = p2.next;
            if(p2.next != null){
                p1 = p2.next;
                if(p1.next != null){
                    p2 = p1.next;
                }else{
                    p2 = null;
                }
            }else{
                p1 = null;
            }
            s1.next = pre.next;
            s2.next = s1;
            pre.next = s2;
            pre = s1;
        }
        return res.next;
    }
}

五、力扣19. 删除链表的倒数第 N 个结点

双指针的经典应用，如果要删除倒数第n个节点，让fast移动n步，然后让fast和slow同时移动，直到fast指向链表末尾。删掉slow所指向的节点就可以了。

/**
 * 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 L = new ListNode(-1, head);
        int count = 0;
        ListNode p = L;
        while(p.next != null){
            count ++;
            p = p.next;
        }
        int index = count - n;
        p = L;
        for(int i = 0; i < index; i ++){
            p = p.next;
        }
        p.next = p.next.next;
        return L.next;
    }
}

快慢双指针解法

/**
 * 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 L = new ListNode(-1, head);
        ListNode fast = L, slow = L;
        while(n -- > 0){
            fast = fast.next;
        }
        while(fast.next != null){
            fast = fast.next;
            slow = slow.next;
        }
        slow.next = slow.next.next;
        return L.next;
    }
}

六、力扣面试题 02.07. 链表相交

链表相交的话，一定是由共同节点，先统计出长度，然后对其后，同步比对，就OK了

/**
 * 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) {
        if(headA == null || headB == null){
            return null;
        }
        ListNode La = new ListNode(-1,headA);
        ListNode Lb = new ListNode(-1,headB);
        int c1 = 0, c2 = 0;
        for(ListNode p = La; p.next != null; p = p.next){
            c1 ++;
        }
        for(ListNode p = Lb; p.next != null; p = p.next){
            c2 ++;
        }
        int c3 = Math.abs(c1 - c2);
        if(c1 >= c2){
            La.next = headA;
            Lb.next = headB;
        }else{
            La.next = headB;
            Lb.next = headA;
        }
        while(c3 -- > 0){
            La = La.next;
        }
        while(La.next != null && Lb.next != null){
            if(La.next == Lb.next){
                return La.next;
            }
            La = La.next;
            Lb = Lb.next;
        }
        return null;
    }
}

七、力扣 142. 环形链表 II

这里，一定要三段论，入环前L1，环分成两半，一半相遇前L2，一半相遇后L3,快指针一次走2步，慢指针一次走1步，相遇时，快指针走过的路是慢指针走过的2倍，有等式：2*（L1+L2）=L1+n*（L2+L3）+L2，变形后，L1= （n-1）*（L2+L3）+L3，此时说明，从相遇的点走上n-1圈，再把剩下的L3走完，就到达了，入环点，这里，一个指针从相遇点出发，一个指针从起始点出发，相遇的位置就是入环点

/**
 * 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) {
        if(head == null || head.next == head){
            return head;
        }
        ListNode fast = new ListNode(-1, head);
        ListNode slow = new ListNode(-1, head);
        while(fast.next != null && slow.next != null){
            if(fast.next.next != null){
                fast = fast.next.next;
                slow = slow.next;
            }else{
                return null;
            }
            if(fast == slow){
                ListNode p = new ListNode(-1, head);
                while(p != slow){
                    p = p.next;
                    slow = slow.next;
                }
                return p;
            }
        }
        return null;
    }
}