代码随想录

最新推荐文章于 2024-09-12 19:02:20 发布
最新推荐文章于 2024-09-12 19:02:20 发布
阅读量83 收藏
点赞数
分类专栏： 算法 文章标签： 算法 数据结构 leetcode 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JiFree/article/details/131724811
版权

代码随想录第三天

代码随想录算法训练营第三天 | LeetCode 203.移除链表元素 |LeetCode 707.设计链表 |LeetCode 206.反转链表 | 双指针法 | 递归法

前言

今天的内容非常的丰富，可以认真的品味

一、 LeetCode 203.移除链表元素

题目解析：法一：直接让该节点的前一个节点直接指向该节点的下一个节点。但是如何移除头节点呢？只需要head = head.next;换一个头节点罢了。另一种方法为虚拟头节点的方法，那么就可以都按照方法一的规则去删除了。（虚拟头节点的方法由此诞生）

首先判断头节点一定不是空，同时头节点指向的数值等于target的值，后head = head.next.//我的理解：更改head的value。更改head的指针域

重要思路：我们要删除一个元素，那么我们一定要知道这个元素的上一个元素。通过上一个元素完成删除操作，我们自己设计的一个节点cur，我们只能删除cur.next，因此，我们在让cur移动时必须要让cur停留在要删除的节点的上一个位置，用到的方法就是cur.next的判断。这里有另外一种思路。直接通过一个pre前节点来记住cur前面的那个节点的话，那我们就可以直接去判断cur的性质了。

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 {
    public ListNode removeElements(ListNode head, int val) {
        if (head == null) {
        return head;
    }
    // 因为删除可能涉及到头节点，所以设置dummy节点，统一操作,这三行代码很固定
    ListNode dummy = new ListNode(-1, head);
    ListNode pre = dummy;
    ListNode cur = head;
    //接下来开始往下遍历，这里用到的就是另外一种思路，采用pre来记录。
    while (cur != null) {
    //pre怎么移动取决于要不要删除
        if (cur.val == val) {
            pre.next = cur.next;
        } else {
            pre = cur;
        }
        //一定要往后移动
        cur = cur.next;
    }
    return dummy.next;
    }
}

C++代码如下：

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 就要走了，我们必须要删除掉它，所以要提前记录下来。
                ListNode* tmp = cur->next;
                cur->next = cur->next->next;
                delete tmp;
            } else {
                cur = cur->next;
            }
        }
        head = dummyHead->next;
        delete dummyHead;
        return head;
    }
};

二、LeetCode 707.设计链表

题目解析：本题目让我们实现链表有关的五个函数。都是链表的常用基本操作，反复练习本题目，方可熟练掌握链表的知识。
注意本题目的n从0开始，并且自己选择用虚拟头节点的方法来做。因此函数一：获取第n个节点的数值（n从零开始）：首先定义一个用来遍历的指针cur，（他只是临时指针，为的是不改变链表本身的值）。cur = dummyhead.next。while(check(n)){cur = cur.next; n–;}
二：头部插入节点 ：最某一个节点后方插入一个节点，我们仍然需要用到该节点指向下一个节点的操作，因此cur仍然要指向这个节点本身。我们另该节点是A，需要插入B，以下是操作：1.B.next = A.next 2.A.next = B
因此头部插入节点是 newnode.next = dummy.next; dummy.next = newnode
在尾部插入一个节点：首先我们需要找到尾部的位置，cur.next = null来判断。之后newnode.next = null; cur.next = newnode.
第n个节点前插入节点：其实我也是第n-1个节点后插入节点。（我们只从前一个节点知道后面一个节点）cur指向n-1.则newnode.next = cur.next。cur.next = newnode
删除第n个节点：判断n的合法性，删除第n个节点，则需要用到第n-1个节点作为工具。所以cur指向n-1；（保证cur.next = n可以处理好边界条件）cur.next = cur.next.next.

JAVA代码

//单链表
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);
 */

三、LeetCode 206.反转链表 | 双指针法 | 递归法

题目解析：将头尾的顺序完全反过来。 双指针法：初始化cur = head; pre = NUILL，初始化的一个目的是为了让head能够指向他的前一位。;思考，我们遍历的操作什么时候结束，当cur到最结尾的Null的时候，就可以结束了。在遍历的过程中，我们不断的将cur的节点指向一个新的位置，但是他又在它的下一个节点之前，他仍然需要往下走，因此他需要一个temp节点来暂时记录他的下一个节点（cur.next）temp = cur.next;cur.next = pre;pre = cur;cur = temp;必须要有一步是cur.next = pre才可以实现转向操作，那pre应该何去何从，而且cur即使真的变成从左边转向右边的pre，但是它还有着遍历整个链表的职责，因此就需要一个辅助节点来帮助我们实现记录cur应该有的位置，且他必须提前记录好，这个相当于准备工作就绪了，我们才能开始接下来的反转操作因为要让现在的cur的值赋值给pre，所以cur的值暂时不可以改变，需要让cur先移动，然后在让pre移动到cur.总体的过程就是让箭头一个一个的反转。
递归法：反转链表用的函数reverse（cur ,pre）{if(cur = null) return pre temp = cur.next;cur.next = pre}

JAVA代码如下

// 双指针
class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode prev = null;//
        ListNode cur = head;
        ListNode temp = null;
        while (cur != null) {
            temp = cur.next;// 保存下一个节点，为了能够让cur的指的方向改变后还可以接着按着原来的方向移动。
            cur.next = prev;
            prev = cur;
            cur = temp;
        }
        return prev;
    }
}


// 递归 
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);
    }
}

总结

`这一次刷题的任务还是蛮多的，花费了较长的时间，其中第二道题目非常的基础实用，更需要注意自己的写题。接下来就好好消化一下吧。加油。

JiFree
关注
专栏目录
代码随想录-力扣刷题-总结笔记01
upward
02-27 1107
代码随想录-力扣刷题-总结笔记01
代码随想录-八股文 pdf
04-25
代码随想录-八股文 PDF 代码随想录-八股文 PDF 是一个涵盖了程序员学习必备的内容的知识星球精华，总结了包括 C++、Java、Go 在内的多种编程语言，数据结构和算法、操作系统、数据库、计算机网络、设计模式、Linux ...
代码随想录——回溯
weixin_48956191的博客
01-14 1300
代码随想录——回溯
代码随想录刷题汇总
不思考会变草履虫哦
08-11 1383
网站：https://www.programmercarl.com/
代码随想录刷题笔记
Twoton的博客
07-12 633
代码随想录对应题目链接 数组是有序数组，是使用二分查找的基础条件。 以后大家只要看到面试题里给出的数组是有序数组，都可以想一想是否可以使用二分法。或者说可以转换在一个有序数组中找一个数的题目。 同时题目还强调数组中无重复元素，因为一旦有重复元素，使用二分查找法返回的元素下标可能不是唯一的。代码随想录对应题目链接 双指针法（快慢指针法）： 通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。 对于使用双指针的题目，需要明确双指针的含义，针对其含义去思考题解方式。 双指针法（快慢指针法）在数组和链
代码随想录-力扣刷题笔记
m0_49651195的博客
03-12 2128
数组是存放在连续内存空间上的相同数据类型的集合。要查找数组里的数据一般通过查找数据的下标索引的方式来查找。由于数组的这个特性，所以数组删除或添加元素的时候，不能直接进行删除操作。在增加或删除元素的时候，需要通过移动其他元素的地址来达到目的。给定一个n个元素有序的（升序）整型数组nums和一个目标值target，写一个函数搜索nums中的target，如果目标值存在返回下标，否则返回-1。输入：nums = [-1,0,3,5,9,12]输出：4解释：9 出现在nums中并且下标为4。
代码随想录总结
yeeanna的博客
10-24 1524
找工作刷题，仅供自己参考
代码随想录刷题｜一刷总结
东东唯一指定铲屎官
04-21 1634
成果汇报经验总结为什么要刷题未来计划以及附件资源，里面有所有pdf，需要自取。我会在末尾放上pdf，点击思维导图的右上角的【箭头】可以直接跳转到leetcode，提供一键跳转方便复习。
代码随想录 正版
m0_37347812的博客
02-22 874
代码随想录
代码随想录一刷总结
qq_45542288的博客
04-22 299
代码随想录的一刷，也大致是伴随着我的春招找实习一同进行的。有着每日任务的下达，相较于自己埋头苦刷，总是更容易坚持下去的。一刷完成，我的每天刷题的习惯也大致养成了。实习还未找到，秋招也不远了。刷题作为求职的一个重要部分，也是必不可少，且需要良好的规划的。目前，暂定的后序刷题顺序是：1. 随想录图论部分及未分类部分；3. 牛客高频面试题。三个部分可以看心情并行进行。相信现在的刷题速度相比于2个月前的自己，一定是快了很多的。找实习加油，秋招加油！
代码随想录-大厂八股文-面试
04-25
"代码随想录-大厂八股文-面试" 从标题和描述中，我们可以看出这篇文章主要讲述的是代码随想录的大厂八股文面试相关知识点。下面将对这些知识点进行详细的解释和总结。 首先，代码随想录是一种常用的编程技巧，旨在...
代码随想录知识星球精华 最强⼋股⽂
04-28
代码随想录知识星球精华（最强⼋股⽂） 这份PDF总结了 代码随想录知识星球 的全部精华内容，覆盖了⼏乎程序员学习必备的内容。 知识星球⾥很多录友拿到了⼤⼚offer，包括科班 和 ⾮科班的，⽽他们的每⽇学习总结都是...
代码随想录算法PDF.zip
05-29
《代码随想录》是一本深受程序员喜爱的算法学习书籍，其PDF版本为读者提供了方便的电子阅读体验。这本书主要针对准备参加编程面试或者想要提升自己算法能力的开发者，通过实例解析和实战演练，帮助读者深入理解算法...
代码随想录 面试大厂必备八股文
07-03
《代码随想录》是众多程序员面试准备的重要参考资料，尤其对于目标是大厂的开发者来说，这本书中的“面试大厂必备八股文”更是不容忽视的内容。这里的“八股文”并非传统意义上的文学形式，而是指在编程面试中经常被...
算法刷题：300. 最长递增子序列、674. 最长连续递增序列、718. 最长重复子数组、1143. 最长公共子序列
最新发布
qq_61936886的博客
09-12 501
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。但dp[i][0] 和dp[0][j]要初始值，因为 为了方便递归公式dp[i][j] = dp[i - 1][j - 1] + 1;2.递推公式：当A[i - 1] 和B[j - 1]相等的时候，dp[i][j] = dp[i - 1][j - 1] + 1;
算法知识点——常用输入输出数据的方式
5233的博客
09-12 294
除了换行之外，还会清空缓存区，而清空缓存区这件事情会耗时很久，因此为了提高速度，一般直接：cout << “\n”;2、n组输入输出(n不确定）1、n组输入输出(n确定）3、 复杂的输入输出。
Java数据结构（十）——冒泡排序、快速排序
xiaokuer_的博客
09-11 1184
文章介绍了冒泡排序和快速排序，快速排序的内容包括：划分方式、优化策略以及非递归实现
算法基础-约数
qq_65186476的博客
09-11 320
试除法求约数、约数个数、约数之和、最大公约数
代码随想录python
02-17
代码随想录是一个由CSDN开发的Python学习教程，它提供了丰富的Python编程知识和实例代码。以下是关于代码随想录Python的介绍： 1. 代码随想录Python是一个面向初学者的Python教程，它从基础知识开始，逐步介绍...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值