【Leecode】代码随想录链表篇day3(链表增删改查&反转）

已于 2024-07-06 12:22:46 修改
阅读量901 收藏 28
点赞数 12
分类专栏： 算法（非职业） 文章标签： 链表 数据结构 算法
于 2024-07-05 18:35:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52014623/article/details/140200174
版权

链表节点定义

单链表

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

双链表

public class DListNode{
    int val;
    DListNode pre;
    DListNode next;
    DListNode() {};
    DListNode(int val, DListNode pre, DListNode next){this.val = val; this.pre = pre;this.next = next;}
}

链表增删改查

  • 题目链接：单双链表的增删改查
  • 我的解法：一开始，通过52/65用例，暂时用输入输出法找不到问题所在，感觉时index和下标的关系出问题，具体应该是get函数和addAtIndex两个函数有问题，绷不住了。。。
public class ListNode{
    int val;
    ListNode next;
    ListNode() {};
    ListNode(int val, ListNode next) {this.val = val; this.next = next;}
}
class MyLinkedList {
    int size;//便于判断index是否合理
    ListNode head;//虚拟头节点
    public MyLinkedList() {
        this.size = 0;
        this.head = new ListNode(-1, null);
    }
    
    public int get(int index) {
        System.out.print("get");
        if(index < 0 || index > size) return -1;
        ListNode p = head.next;
        while((p != null) && (index > 0)){p = p.next;index--;}
        if(p == null) return -1;
        return p.val;
    }
    
    public void addAtHead(int val) {
        System.out.print("addAtHead");
        ListNode newNode = new ListNode(val, null);
        newNode.next = head.next;
        head.next = newNode;
        size++;
        // System.out.print("addAtHead");
        // ListNode tmp = head.next;
        // while(tmp != null)
        // {
        //     System.out.print(tmp.val);
        //     System.out.print(" ");
        //     tmp = tmp.next;
        // }
    }
    
    public void addAtTail(int val) {
        System.out.print("addAtTail");
        ListNode newNode = new ListNode(val, null);
        ListNode p = head;
        while(p.next != null){p = p.next;}
        p.next = newNode;
        size++;
        // System.out.print("addAtTail");
        // ListNode tmp = head.next;
        // while(tmp != null)
        // {
        //     System.out.print(tmp.val);
        //     System.out.print(" ");
        //     tmp = tmp.next;
        // }
    }
    
    public void addAtIndex(int index, int val) {
        System.out.print("addAtIndex");
        if(index < 0 || index > size) return;
        ListNode newNode = new ListNode(val, null);
        ListNode p = head.next;
        ListNode pre = head;
        while((p != null) && (index > 0)){pre = pre.next; p = p.next;index--;}
        newNode.next = pre.next;
        pre.next = newNode;
        size++;
        // System.out.print("addAtIndex");
        // ListNode tmp = head.next;
        // while(tmp != null)
        // {
        //     System.out.print(tmp.val);
        //     System.out.print(" ");
        //     tmp = tmp.next;
        // }
    }
    
    public void deleteAtIndex(int index) {
        System.out.print("deleteAtIndex");
        if(index < 0 || index > size) return;
        ListNode pre = head;ListNode p = head.next;
        while((p != null) && (index > 0)){pre = pre.next; p = p.next; index--;}
        if(p != null)pre.next = p.next;
        else pre.next = null;
        size--;
        // System.out.print("deleteAtIndex");
        // ListNode tmp = head.next;
        // while(tmp != null)
        // {
        //     System.out.print(tmp.val);
        //     System.out.print(" ");
        //     tmp = tmp.next;
        // }
    }
}

后来发现就是index从零开始但是size从1开始问题，这个需要在涉及index的函数中注意，其次就是addAtIndex的定义本身很不一样，size==index时直接插就行了,贴一下正确自己的解法，虽然很慢

public class ListNode{
    int val;
    ListNode next;
    ListNode() {};
    ListNode(int val, ListNode next) {this.val = val; this.next = next;}
}
class MyLinkedList {
    int size;//便于判断index是否合理
    ListNode head;//虚拟头节点
    public MyLinkedList() {
        this.size = 0;
        this.head = new ListNode(-1, null);
    }
    
    public int get(int index) {
        if(index < 0 || index >= size) return -1;
        ListNode p = head.next;
        while(index > 0){p = p.next;index--;}
        return p.val;
    }
    
    public void addAtHead(int val) {
        ListNode newNode = new ListNode(val, null);
        newNode.next = head.next;
        head.next = newNode;
        size++;
    }
    
    public void addAtTail(int val) {
        ListNode newNode = new ListNode(val, null);
        ListNode p = head;
        while(p.next != null){p = p.next;}
        p.next = newNode;
        size++;
    }
    
    public void addAtIndex(int index, int val) {
        if(index < 0 || index > size) return;
        ListNode newNode = new ListNode(val, null);
        if(index == size) {addAtTail(val);return;}
        ListNode p = head.next;
        ListNode pre = head;
        while(index > 0){pre = pre.next; p = p.next;index--;}
        newNode.next = pre.next;
        pre.next = newNode;
        size++;
    }
    
    public void deleteAtIndex(int index) {
        if(index < 0 || index >= size) return;
        ListNode pre = head;ListNode p = head.next;
        while(index > 0){pre = pre.next; p = p.next; index--;}
        pre.next = p.next;
        size--;
    }
}

上面addAtHead和addAtTail都可以在内部调用addAtIndex实现，分别为前者addAtIndex(0,val)，后者addAtTail(size, val),同时增加size记录链表长度便于判定index是否合法，这样可以在代码中不判空

  • 双链表版本
public class DListNode{
    int val;
    DListNode pre;
    DListNode next;
    DListNode() {};
    DListNode(int val, DListNode pre, DListNode next){this.val = val; this.pre = pre;this.next = next;}
}
class MyLinkedList {
    int size;//便于判断index是否合理
    DListNode head;//虚拟头节点
    DListNode tail;
    public MyLinkedList() {
        this.size = 0;
        this.head = new DListNode(-1, null, null);
        this.tail = new DListNode(-1, null, null);
        //双向链表互指
        head.next = tail;
        tail.pre = head;
    }
    
    public int get(int index) {
        if(index < 0 || index >= size) return -1;
        DListNode p = head.next;
        if(index >= size/2){//比较巧，那边短从那边开始
            p = tail.pre;
            index = size-index-1;
            while(index > 0){p = p.pre;index--;}
        }
        else{
            while(index > 0){p = p.next;index--;}
        }
        return p.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 < 0 || index > size) return;
        size++;
        DListNode newNode = new DListNode(val, null, null);
        if(index == size) {
            newNode.pre = tail.pre;
            tail.pre = newNode;
            newNode.next = tail;
            newNode.pre.next = newNode;
            return;}
        DListNode p = head.next;
        while(index > 0){p = p.next;index--;}
        p.pre.next = newNode;
        newNode.pre = p.pre;
        newNode.next = p;
        p.pre = newNode;
    }
    
    public void deleteAtIndex(int index) {
        if(index < 0 || index >= size) return;
        DListNode p = head.next;
        while(index > 0) {p = p.next; index--;}
        p.pre.next = p.next;
        p.next.pre = p.pre;
        size--;
    }
}
  • 复杂度：时空复杂度均为 O ( O( O(调用类中函数次数之和 ) ) )

删除元素

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        if(head == null){return null;}
        ListNode h = new ListNode(0, head);
        ListNode pre = h;ListNode p = head;
        while(p != null)
        {
            if(p.val != val)
            {
                p = p.next;
                pre = pre.next;
            }
            else
            {
                pre.next = p.next;
                p = pre.next;
            }
        }
        return h.next;
    }
}

总结：不同于之前一直使用c++解题，java的指针概念是通过结构体模拟

  • 其他解法：不引入虚拟节点，head直接作为头节点
class Solution {
    public ListNode removeElements(ListNode head, int val) {
        while(head != null && head.val == val) head = head.next;
        if(head == null) return null;
        ListNode pre = head; ListNode p = head.next;
        while(p != null)
        {
            while(p != null && p.val != val) {p = p.next;pre = pre.next;}
            if(p!=null){pre.next = p.next;p = pre.next;}
        }
        return head;
    }
}

比起创建虚拟节点不带头结点的链表执行删除操作更快
删除操作的标配是pre指向前节点，p指向当前节点，要注意当前节点可能为空指针的判断。

  • 复杂度：时间复杂度 O ( n ) O(n) O(n)，空间复杂度 O ( 1 ) O(1) O(1)

反转链表

  • 题目链接：反转单链表
  • 我的解法：引入虚拟头节点+头插法
class Solution {
    public ListNode reverseList(ListNode head) {
        if(head == null || head.next == null) return head;
        ListNode h = new ListNode(-1, head);
        ListNode pre = head.next;
        ListNode p = pre.next;
        head.next = null;//头插法一定要记得将最末端置空
        while(pre != null)
        {
            pre.next = h.next;
            h.next = pre;
            pre = p;
            if(pre != null) p = pre.next;
        }
        return h.next;
    }
}

整体比较熟悉，记住在断开链表进行头插前要将断开点节点next指向null,不然会成环。

  • 复杂度：时间复杂度 O ( n ) O(n) O(n)，空间复杂度 O ( 1 ) O(1) O(1)
流年顾盼纯香消
关注
  • 12
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++实现链表增删改查
07-17
c++实现链表增删改查
Java描述数据结构学习之链表的增删改查详解
08-27
本文将从链表的基本概念、链表的定义、链表的增删改查操作等方面对Java描述数据结构学习之链表的增删改查进行详细的解释。 链表是一种常见的基础数据结构，它是一种线性表，但在内存中它并不是顺序存储的，而是以...
代码随想录 | Day05 | 链表：移除链表元素&&设计链表&&反转链表
m0_74795952的博客
05-22 795
用tmp=cur->next来更新tmp，使得cur和tmp产生关联，和循环条件统一起来，当tmp=NULL时，不会因为使用tmp->next而报错。addAtIndex函数的if条件里面是要index>size而不是index>=size，因为=的时候是要插入到末尾。2.没有了虚拟头结点，我们就不知道第一个到底是不是为空，则需要在两个while（）处加入head不为空的判断条件。1.头结点是val头结点连着的下面几个可能也是val，所以要用while而不是if来处理头结点。最后返回的就是pre。
day9【代码随想录】反转链表
qq_42338744的博客
11-28 140
反转链表 回文链表
代码随想录刷题day3 | Leecode 203.移除链表元素 707.设计链表 206.反转链表
weixin_40323978的博客
10-14 330
代码随想录刷题day3
Day8 代码随想录打卡|链表篇---反转链表
m0_48909584的博客
04-21 316
双指针法，分析题目我们发现，其实只需要改变每个节点指针的方向，将每个指向下一个位置的节点指向前一个即可完成题目。首先定义一个cur指针指向head的位置，定义一temp指向用来向后遍历，保存cur指针下一个要去的位置（因为cur指针要改变指针方向，所以需要一个指针用来帮他指向原来的路），定义一个pre指针，刚开始pre指针指向空值。随后执行cur的循环，先用temp保存位置，断开cur的指针指向pre， pre=cur，cur=temp。但是还是要学习一下这种思想，毕竟有的题确实使用递归的方式会更简单。
线性表和链表的存储和增删改查c++
01-28
线性表的增删改查操作 - **插入**：在线性表的指定位置插入一个新元素，需要找到插入点并更新指针。对于链表，这涉及修改前后两个节点的指针。 - **删除**：根据给定的元素或位置删除一个元素，需要找到要删除的...
用c语言实现链表增删改查
11-07
自己写的，能够使用，对c语言的指针用的淋漓精致，有需要的小伙伴可以下载看下
C语言单双向链表的增删改查以及排序问题完整代码
09-04
本主题聚焦于C语言实现的单双向链表，包括链表的基本操作：增、删、改、查和排序。以下是这些核心知识点的详细说明。 首先，链表是一种动态数据结构，它不像数组那样在内存中连续存储元素，而是通过节点间的指针...
数据结构第32节 无锁编程
hummhumm的专栏
07-17 835
在Java中，无锁编程是一种在多线程环境下避免使用传统锁机制（如关键字或）的技术。这种技术可以提高程序的并发性能，尤其是在高并发场景下，因为它减少了锁的竞争和上下文切换的开销。
【Java--数据结构】二叉树
2301_80898480的博客
07-16 1055
如有错误，欢迎指出~
常见排序算法总结
mydaily_的博客
07-16 825
大概是因为插入排序没预处理，极端情况可能让一个很小很右的数一直比比比比比，比到最开头，浪费比较次数。某种情况比计数排序好，因为数字，如果按照普通十进制理解，则只需准备10个不同数字的桶就好了！整体的quickSort函数swap后，再进行partition，划分三部分后，所以这种不基于比较的算法应用范围很局限，大部分情况下，不如之前的所有比较算法！前提得知道空间范围，比如人的年龄，正数[0-200]，否则内存爆炸！间隔分组，且分组间隔依次减半，每次分组后，每个组内排序都是插入排序。
【数据结构】栈和队列
奋斗的小羊的博客
07-12 1887
栈超超超详解
数据结构——栈
最新发布
weixin_45942515的博客
07-19 205
1、栈的英文为stack2、栈是先入后出（FILO-First In Last Out）的有序列表。3、栈stack是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶 (Top)，另一端固定的一端，称为栈底(Bottom)。4、根据栈的定义可知，最先放入栈中的元素在栈底，最后放入栈中的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除。
数据结构(5.1)——树的性质
m0_65240792的博客
07-16 231
1%29%5D。
数据结构(4.4)——求next数组
m0_65240792的博客
07-14 376
next[1]都无脑写0next[2]都无脑写1其他next:在不匹配的位置前边，划一条分界线，模式串一步一步往后退，直到分界线之前"能对上"，或模式串能完全跨过分界线为止，此时j指向哪儿，next数组值就是多少ababaa的next数组//求next[1]??????->??????/i=1->i=2ababaa-> ababaa //j=0,第一个字符匹配失败，只能匹配下一个子串，++i，++jnext[1]=0;//求next[2]a?????->a??????//i=2。
数据结构初阶（C语言）-顺序表
xiuwoaiailixiya的博客
07-15 1044
在进行顺序表的介绍之前，我们先来了解下什么是线性表：线性表是n个具有相同特性的数据元素的有限序列。线性表是⼀种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串...线性表在逻辑上是线性结构，也就说是连续的⼀条直线。但是在物理结构上并不⼀定是连续的， 线性表在物理上存储时，通常以数组和链式结构的形式存储。
《数据结构：C语言实现双链表》
2401_83305953的博客
07-19 147
带头链表中的头结点，实际为“哨兵位”，哨兵位结点补存储任何有效元素，只是站在这里“放哨的”虽然有这么多的链表的结构，但我们实际中最常用的还是两种结构：单链表和双向带头循环链表.
链表的增删改查代码示范
04-29
下面是链表的增删改查的代码示范： 1. 链表的创建和添加节点[^1]： ```python class Node: def __init__(self, data=None): self.data = data self.next = None class LinkedList: def __init__(self): self....

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值