leetcode刷题第三天

最新推荐文章于 2023-12-06 14:23:59 发布
最新推荐文章于 2023-12-06 14:23:59 发布
阅读量104 收藏
点赞数
分类专栏： leetcode 文章标签： leetcode 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45975562/article/details/127566007
版权

1. 链表基础

1.1概念

链表(linked list)：是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的.

链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂度分别是O(logn)和O(1)。

1.2 链表的分类

  1. 单向链表，双向链表
  2. 带头的链表，不带头的链表
  3. 循环的链表和非循环的链表

1.3链表代码实现

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

1.4链表和数组对比

在这里插入图片描述

2. leetcode230 移除链表元素

题目链接

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

2.1思路

这里就涉及如下链表操作的两种方式：

  • 直接使用原来的链表来进行删除操作： 移除头结点和移除其他节点的操作是不一样的，因为链表的他节点都是通过前一个节点来移除当前节点，而头结点没有前一个节点。所以头结点如何移除呢，其实只要将头结点向后移动一位就可以，这样就从链表中移除了一个头结点。
  • 设置一个虚拟头结点在进行删除操作：

2.2代码实现

/**
 * 添加虚节点方式
 * 时间复杂度 O(n)
 * 空间复杂度 O(1)
 * @param head
 * @param val
 * @return
 */
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;
    while (cur != null) {
        if (cur.val == val) {
            pre.next = cur.next;
        } else {
            pre = cur;
        }
        cur = cur.next;
    }
    return dummy.next;
}
/**
 * 不添加虚拟节点方式
 * 时间复杂度 O(n)
 * 空间复杂度 O(1)
 * @param head
 * @param val
 * @return
 */
public ListNode removeElements(ListNode head, int val) {
    while (head != null && head.val == val) {
        head = head.next;
    }
    // 已经为null，提前退出
    if (head == null) {
        return head;
    }
    // 已确定当前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;
}
/**
 * 不添加虚拟节点and pre Node方式
 * 时间复杂度 O(n)
 * 空间复杂度 O(1)
 * @param head
 * @param val
 * @return
 */
public ListNode removeElements(ListNode head, int val) {
    while(head!=null && head.val==val){
        head = head.next;
    }
    ListNode curr = head;
    while(curr!=null){
        while(curr.next!=null && curr.next.val == val){
            curr.next = curr.next.next;
        }
        curr = curr.next;
    }
    return head;
}

3 leetcode707 设计链表

题目链接
题意：

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

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

3.1代码实现

//单链表
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个节点的数值
    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) {
        addAtIndex(0, val);
    }

    //在链表的最后插入一个节点
    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);
 */

4 leetcode206 反转链表

题目链接

4.1思路

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

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

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

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

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

4.2代码实现

// 双指针
class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode prev = null;
        ListNode cur = head;
        ListNode temp = null;
        while (cur != null) {
            temp = cur.next;// 保存下一个节点
            cur.next = prev;
            prev = cur;
            cur = temp;
        }
        return prev;
    }
}
Shr.Zar
关注
专栏目录
Leetcode刷题技巧，看这一篇就够了
weixin_41930359的博客
08-01 1555
1.常看Discussion。我相信很多同学为了刷题量，解开一道题后会迫不及待地点开下一道题。更为甚者，很多同学把刷题的数量作为衡量水平的绝对标准，比如“老师，我在Leetcode刷了500题，您看去面Google有希望吗？”，结果该挂还是挂了。但是，你有没有试过思考其他过解决方案? 这里并不只是说在自己的代码上继续优化，而是点开Discussion, 看看其他人有没有其他的思路，并思考他们的解法和你的有什么不同。也就是说，Discussion也是刷题的一部分。同学们往后可以注意这点，注意分析别人的思路，.
LeetCode刷题攻略
Redemption___的博客
06-13 7233
应届生面试算法就考个数组 链表 二叉树 矩阵 数组变着法子考你排序 查询 指针 位运算 链表变着法子考你指针 最多再考个哈希 二叉树变着法子考用递归和栈前中后遍历 最多加上回溯 矩阵的话就是知道起点的路径查询和不知道起点的路径查询 掌握了这些 面大厂就比较轻松了 其实和学历技术关系也不大 大部分人先死到想都不敢想上了。 据了解，LeetCode 是一个非常棒的 OJ（Online Judge）平台，收集了许多公司的面试题目。相对其他 OJ 平台而言，有着下面的几个优点： 题目全部来自业内大公司的真.
剑指offer(17)——反转链表(思路及代码)
weixin_45778415的博客
07-21 252
题目 定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。 思路 首先定义一个cur指针，指向头结点，再定义一个pre指针，初始化为null。 然后就要开始反转了，首先要把 cur->next 节点用tmp指针保存一下，也就是保存一下这个节点。 为什么要保存一下这个节点呢，因为接下来要改变 cur->next 的指向了，将cur->next 指向pre ，此时已经反转了第一个节点了。 接下来，就是循环走如下代码逻辑了，继续移动pre和cur指针。 最后，cur 指针已经
【力扣】反转链表
qq_36149079的博客
05-16 647
题目：给你单链表的头指针 head 和两个整数left 和 right ，其中left <= right 。请你反转从位置 left 到位置 right 的链表节点，返回 反转后的链表 。 该题是部分反转链表，也就是指定位置进行反转 反转链表思路： 1.新建一个链表，把原链表的末结点插入到新链表头结点 2.不建立新链表的话，将遍历向后，将后一个结点插入自身头结点之前。 即：1 2 3 4 5 -> 2 1 3 4 5 -> 3 2 1 4 5 -> 4 3...
力扣206题——反转链表
m0_61608447的博客
04-24 588
反转链表的三种思路
力扣 206.反转链表
qq_53574615的博客
12-11 702
问题描述 给你单链表的头节点head，请你反转链表，并返回反转后的链表。 示例1： 输入：head = [1,2,3,4,5] 输出：[5,4,3,2,1] 示例2： 输入：head = [1,2] 输出：[2,1] 示例3： 输入：head = [] 输出：[] 解题思路 /** * Definition for singly-linked list. * public class ListNode { * int val; *...
力扣—206. 反转链表
xiaoxin0630的博客
04-23 618
反转一个单链表。 示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL 进阶: 你可以迭代或递归地反转链表。你能否用两种方法解决这道题？ 思路 需要三个存放的位置 上一个 当前元素，下一个元素 package com.binglian.Linked; /** ...
LeetCode刷题模板.pdf
04-05
1.4. LeetCode中二分查找题目 29 2. 双指针 30 2.1. 快慢指针 31 2.1.1. 什么是快慢指针 31 2.1.2. 快慢指针模板 31 2.1.3. 快慢指针相关题目 32 2.1.3.1. LC-141:链表是否有环 32 2.1.3.2. LC-142:环形链表入口 34 ...
LeetCode:LeetCode 刷题笔记(C++, Python 实现)
04-12
LeetCode刷题笔记 ＃ 标题 标签 1个 两次总和 哈希表 2个 加两个数字 链表 3 最长子串，无重复字符 细绳 4 两个排序数组的中位数 大批 5 最长回文子串 细绳 6 之字形转换 细绳 7 反整数 数学 8 字符串到整数 ...
leetcode刷题方法总结—数组全解
修行的凡人的博客
08-21 1324
leetcode解题方法全解--数组全解
力扣——反转链表
weixin_30449453的博客
04-02 367
反转一个单链表。 示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL 进阶:你可以迭代或递归地反转链表。你能否用两种方法解决这道题？ class Solution { public ListNode reverseList(ListNode head) { ...
LeetCode-链表经典习题（206-反转链表）图文详解
weixin_48143996的博客
12-03 649
为了明年的实习要从现在开始狠刷LeetCode了 这个反转链表在面试中还是经常容易考到的！！划重点 需求：反转一个单链表 示例： - 输入：1->2->3->4->5->NULL - 输出：5->4->3->2->1->NULL 进阶： 你可以迭代或递归的这两种方式解决这道题 1. 递归： 我在递归这方面一直都是比较弱的，所以我就以我最直白的方式来讲这个反转的递归，我自我觉得吧，我能看明白的递归大家应该都行（递归我是真不行），我这就直接说
leetcode系列-206.反转链表
weixin_41198447的博客
04-13 373
leetcode系列–第206题.反转链表 这道题很经典 给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。 示例 1： 输入：head = [1,2,3,4,5] 输出：[5,4,3,2,1] /** * Definition for singly-linked list. * function ListNode(val, next) { * this.val = (val===undefined ? 0 : val) * this.next = (next=
【力扣】：图解 反转链表
衡的博客
03-08 210
反转一个单链表。 示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL /** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNode...
力扣刷题笔记——反转链表
最新发布
bairui6666的博客
12-06 1359
经典问题反转链表这里给出四种解法。
力扣206——反转链表
ren__wei_的博客
04-01 177
题目描述： 反转一个单链表。 示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL 分析： 这里题目给定一个链表，要求我们将其反转。 这里我们指定curNode 为当前操作的节点，prevNode 为当前节点的前一个节点。每次循环让curNode指向prevNode，然后更新curNode和prevNode的位置即可。 话不多说，直接上代码： 代码： class Solution { pub
力扣206 - 反转链表【校招面试高频考题】
做技术人 · 产优质博客 · 找好工作
11-13 1069
力扣206 - 反转链表，一道校招中笔试面试链表章节中【非常高频】的考题
力扣：反转链表
qq_56762247的博客
02-11 243
力扣：反转链表 题目： 给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。 思路： 运用三个指针，用两个指针作为逆置链接关系的前后节点，以及用一个指针提供下一个节点的位置。 代码： /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode() : val(0), next(nullptr) {} * Lis
LeetCode刷题攻略：二分法与双指针模板
"LeetCode刷题模板.pdf" 这篇文档主要涵盖了LeetCode刷题中常见的两种算法模板——二分法和双指针法，并提供了相应的代码模板、关键属性和具体题目的应用示例。以下是对这两种方法的详细解释： 1. 二分法 - 什么...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值