代码随想录算法训练营第3天 | 链表理论基础，203.移除链表元素，707.设计链表，206.反转链表-CSDN博客

本文链接：https://blog.csdn.net/weixin_52301226/article/details/133816491

203.移除链表元素

题目链接：LeetCode
文章讲解：代码随想录
视频讲解：哔哩哔哩
编写语言：Java
完成状态：已完成

解题思路

按照常规方式删除，考虑头结点和非头结点的不同情况。使用虚拟头结点时，可以综合到一种情况中去

代码

常规方式

/**
 * 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 {
    /**
     * 删除链表中指定数值的节点
     * @param head 链表头节点
     * @param val 指定数值
     * @return 删除指定数值节点后的链表头节点
     */
    public ListNode removeElements(ListNode head, int val) {
        // 首先判断头节点是否为指定数值，若是则一直移动头节点直到找到不是指定数值的节点
        while (head != null && head.val == val) {
            head = head.next;
        }

        // 如果链表为空或者已经删除完所有指定数值的节点，则直接返回头节点
        if (head == null) {
            return head;
        }

        // 遍历链表，删除指定数值的节点
        ListNode pre = head;
        ListNode cur = head.next;
        while (cur != null) {
            // 如果当前节点的值等于指定数值，则将前一个节点的next指针指向当前节点的next指针
            if (cur.val == val) {
                pre.next = cur.next;
            } else {
                // 如果当前节点的值不等于指定数值，则更新前一个节点的位置为当前节点
                pre = pre.next;
            }
            cur = cur.next;
        }
        // 返回删除指定数值节点后的链表头节点
        return 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 {
    /**
     * 移除链表中指定值的节点
     *
     * @param head 链表头节点
     * @param val  要移除的值
     * @return 移除指定值后的链表头节点
     */
    public ListNode removeElements(ListNode head, int val) {
        // 创建虚拟头节点
        ListNode dummy = new ListNode(0);
        dummy.next = head;

        ListNode pre = dummy; // 前一个节点
        ListNode cur = head; // 当前节点

        // 遍历链表
        while (pre.next != null) {
            if (cur.val == val) { // 如果当前节点的值等于要移除的值
                pre.next = cur.next; // 将前一个节点的next指向当前节点的next，实现删除操作
            } else {
                pre = pre.next; // 前一个节点指向下一个节点
            }
            cur = cur.next; // 当前节点指向下一个节点
        }
        
        return dummy.next; // 返回虚拟头节点的下一个节点作为新的链表头节点
    }
}

707.设计链表

题目链接：LeetCode
文章讲解：代码随想录
视频讲解：哔哩哔哩
编写语言：Java
完成状态：已完成

解题思路

将其全部整合为使用虚拟头结点操作，易于实现，只考虑一种情况
常规解法要分析头结点的特殊情况。

代码

设置虚拟头结点

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 MyLinkedList {

    int size; // 链表的长度
    ListNode dummy; // 虚拟头结点

    public MyLinkedList() { // 构造方法，初始化链表的长度为0，并创建虚拟头结点
        size = 0;
        dummy = new ListNode(0);
    }
    
    public int get(int index) { // 获取指定位置上的节点的值
        if (index < 0 || index >= size) { // 如果索引越界，则返回-1
            return -1;
        }
        ListNode cur = dummy; // 从虚拟头结点开始遍历
        for (int i = 0; i <= index; i++) { // 遍历到指定位置上的节点
            cur = cur.next;
        }
        return cur.val; // 返回节点的值
    }
    
    public void addAtHead(int val) { // 在链表头部插入节点
        addAtIndex(0, val); // 直接调用addAtIndex方法，在索引0处插入节点
    }
    
    public void addAtTail(int val) { // 在链表尾部插入节点
        addAtIndex(size, val); // 直接调用addAtIndex方法，在索引size处插入节点，即链表尾部
    }
    
    public void addAtIndex(int index, int val) { // 在指定位置上插入节点
        if (index > size) { // 如果插入的位置超过了链表的长度，则不插入
            return;
        }
        if (index < 0) { // 如果插入的位置小于0，则将索引设置为0
            index = 0;
        }
        ListNode cur = dummy; // 从虚拟头结点开始遍历
        for (int i = 0; i < index; i++) { // 遍历到指定位置的前一个节点
            cur = cur.next;
        }
        ListNode newNode = new ListNode(val); // 创建新的节点
        newNode.next = cur.next; // 将新节点的下一个节点指向当前节点的下一个节点
        cur.next = newNode; // 将当前节点的下一个节点指向新节点
        size++; // 链表长度加1
    }
    
    public void deleteAtIndex(int index) { // 删除指定位置上的节点
        if (index < 0 || index >= size) { // 如果索引越界，则不删除
            return;
        }
        
        ListNode cur = dummy; // 从虚拟头结点开始遍历
        for (int i = 0; i < index; i++) { // 遍历到指定位置的前一个节点
            cur = cur.next;
        }
        cur.next = cur.next.next; // 将当前节点的下一个节点指向下下一个节点，即删除指定位置的节点
        size--; // 链表长度减1
    }
}

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

题目链接：LeetCode
文章讲解：代码随想录
视频讲解：哔哩哔哩
编写语言：Java
完成状态：已完成

解题思路

设置两个指针pre和cur，通过平行移动一个一个反转链表
对于递归操作，定义好函数按照双指针往上面套即可

代码

双指针法

/**
 * 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 {
    /**
     * 反转单链表
     * @param head 链表头节点
     * @return 反转后的链表头节点
     */
    public ListNode reverseList(ListNode head) {
        ListNode pre = null; //前驱节点，初始为null
        ListNode cur = head; //当前节点，初始为链表头节点
        while (cur != null) { //遍历链表
            ListNode temp = cur.next; //暂存当前节点的下一个节点
            cur.next = pre; //将当前节点的next指针指向前驱节点
            pre = cur; //更新前驱节点为当前节点
            cur = temp; //更新当前节点为下一个节点
        }
        return pre; //返回反转后的链表头节点
    }
}

递归

/**
 * 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 {
    /**
     * 反转单链表
     *
     * @param head 链表的头节点
     * @return 反转后的链表头节点
     */
    public ListNode reverseList(ListNode head) {
        // 调用辅助方法进行反转，并将结果返回
        return reverse(null, head);
    }

    /**
     * 辅助方法，递归地反转链表
     *
     * @param pre 上一个节点
     * @param cur 当前节点
     * @return 反转后的链表头节点
     */
    public ListNode reverse(ListNode pre, ListNode cur) {
        // 若当前节点为空则说明已经到达了链表尾部，直接返回上一个节点作为反转后的链表头节点
        if (cur == null) {
            return pre;
        }
        
        // 保存当前节点的下一个节点的引用
        ListNode temp = cur.next;
        
        // 反转当前节点的指针，指向上一个节点
        cur.next = pre;
        
        // 继续递归，将当前节点变为上一个节点，下一个节点变为当前节点
        return reverse(cur, temp);
    }
}