代码随想录Day2.1—链表基础

已于 2023-12-23 18:09:11 修改
阅读量46 收藏
点赞数
文章标签： 链表 算法 数据结构
于 2023-09-12 14:47:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52895914/article/details/132795369
版权

203. 移除链表元素

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

解题思路：通过设置虚拟头节点或者不设置的方式，都可以解决
/**
 * 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) {
        //首先创建一个哑节点dummy，或者叫虚拟头节点
        ListNode dummy=new ListNode(0);
        dummy.next=head;
        ListNode current=dummy;
        while(current.next!=null){
            if(current.next.val==val){
                current.next=current.next.next;
            }else{
                current=current.next;
            }
        }
        return dummy.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 removeElements(ListNode head, int val) {
        while(head!=null && head.val==val){
            head=head.next;
        }
        if(head==null){
            return head;
        }
        //已经确定当前head.val!=val，所有当前的head.val都!=val
        ListNode pre=head;
        ListNode cur=head.next;
        while(cur!=null){
            if(cur.val==val){
                pre.next=cur.next;
            }else{
                pre=cur;
            }
            
            cur=cur.next;

        }
        return head;
    }
}

707. 设计链表

你可以选择使用单链表或者双链表，设计并实现自己的链表。

单链表中的节点应该具备两个属性：val 和 next 。val 是当前节点的值，next 是指向下一个节点的指针/引用。

如果是双向链表，则还需要属性 prev 以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。

实现 MyLinkedList 类：

  • MyLinkedList() 初始化 MyLinkedList 对象。
  • int get(int index) 获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1 。
  • void addAtHead(int val) 将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。
  • void addAtTail(int val) 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
  • void addAtIndex(int index, int val) 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。如果 index 比长度更大，该节点将 不会插入 到链表中。
  • void deleteAtIndex(int index) 如果下标有效，则删除链表中下标为 index的节点。
解题思路：设置单链表还是双向链表，设置一个虚拟头节点后，index下标怎么计算，都是要考虑的问题
public class MyLinkedList {
    //单链表形式
    private Node head;
    private int size;

    public MyLinkedList() {
        this.head = new Node(0);  //设置一个虚拟头节点或者叫哑节点
        this.size = 0;
    }

    public int get(int index) {
        if (index < 0 || index >= size) {
            return -1;
        }

        Node current = head;
        for (int i = 0; i <= index; i++) {//设置虚拟头节点后，要取第index个节点的值，其下标是index+1（虚拟头节点也占一个节点位置）
            current = current.next;
        }

        return current.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 > size) {
            return;
        }
        Node current=head;
        for(int i=0;i<index;i++){//插入到第index个节点前的位置
            current=current.next;
        }
        Node newNode=new Node(val);
        newNode.next=current.next;
        current.next=newNode;
        size++;
    }

    public void deleteAtIndex(int index) {
        if (index < 0 || index >= size) {
            return;
        } 

        Node current = head;
        for (int i = 0; i < index; i++) {
            current = current.next;
        }
        current.next = current.next.next;

        size--;
    }

    private class Node {
        int val;
        Node next;

        Node(int val) {
            this.val = val;
        }
    }
}

public class MyLinkedList {
    //双链表形式
    private Node head;
    private Node tail;
    private int size;

    public MyLinkedList() {
        this.head = new Node(0);
        this.tail=new Node(0);
        this.size = 0;

        head.next=tail;
        tail.prev=head;
    }

    public int get(int index) {
        if (index < 0 || index >= size) {
            return -1;
        }

        Node current = this.head;
        //判断哪一边遍历时间更短
        if(index>=size/2){
            current=this.tail;
            for(int i=0;i<size-index;i++){
                current=current.prev;
            }
        }else{
            for (int i = 0; i <= index; i++) {
                current = current.next;
            }
        }
        return current.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 > size) {
            return;
        }
        Node current=head;
        for(int i=0;i<index;i++){
            current=current.next;
        }
        Node newNode=new Node(val);
        newNode.next=current.next;
        current.next.prev=newNode;
        newNode.prev=current;
        current.next=newNode;
        size++;
    }

    public void deleteAtIndex(int index) {
        if (index < 0 || index >= size) {
            return;
        } 

        Node current = head;
        for (int i = 0; i < index; i++) {
            current = current.next;
        }
        current.next.next.prev=current;
        current.next = current.next.next; //这一行和上一行的代码先后顺序不能改，改了会报错


        size--;
    }

    private class Node {
        int val;
        Node next,prev;

        Node(int val) {
            this.val = val;
        }
    }
}

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

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

//方式一：双指针prev和curr
class Solution {
    public ListNode reverseList(ListNode head) {
        //定义的是单链表
        ListNode prev=null,nextTemp==null;
        ListNode curr=head;
        while(curr != null){
            nextTemp=curr.next;
            curr.next=prev;
            prev=curr;
            curr=nextTemp;
        }
        return prev;
    }
}

//双指针方式二：递归—从前往后方向递归
class Solution {
    public ListNode reverseList(ListNode head) {
        //递归
        return reverse(null,head);
    }
    public ListNode reverse(ListNode prev, ListNode curr){
        if(curr==null) return prev;

        ListNode temp=curr.next;
        curr.next=prev;
        
        return reverse(curr,temp);
    }
}

//方式三：递归方式二
class Solution {
    public 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;
        return last;
    }
}

strider1111
关注
【代码随想录刷题】Day03 链表
qq_41994691的博客
09-07 44
链表是一种通过指针串联在一起的线性结构，每一个结点有两个部分组成，一个是数据域，一个是指针域（用来存放指向下一个结点的指针），最后一个结点的指针域指向null（空指针的意思）链表的入口结点称为链表的头结点，也就是headint val;//结点值//下一个结点//结点的构造函数（无参）//结点的构造函数（有一个参数）//结点的构造函数（两个参数）
代码随想录 day1
qq_40445763的博客
05-22 309
自己预习写二分法代码，写得有些凌乱，忘记了区间[ ], [ ）的区别， 导致写出来的[ ]中，right = mid， 忽略了nums[mid] > target时， mid索引的值一定不会等于target, 且right是闭区间， 所以，如果right = mid， 则mid出现重复计算的情况， 需要修正为right = mid - 1.但是 [left, right)情况下， left = right会导致集合区间不合法， 因为不存在一个数i， 使得i 包含在区间， 同时i又不包含在区间的情况。
代码随想录-八股刷题（随时更新）
weixin_48485132的博客
07-23 676
GET请求和POST请求的区别HTTP请求中常见的状态码什么是强缓存和协商缓存HTTP1.0和HTTP1.1的区别HTTP2.0与HTTP1.1的区别?Java的集合类有哪些，那些是线程安全的，那些是线程不安全的 ArrayList和Array有什么区别?ArrayList 和LinkedList的区别是什么?HashMap的底层实现是什么?如何查看某个端口有没有被占用 说- -下select、poll、 epoll 一条SQL查询语句 是如何执行的?Redis是单线程的还是多线程的，为什么?
代码随想录 | Day3(01) 移除链表中的元素（下） c语言
weixin_62566688的博客
04-13 116
};}else{3.2 细节总结1) 进行循环条件判断时，只需要判断下一个节点是否存在，并不需要判断当前节点是否存在，因为如果head为NULL，直接返回NULL后记：“成为那种不声不响，但什么都做的很好的人！” --406工位。
代码随想录刷题day3丨链表理论基础，203.移除链表元素，707.设计链表，206.反转链表
m0_75195038的博客
08-16 637
/ 结点的值int val;// 下一个结点// 节点的构造函数(无参)// 节点的构造函数(有一个参数)// 节点的构造函数(有两个参数)
代码随想录算法训练营day4
qq_56445436的博客
08-03 522
定义快慢指针，快指针每次走两步，慢指针每次走一步，通过数学证明可知当快慢指针相遇时在环上，此时从相遇点出发到环入口的距离等于从head出发到环入口的距离。末尾位置对齐，先让长链表的cur指针先走两条链表长度的差值，再同时走，若指针相同则返回。
代码随想录打卡—day4—【链表】—链表操作综合题
weixin_60899084的博客
03-20 723
链表操作综合题
代码随想录算法训练营day3
qq_56445436的博客
08-02 303
双指针法要牢牢掌握，要确定双指针的起始位置，双指针每次循环走几步，终止条件是什么。
【代码随想录刷题】Day08 字符串
qq_41994691的博客
11-03 131
现需将路径加密，加密方法为将 path 中的分隔符替换为空格 " "，请返回加密后的字符串。使用一个新的对象，复制str，复制的过程对其判断，是分隔符.则替换为空格" "，否则直接复制，类似于数组复制。s 中使用至少一个空格将字符串中的 单词 分隔开。解释：如果两个单词间有多余的空格，反转后的字符串需要将单词间的空格减少到仅有一个。输入：s = [“H”,“a”,“n”,“n”,“a”,“h”]输入：s = [“h”,“e”,“l”,“l”,“o”]输出：[“h”,“a”,“n”,“n”,“a”,“H”]
《代码随想录》链表算法详解及实现
09-17
此外，《代码随想录》系列文章进一步剖析了具体的LeetCode题目，包括链表常见操作（删除指定元素、设计自定义链表）、链表的反转方法、两两交换链表节点以及删除倒数第N个节点等问题，并提供了详细的解题思路和技术...
代码随想录的pdf版本，需要准备秋招的小伙伴们看过来呀！
02-28
通过学习《代码随想录》，你可以系统地了解和掌握这些基础知识，为面试和工作中的问题解决做好准备。 书中可能包含以下核心知识点： 1. **基础数据结构**：数组、链表、栈、队列、哈希表、二叉树等。理解这些数据...
代码随想录算法PDF.rar
08-06
《代码随想录》是一本深受程序员喜爱的算法学习书籍，尤其对于初学者来说，它提供了深入浅出的讲解和实战演练。这本书的核心是通过实际编程来帮助读者理解和掌握算法，提升编程技能，特别是C++语言的应用。在C++这个...
《代码随想录》双指针算法及其应用详解
09-17
本文围绕程序员Carl撰写的《代码随想录》，全面系统地阐述了一系列重要的利用双指针算法解决编程问题的方法，并深入解析了其背后的逻辑与实现细节。涵盖典型题目包括：27号题目移除元素，力扣上排名第15和第18的三数...
100种算法【Python版】第36篇——Graham Scan算法
AnFany
11-02 262
100种算法【Python版】第36篇——Graham Scan算法
算法基础-链表
August的专栏
11-05 191
当链表的长度为偶数时，head找到的中点是靠后的，因为fast相对slow移动只快了1步，而head.next找到的中点是靠前的，因为fast相对slow移动快了2步。这2种方式寻找链表的结点主要区别是 当链表的长度为奇偶数时，找到链表中点的位置一个靠后，一个靠前。使用快慢指针寻找链表的中点有2种方式，分别是fast=head;当链表为奇数时 [1->2->3->4->5]当链表长度为奇数时，找到的中点2种方式是一样的。当链表为偶数时 [1->2->3->4]
100种算法【Python版】第51篇——希尔排序
最新发布
AnFany
11-06 152
100种算法【Python版】第51篇——希尔排序
深⼊理解指针2
ElePower9527的博客
11-01 675
指针访问数组内容时，有如下代码这⾥我们使⽤ &arr[0] 的⽅式拿到了数组第⼀个元素的地址，但是其实数组名本来就是地址，⽽且 是数组⾸元素的地址，我们来做个测试。输出结果我们发现数组名和数组⾸元素的地址打印出的结果⼀模⼀样，数组名就是数组⾸元素(第⼀个元素)的地址。注意有两个例外• sizeof(数组名)，sizeof中单独放数组名，这⾥的数组名表⽰整个数组，计算的是整个数组的⼤⼩， 单位是字节。
CSP/信奥赛C++刷题训练：经典深搜例题（1）：洛谷1605 ：迷宫
weixin_66461496的博客
11-02 1021
CSP/信奥赛C++刷题训练：经典深搜例题（1）：洛谷1605 ：迷宫
字符串-06-整数与ip地址之间的转换
qq_45480682的博客
11-04 291
华为od算法——HJ33
代码随想录的python版本
07-27
抱歉，我无法理解你的问题。你可以提供更多的上下文或者明确你的问题吗？谢谢！ #### 引用[.reference_title] - *1* [leetcode 刷题记录，链表部分，代码随想录刷题顺序（python实现）](https://blog.csdn.net/yyy199869/article/details/121777716)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值