代码随想录第三天: 链表(虚拟头节点+基本操作实现)

最新推荐文章于 2024-05-07 20:03:10 发布
最新推荐文章于 2024-05-07 20:03:10 发布
阅读量745 收藏 6
点赞数 18
分类专栏： 代码随想录 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sevune/article/details/136938789
版权

语言: Java

参考资料: 代码随想录

链表的定义

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;
    }
}

203.移除链表元素

力扣题目链接(opens new window)

题意：删除链表中等于给定值 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 输出：[]

如果使用java ，python的话就不用手动管理内存了。

设置一个虚拟头结点在进行移除节点操作：

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode dummyHead = new ListNode(0); // 设置一个虚拟头结点
        dummyHead.next = head; // 将虚拟头结点指向head，这样方便后面做删除操作
        ListNode cur = dummyHead;
        while (cur.next != null) {
            if (cur.next.val == val) {
                cur.next = cur.next.next;
            } else {
                cur = cur.next;
            }
        }
        return dummyHead.next;
    }
}

707.设计链表

力扣题目链接(opens new window)

题意：

在链表类中实现这些功能：

  • get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
  • addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
  • addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
  • addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
  • deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

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

  • 获取链表第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;
    }

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

    //在链表的最后插入一个节点，等价于在(末尾+1)个元素前添加
    public void addAtTail(int val) {
        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--;
        if (index == 0) {
            head = head.next;
	    return;
        }
        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<0 || 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;
        }
        //index小于0
        if(index<0){
            index = 0;
        }
        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<0 || 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;
    }
}

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

力扣题目链接(opens new window)

题意：反转一个单链表。

示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL

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

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

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

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

最后，cur 指针已经指向了null，循环结束，链表也反转完毕了。 此时我们return pre指针就可以了，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 {
    public ListNode reverseList(ListNode head) {
        ListNode cur = head;
        ListNode pre = null;
        ListNode tmp = null;
        while (cur != null) {
            tmp = cur.next;
            cur.next = pre;
            pre = cur;
            cur = tmp;
        }
        return pre;
    }
}

递归法

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

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

具体可以看代码（已经详细注释），双指针法写出来之后，理解如下递归写法就不难了，代码逻辑都是一样的。

/**
 * 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 reverse(ListNode cur, ListNode pre) {
        if (cur == null)
            return pre;
        ListNode tmp = cur.next;
        cur.next = pre;
        // 可以和双指针法的代码进行对比，如下递归的写法，其实就是做了这两步
        // pre = cur;
        // cur = temp;
        return reverse(tmp, cur);
    }

    public ListNode reverseList(ListNode head) {
		// 和双指针法初始化是一样的逻辑
        // ListNode* cur = head;
        // ListNode* pre = NULL;
        return reverse(head, null);
    }
}
sevune
关注
  • 18
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
linkedList_DSA:链表与C ++
03-27
linkedList_DSA 链表与C ++
js代码-第一题：寻找链表的头节点
07-16
js代码-第一题：寻找链表的头节点
代码随想录第四天：链表2
qq_39878231的博客
10-30 84
链表2
《代码随想录》学习笔记：链表合集
weixin_43216182的博客
10-20 132
一刷[代码随想录](https://programmercarl.com/)，今天的内容是 **链表**。所有题目均源自LeetCode。
代码随想录day3：链表+移除元素+设计链表+翻转链表
zhy2267291213的博客
01-30 200
int val;
代码随想录day4：交换链表节点+删除链表节点+链表相交+环形链表
zhy2267291213的博客
01-31 350
跟之前数组的题目类似，相邻的两两交换，但是此时要求对节点进行交换，而不是节点内部的数值。这样的操作使得头节点是非固定的，所以可以使用虚拟头节点。实际操作如下：每次操作完成后，cur往下移动两位。终止条件：下一个节点为空（链表节点个数为偶数）&&下下个节点为空（链表节点个数为奇数）
代码随想录Day4：两两交换节点+删除倒数第N个节点+链表相交+环形链表II
m0_56809046的博客
01-17 1092
通过遍历链表，如果当前节点已经在visited集合中出现过，则说明链表存在环，返回当前节点即为环的起始节点，否则将当前节点加入visited集合。：令curA指向长链表第len(A)-len(B)+1个节点，令curB指向短链表第1个节点，比较curA和curB是否相同，如果不相同，同时向后移动curA和curB，如果遇到curA == curB，则找到交点。然后fast和slow同时移动，直到fast指向末尾，此时slow指向的是倒数第n+1个节点，即倒数第n个节点的上一节点。给定一个链表的头节点。
【C语言视角】数据结构之~二叉树
循环渐进学习编程，成长
05-01 1188
设二叉树的根节点所在层数为1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问第2层上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。第一层是根结点，只有一个，所以2(1-1）=20=1。终端结点数其实就是叶子结点数，而一棵二叉树，除了叶子结点外，剩下的就是度为1或2的结点数了，我们设n1为度是1的结点数。终端结点数其实就是叶子结点数，而一棵二叉树，除了叶子结点外，剩下的就是度为1或2的结点数了，我们设n1为度是1的结点数。
redis核心数据结构——跳表项目设计与实现（跳表结构插入数据、删除数据、展示数据）
qq_63149342的博客
05-01 519
另外就是每次创建新节点时需要随机分配层数，加上一开始用两个变量分别记录最大层数和当前层数，分配后该层数不能超过最大层数，且如果大于当前层数，需要将当前层数进行更新。向跳表中插入一对数据，如果跳表中已存在该键值对，则不做任何操作，返回 1，如果不存在该键值对，则将该键值对插入到跳表中，返回 0。此成员函数需要从跳表中删除键为 key 的节点。在跳表中查询键值为 key 的键值对，如果跳表中已存在该键值对，则返回 true，否则返回 false。参数说明： K key：要删除的元素的键，其中 K 是键的类型。
【数据结构】链表专题2
m0_74091744的博客
05-01 1300
前言本篇博客继续探讨有关链表的专题，这片博客的题，提前打个预防针，有点意思哦，哈哈哈，话不多说，进入正文若有问题 评论区见📝。
[数据结构]————排序总结——插入排序（直接排序和希尔排序）—选择排序（选择排序和堆排序）-交换排序（冒泡排序和快速排序）—归并排序（归并排序）
小李很执着的博客
05-04 955
直接插入排序是一种简单观的排序算法，它基本思想是将待排序的元逐个插入到已经排好序的序列中，直到所有元素都插入完成为止下面是对直接插入排序的析总结：最好情况下待排序序列已经是有序的此时只需要比较n-1次，时间复杂度为O（n）。最坏情况下，待排序序列是逆序的，此时需要比较和移动元素的次数最多，时间复杂度为O(n^2)。平均情况下，假设待排序序列中的每个元素都等概率地出现在任何位置，那么平时间复杂度为O(n^2)。
数据结构-线性表-应用题-2.2-5
muse3159546973的博客
05-07 96
从顺序表中删除其值在给定值s与t之间（包括s和t，且s
数据结构中的算法
zy1215058242的博客
05-01 1024
什么是算法呢？算法是描述解决问题的方法。算法(Algorithm)这个单词最早出现在波斯数学家阿勒·花刺子密在公园825年(相当于我们中国的唐朝时期)所写的《印度数字算数》中。如今普遍认可的对算法的定义是：算法是解决特定问题求解步骤的描述，在计算机中表现为指令的有限序列，并且每条指令表示一个或多个操作。现实世界中的问题千奇百怪，算法当然也就千变万化，没有通用的算法可以解决所有问题。甚至解决一个小问题，很优秀的算法却不一定适合它。指令能被人或机器等计算装置执行。
数据结构-线性表-应用题-2.2-4
muse3159546973的博客
05-07 311
这个区间的起始位置是 i，这是因为 i 是在 [s, t] 范围内找到的第一个元素的位置，即从这里开始的元素需要被删除或覆盖。通过设置新的顺序表长度为 i 的值（即移动完成后的最后一个元素的索引加一），我们有效地切除了数组尾部的多余部分，这部分现在包含了重复的、不再需要的数据。从有序顺序表中删除其值在给定值s与t之间（要求s
acwing算法提高之数据结构--平衡树Treap
YMWM_的博客
05-01 371
acwing算法提高之数据结构--平衡树Treap
【数据结构和算法】--RangeSet时间范围管理示例
寻梦友的博客
05-05 332
ImmutableRangeSet是一个不可修改的RangeSet，而TreeRangeSet则是利用树的形式来实现，提供了高效的查询和插入操作。这种自动合并的特性使得RangeSet能够保持范围的不重叠性，从而简化了范围集合的管理。当向RangeSet中添加一个新的范围时，它会遍历范围树，找到与新范围相交或相邻的现有范围，并进行合并。例如，当查询一个元素是否包含在RangeSet中时，可以从树的根节点开始，沿着适当的分支向下遍历，直到找到一个包含该元素的范围或确定该元素不在RangeSet中。
数据结构-线性表-应用题-2.2-12
最新发布
muse3159546973的博客
05-07 176
1）算法的基本设计思想：依次扫描数组的每一个元素，将第一个遇到的整数num保存到c中，count记为1，若遇到的下一个整数还是等于num,count++,否则count--,当计数减到0时，将遇到的下一个整数保存到c中，计数重新记为1，反复该过程，直到扫描全部数组元素为止。获得最终的候选主元素，但此时还没完成，出现次数还要过半才行，判断c中元素是否是真正的主元素，再次扫描该数组统计c中元素出现的次数，再进一步进行判断。3）时间复杂度O(n),空间复杂度O（1）
本关任务:编写程序实现节点类 node,实现链表的基本操作
09-20
链表包含一个头节点，头节点是第一个节点，用于指向链表中的第二个节点。链表的插入操作可以在任意位置插入一个节点，我们需要实现一个方法，接收一个参数表示要插入的节点的数据值，并将其插入到链表的指定位置处。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值