代码随想录Java算法训练营Day3 | 链表，LeetCode 203.移除链表元素、707.设计链表、206.反转链表

最新推荐文章于 2024-10-18 16:10:55 发布

MaMaya～

最新推荐文章于 2024-10-18 16:10:55 发布

阅读量47

点赞数

文章标签：算法 java 链表数据结构 leetcode

原文链接：https://programmercarl.com/0707.%E8%AE%BE%E8%AE%A1%E9%93%BE%E8%A1%A8.html#%E5%85%B6%E4%BB%96%E8%AF%AD%E8%A8%80%E7%89%88%E6%9C%AC

版权

参考文章：代码随想录 (programmercarl.com)

今日收获：链表的基础操作

学习时长：2h

链表理论基础

链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）。链表的入口节点称为链表的头结点也就是head。

链表的类型

单链表：上面提到的链表。单链表中的指针域只能指向节点的下一个节点。
双链表：每一个节点有两个指针域，一个指向下一个节点，一个指向上一个节点。双链表既可以向前查询也可以向后查询。

代码随想录官方图片
循环链表：链表首尾相连。可以用来解决约瑟夫环问题。

代码随想录官方图片

链表的存储方式

数组是在内存中是连续分布的，但是链表在内存中不是连续分布的。

链表是通过指针域的指针链接在内存中各个节点。所以链表中的节点在内存中不是连续分布的，而是散乱分布在内存中的某地址上，分配机制取决于操作系统的内存管理。

如图，这个链表起始节点为2，终止节点为7，各个节点分布在内存的不同地址空间上，通过指针串联在一起。

链表的定义

因为leetcode总是帮我们写好了，所以面试有时候干写会不熟悉，所以还是要自己多定义。

public class ListNode {
    int val; // 节点的值
    ListNode next; // 下一个节点

    // 节点的构造函数(无参)
    public ListNode() {
    }

    // 节点的构造函数(有一个参数)
    public ListNode(int val) {
        this.val = val;
    }

    // 节点的构造函数(有两个参数)
    public ListNode(int val, ListNode next) {
        this.val = val;
        this.next = next;
    }
}

链表的操作

删除节点

删除D节点，如图所示：

只要将C节点的next指针指向E节点就可以了。

那D节点不是依然存留在内存里么？只不过是没有在这个链表里而已。是这样的，所以在C++里最好是再手动释放这个D节点，释放这块内存。但是Java、Python，就有自己的内存回收机制，就不用自己手动释放了。

添加节点

链表的增添和删除都是O(1)操作，也不会影响到其他节点。

但是要注意，要是删除第五个节点，需要从头节点查找到第四个节点通过next指针进行删除操作，查找的时间复杂度是O(n)。

链表与数组的对比

数组在定义的时候，长度就固定。如果想改动数组的长度，就需重新定义一个新的数组。
链表的长度可以是不固定的，并且可以动态增删。适合数据量不固定、频繁增删、较少查询的场景。

LeetCode 203.移除链表元素

题目链接：203. 移除链表元素 - 力扣（LeetCode）

文章链接：代码随想录 (programmercarl.com)

视频链接：手把手带你学会操作链表 | LeetCode：203.移除链表元素_哔哩哔哩_bilibili

本题收获： 虚拟头节点

题目关键词：单链表

这题非常建议看视频学习，讲得非常细！

如果要删除的是头节点该怎么办？两种方法：一种是在原链表上进行操作，另一种是加一个虚拟头节点。虚拟头节点：在链表开头加一个头节点。

方法1：直接使用原来的链表来进行移除。

移除头结点和移除其他节点的操作是不一样的，因为链表的其他节点都是通过前一个节点来移除当前节点，而头结点没有前一个节点。

所以头结点如何移除？其实只要将头结点向后移动一位就可以，这样就从链表中移除了一个头结点。

在单链表中移除头结点和移除其他节点的操作方式是不一样，在写代码的时候需要单独写一段逻辑来处理移除头结点的情况。

public ListNode removeElements(ListNode head, int val) {
    // 如果头节点的值等于val，则将头节点指向下一个节点
    while(head!=null && head.val==val) {
        head = head.next;
    }
    // 定义当前节点为头节点
    ListNode curr = head;
    // 遍历链表
    while(curr!=null && curr.next !=null) {
        // 如果当前节点的下一个节点的值等于val，则将当前节点的下一个节点指向下下个节点
        if(curr.next.val == val){
            curr.next = curr.next.next;
        } else {
            // 否则，将当前节点指向下一个节点
            curr = curr.next;
        }
    }
    // 返回头节点
    return head;
}

递归思路：

基础情况：对于空链表，不需要移除元素。
递归情况：首先检查头节点的值是否为 val，如果是则移除头节点，答案即为在头节点的后续节点上递归的结果；如果头节点的值不为 val，则答案为头节点与在头节点的后续节点上递归得到的新链表拼接的结果。

public class Solution {
    public ListNode removeElements(ListNode head, int val) {
        // 基础情况：如果头节点为空，直接返回null
        if (head == null) {
            return null;
        }

        // 递归处理下一个节点
        head.next = removeElements(head.next, val);

        // 如果当前节点的值等于val，返回下一个节点
        if (head.val == val) {
            return head.next;
        } else {
            // 否则返回当前节点
            return head;
        }
    }
}

方法2：设置一个虚拟头结点dummy node。

这样原链表的所有节点就都可以按照统一的方式进行移除了。

注意：最后return 头结点的时候，别忘了 return dummyNode->next;，这才是新的头结点。

public ListNode removeElements(ListNode head, int val) {
    // 设置一个虚拟的头结点
    ListNode dummy = new ListNode();
    dummy.next = head;

    // 定义一个指针，指向当前节点
    ListNode cur = dummy;
    // 遍历链表
    while (cur.next != null) {
        // 如果当前节点的下一个节点的值等于要删除的值
        if (cur.next.val == val) {
            // 将当前节点的next指针指向下一个节点的下一个节点
            cur.next = cur.next.next;
        } else {
            // 否则，将指针指向下一个节点
            cur = cur.next;        
        }
    }
    // 返回虚拟头结点的下一个节点，即删除指定值后的链表
    return dummy.next;
}

LeetCode 707.设计链表

题目链接：707. 设计链表 - 力扣（LeetCode）

文章链接：代码随想录 (programmercarl.com)

本题收获：链表的基础操作，非常适合练习

这道题目设计链表的五个接口：

获取链表第index个节点的数值
在链表的最前面插入一个节点
在链表的最后面插入一个节点
在链表第index个节点前面插入一个节点
删除链表的第index个节点

//单链表
class ListNode {
    int val;
    ListNode next;
    ListNode(){}
    ListNode(int val) {
        this.val=val;
    }
}
class MyLinkedList {
    //size存储链表元素的个数
    int size;
    //虚拟头结点
    ListNode head;

    //初始化链表
    public MyLinkedList() {
        size = 0;
        head = new ListNode(0);
    }

    //获取第index个节点的数值，注意index是从0开始的，第0个节点就是头结点
    public int get(int index) {
        //如果index非法，返回-1
        if (index < 0 || index >= size) {
            return -1;
        }
        ListNode currentNode = head;
        //包含一个虚拟头节点，所以查找第 index+1 个节点
        for (int i = 0; i <= index; i++) {
            currentNode = currentNode.next;
        }
        return currentNode.val;
    }

    public void addAtHead(int val) {
        ListNode newNode = new ListNode(val);
        newNode.next = head.next;
        head.next = newNode;
        size++;

        // 在链表最前面插入一个节点，等价于在第0个元素前添加
        // addAtIndex(0, val);
    }

    
    public void addAtTail(int val) {
        ListNode newNode = new ListNode(val);
        ListNode cur = head;
        while (cur.next != null) {
            cur = cur.next;
        }

        cur.next = newNode;
        size++;

        // 在链表的最后插入一个节点，等价于在(末尾+1)个元素前添加
        // addAtIndex(size, val);
    }

    // 在第 index 个节点之前插入一个新节点，例如index为0，那么新插入的节点为链表的新头节点。
    // 如果 index 等于链表的长度，则说明是新插入的节点为链表的尾结点
    // 如果 index 大于链表的长度，则返回空
    public void addAtIndex(int index, int val) {
        if (index > size) {
            return;
        }
        if (index < 0) {
            index = 0;
        }
        size++;
        //找到要插入节点的前驱
        ListNode pred = head;
        for (int i = 0; i < index; i++) {
            pred = pred.next;
        }
        ListNode toAdd = new ListNode(val);
        toAdd.next = pred.next;
        pred.next = toAdd;
    }

    //删除第index个节点
    public void deleteAtIndex(int index) {
        if (index < 0 || index >= size) {
            return;
        }
        size--;
        //因为有虚拟头节点，所以不用对Index=0的情况进行特殊处理
        ListNode pred = head;
        for (int i = 0; i < index ; i++) {
            pred = pred.next;
        }
        pred.next = pred.next.next;
    }
}

//双链表
class ListNode{
    int val;
    ListNode next,prev;
    ListNode() {};
    ListNode(int val){
        this.val = val;
    }
}


class MyLinkedList {  

    //记录链表中元素的数量
    int size;
    //记录链表的虚拟头结点和尾结点
    ListNode head,tail;
    
    public MyLinkedList() {
        //初始化操作
        this.size = 0;
        this.head = new ListNode(0);
        this.tail = new ListNode(0);
        //这一步非常关键，否则在加入头结点的操作中会出现null.next的错误！！！
        head.next=tail;
        tail.prev=head;
    }
    
    public int get(int index) {
        //判断index是否有效
        if(index>=size){
            return -1;
        }
        ListNode cur = this.head;
        //判断是哪一边遍历时间更短
        if(index >= size / 2){
            //tail开始
            cur = tail;
            for(int i=0; i< size-index; i++){
                cur = cur.prev;
            }
        }else{
            for(int i=0; i<= index; i++){
                cur = cur.next; 
            }
        }
        return cur.val;
    }
    
    public void addAtHead(int val) {
        //等价于在第0个元素前添加
        addAtIndex(0,val);
    }
    
    public void addAtTail(int val) {
        //等价于在最后一个元素(null)前添加
        addAtIndex(size,val);
    }
    
    public void addAtIndex(int index, int val) {
        //index大于链表长度
        if(index>size){
            return;
        }

        size++;
        //找到前驱
        ListNode pre = this.head;
        for(int i=0; i<index; i++){
            pre = pre.next;
        }
        //新建结点
        ListNode newNode = new ListNode(val);
        newNode.next = pre.next;
        pre.next.prev = newNode;
        newNode.prev = pre;
        pre.next = newNode;
        
    }
    
    public void deleteAtIndex(int index) {
        //判断索引是否有效
        if(index>=size){
            return;
        }
        //删除操作
        size--;
        ListNode pre = this.head;
        for(int i=0; i<index; i++){
            pre = pre.next;
        }
        pre.next.next.prev = pre;
        pre.next = pre.next.next;
    }
}

LeetCode 206.反转链表

题目链接：206. 反转链表 - 力扣（LeetCode）

文章链接：代码随想录 (programmercarl.com)

本题收获：双指针法、递归

首先定义一个cur指针，指向头结点，再定义一个pre指针，初始化为null。

然后就要开始反转了，首先要把 cur->next 节点用tmp指针保存一下，也就是保存一下这个节点。

为什么要保存一下这个节点呢，因为接下来要改变 cur->next 的指向了，将cur->next 指向pre ，此时已经反转了第一个节点了。

接下来，就是循环走如下代码逻辑了，继续移动pre和cur指针。

最后，cur 指针已经指向了null，循环结束，链表也反转完毕了。此时我们return pre指针就可以了，pre指针就指向了新的头结点。

双指针法

实现原理

初始化指针：
- prev：指向当前节点的前一个节点，初始值为null，因为反转后的链表头节点的前一个节点是null。
- cur：指向当前节点，初始值为链表的头节点head。
- temp：用于临时存储当前节点的下一个节点，防止链表断裂。
遍历链表：使用while循环遍历链表，直到cur为null，即到达链表末尾。
反转指针：
- 在每次循环中，首先保存当前节点的下一个节点temp = cur.next。
- 然后将当前节点的next指针指向前一个节点cur.next = prev。
- 接着，将prev指针移动到当前节点prev = cur。
- 最后，将cur指针移动到下一个节点cur = temp。
返回反转后的链表头节点：当cur为null时，prev指向反转后的链表头节点，返回prev。

class Solution {
    // 反转链表
    public ListNode reverseList(ListNode head) {
        // 定义三个指针，prev指向当前节点的前一个节点，cur指向当前节点，temp指向当前节点的下一个节点
        ListNode prev = null;
        ListNode cur = head;
        ListNode temp = null;
        // 遍历链表，直到当前节点为空
        while (cur != null) {
            temp = cur.next;// 保存下一个节点
            // 保存下一个节点
            temp = cur.next;
            // 将当前节点的next指针指向前一个节点
            cur.next = prev;
            // 将prev指针指向当前节点
            prev = cur;
            // 将cur指针指向下一个节点
            cur = temp;
        }
        // 返回反转后的链表头节点
        return prev;
    }
}

递归

递归法相对抽象一些，但是其实和双指针法是一样的逻辑，同样是当cur为空的时候循环结束，不断将cur指向pre的过程。

关键是初始化的地方，可能有的同学会不理解，可以看到双指针法中初始化 cur = head，pre = NULL，在递归法中可以从如下代码看出初始化的逻辑也是一样的，只不过写法变了。

方法接收两个参数：prev和cur，分别表示当前节点的前一个节点和当前节点。
如果cur为null，说明已经到达链表的末尾，此时返回prev，即反转后的链表的头节点。
否则，先保存当前节点的下一个节点temp。
然后将当前节点的next指针指向prev，完成反转。
最后递归调用reverse方法，将当前节点cur作为新的prev，temp作为新的cur，继续反转链表。

// 递归 
class Solution {
    public ListNode reverseList(ListNode head) {
        return reverse(null, head);
    }

    private ListNode reverse(ListNode prev, ListNode cur) {
        if (cur == null) {
            return prev;
        }
        ListNode temp = null;
        temp = cur.next;// 先保存下一个节点
        cur.next = prev;// 反转
        // 更新prev、cur位置
        // prev = cur;
        // cur = temp;
        return reverse(cur, temp);
    }
}

// 从后向前递归
class Solution {
    ListNode reverseList(ListNode head) {
        // 边缘条件判断
        if(head == null) return null;
        if (head.next == null) return head;
        
        // 递归调用，翻转第二个节点开始往后的链表
        ListNode last = reverseList(head.next);
        // 翻转头节点与第二个节点的指向
        head.next.next = head;
        // 此时的 head 节点为尾节点，next 需要指向 NULL
        head.next = null;
        return last;
    } 
}