【每日更新 Suggest 】leetcode解题-2022-4-22

我是哪吒
941 阅读41分钟

一起养成写作习惯！这是我参与「掘金日新计划 · 4 月更文挑战」的第22天，点击查看活动详情。

低调务实优秀中国好青年 (简介) && 附加答案

中文 | English

地址 ⬇️

github.com/webVueBlog/…

一个 ☝️ 正经的前端学习 开源 仓库，启发来自 淘宝大佬 @冴羽 ，初心做一个真正能帮助到大家的仓库。（非常口语化的，手写总结）

👤：我是哪吒： 如果你所学的东西 处于喜欢 才会有强大的动力支撑。

🐤 交流讨论 && 如何学习 && 转载声明 && 帮忙修正以及补充

第一：你可以直接在本仓库阅读即可，阶段性学习。 （可以转载里面的所有知识点用到任何地方，但请添加仓库的地址）有问题欢迎提交issues . 欢迎大家前来讨论，如果觉得对你的学习有一定的帮助，欢迎点个Star （此仓库每天都会准时更新）- vx联系: xiaoda0423

141. 环形链表

  1. 环形链表

给你一个链表的头节点 head ，判断链表中是否有环。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。

如果链表中存在环 ，则返回 true 。 否则，返回 false 。

示例 1： 输入：head = [3,2,0,-4], pos = 1 输出：true 解释：链表中有一个环，其尾部连接到第二个节点。

示例 2： 输入：head = [1,2], pos = 0 输出：true 解释：链表中有一个环，其尾部连接到第一个节点。

示例 3： 输入：head = [1], pos = -1 输出：false 解释：链表中没有环。

提示：

链表中节点的数目范围是 [0, 104] -105 <= Node.val <= 105 pos 为 -1 或者链表中的一个 有效索引 。

思路：暴力破解法：

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }

 */

/**
 * @param {ListNode} head
 * @return {boolean}
 */
var hasCycle = function(head) {
    // 首先判断一下这个链表是不是空的链表或者是这个链表是不是只有一个节点
    // 如果是的话那就说明他不可能构成环形链表
    // 我们直接给他返回false
    if(!head || head.next === null) return false
    // 否则的话呢，我们就从头指针开始然后遍历一下 遍历一下这个链表
    let p = head
    const arr = []
    while(p !== null) {
        // 我们判断一下这个数组里面是否已经 包含了这个节点
        if(!arr.includes(p)) {
            // 如果不包含的话呢我们就 把这个节点直接push到这个数组里面
            arr.push(p)
            // 然后把 p 指针指向下一个节点
            p = p.next
        } else {
            // 否则如果这个节点已经在数组里面出现了
            // 就说明他是第二次走到了这里
            // 那么我们返回true
            // 说明他有 他是一个环形链表
            return true;
        }
    }
    // 否则的话呢
    // 就是说明他走到了末尾的空节点 
    // 那么我们就返回了false
    return false
};

142. 环形链表 II

给定一个链表的头节点  head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。

示例 1： 输入：head = [3,2,0,-4], pos = 1 输出：返回索引为 1 的链表节点 解释：链表中有一个环，其尾部连接到第二个节点。

示例 2： 输入：head = [1,2], pos = 0 输出：返回索引为 0 的链表节点 解释：链表中有一个环，其尾部连接到第一个节点。

示例 3： 输入：head = [1], pos = -1 输出：返回 null 解释：链表中没有环。  

提示：

链表中节点的数目范围在范围 [0, 104] 内 -105 <= Node.val <= 105 pos 的值为 -1 或者链表中的一个有效索引  

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */

/**
 * @param {ListNode} head
 * @return {ListNode}
 142. 环形链表 II
 */
 // 我们上节讲到第一种方法是 用一个数据结构去存储
 // 链表的每个节点 如果它走到了 最后的一个空节点就说明它没有环形
 // 如果它第二次走到一个相同的节点就说明 它具有环
 // 第二次走到的这个节点就是入环的节点
var detectCycle = function(head) {
    if(!head || head.next === null) return null
    // 我们使用Map结构来进行存储
    // 因为Map结构在查找的时候效率比较高
    const mapper = new Map()
    let p = head
    while(p) {
        // 我们看一下这个p节点是不是在Map里面
        // 如果不是的话我们就把它存到Map里面去
        if(!mapper.has(p)) {
            mapper.set(p, p)
            // 然后把p指向它的下一个节点
            p = p.next
        } else {
            // 否则的话就说明Map里面已经存在这个节点
            // 而且这个节点就是它的入环点
            return p
        }
    }
    // 如果跳出了循环呢 就说明它已经走到了空节点
    // 链表的末尾一个空节点
    // 所以就证明它是没有环的
    // 然后我们直接返回null就好了
    return null
};

202. 快乐数

编写一个算法来判断一个数 n 是不是快乐数。

「快乐数」 定义为：

对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。 然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。 如果这个过程 结果为 1，那么这个数就是快乐数。 如果 n 是 快乐数 就返回 true ；不是，则返回 false 。

示例 1： 输入：n = 19 输出：true

解释： 12 + 92 = 82 82 + 22 = 68 62 + 82 = 100 12 + 02 + 02 = 1

示例 2： 输入：n = 2 输出：false   提示：

1 <= n <= 231 - 1

/**
 * @param {number} n
 * @return {boolean}
 202. 快乐数
 当它最后是快乐数，最后是能够得到1这个值的
 1这个值就相当链表的尾节点就一个空节点
 如果不是快乐数 说明它会一直的去 在某一个数
 通过计算之后会等于前面的某一个数
 这样的话它才会 一直的循环下去形成闭环
 */
var isHappy = function(n) {
    // 1 <= n so 等于1的话它就是一个快乐数
    if(n === 1) return true
    // 首先我们定义一个map结构
    let mapper = new Map()
    let p = getNext(n)
    // 如果p不等于1的话
    while(p !== 1) {
        if(!mapper.has(p)) {
            mapper.set(p, p)
            p = getNext(p)
        } else {
            return false
        }
    }
    // 跳出循环的时候
    // 走到了最后一个节点也就是为1
    return true
};

// 获取它的下一个节点
var getNext = function(n) {
    let sum = 0
    while(n) {
        // 计算的话我们从它的末位开始去 平方和相加
        sum += (n % 10) ** 2 // 9
        // 把n赋值为就是把它的个位数砍掉
        n = Math.floor(n / 10) // 1
    }
    // 计算完成之后，我们再把和返回出来
    return sum
}

206. 反转链表

github.com/webVueBlog/…

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。   示例 1： 输入：head = [1,2,3,4,5] 输出：[5,4,3,2,1]

示例 2： 输入：head = [1,2] 输出：[2,1]

示例 3： 输入：head = [] 输出：[]   提示：

链表中节点的数目范围是 [0, 5000] -5000 <= Node.val <= 5000

/**
 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */
/**
 * @param {ListNode} head
 * @return {ListNode}
 206. 反转链表
 迭代的方法

      pre = null
      cur = head
(指向空节点)
 pre  cur(指向当前的头节点)
 null  1 -> 2 -> 3 -> 4 -> 5 -> null
 pre = null
 cur = head
 当当前节点不为空的时候

 pre    cur  next
 null <- 1   2     ->  3 -> 4 -> 5 -> null
 next = current.next
 cur.next = pre

            cur
       pre  next
null <- 1    2   ->  3 -> 4 -> 5 -> null
 pre = cur
 cur = next
 next = current.next
 cur.next = pre
 
 直到cur节点为空 return pre
 */
var reverseList = function(head) {
    let pre = null, cur = head, next
    // 判断当前指针
    while(cur) {
        next = cur.next
        cur.next = pre
        pre = cur
        cur = next
    }
    return pre
};

92. 反转链表 II

github.com/webVueBlog/…

给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点，返回 反转后的链表 。  

示例 1： 输入：head = [1,2,3,4,5], left = 2, right = 4 输出：[1,4,3,2,5]

示例 2： 输入：head = [5], left = 1, right = 1 输出：[5]  

提示：

链表中节点数目为 n 1 <= n <= 500 -500 <= Node.val <= 500 1 <= left <= right <= n  

/**
 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */
/**
 * @param {ListNode} head
 * @param {number} left
 * @param {number} right
 * @return {ListNode}
 92. 反转链表 II
left = 2 right = 4
定义一个虚拟的头节点

 -1 -> 1 -> 2 -> 3 -> 4 -> 5
 pre  cur
      pre  cur
      pre            cur

            2 -> 3 -> 4
            p    q
 */
var reverseBetween = function(head, left, right) {
    const newNode = new ListNode(-1, head)
    let pre = newNode, cur = head, next
    let n = right - left + 1
    while(--left) {
        pre = pre.next
        cur = cur.next
    }
    while(--n) {
        cur = cur.next
    }
    next = cur.next
    cur.next = null
    const reverseHead = reverse(pre.next, next)
    pre.next = reverseHead
    return newNode.next
};

var reverse = function (head, next) {
    let pre = head, cur = head.next
    while(head.next) {
        head.next = cur.next
        cur.next = pre
        pre = cur
        cur = head.next
    }
    head.next = next
    return pre
}

😛 阶段二十七（549）

展开查看

😛 阶段二十六（544）

展开查看

😛 阶段二十五（532）

展开查看

😛 阶段二十四（525）

展开查看

😛 阶段二十三（514）

展开查看

📕 阶段二十二（500）

展开查看

😋 阶段二十一（480）

展开查看

✔ 阶段二十（470）

展开查看

😗 阶段十九（460）

展开查看

🐉 阶段十八（450）

展开查看

🐔 阶段十七（440）

展开查看

🐟 阶段十六（425）

展开查看

🦐 阶段十五（401）

展开查看

🦂 阶段十四（384）

展开查看

😘 阶段十三（370）

展开查看

🥰 阶段十二（340）

展开查看

😉 阶段十一（324）

展开查看

🙃 阶段十（306）

展开查看

😍 阶段九（285）

展开查看

🧑🏻 阶段八（250）

展开查看

🧑🏻‍💻 阶段七（215）

展开查看

😇 阶段六（190）

展开查看

🧑🏻‍💻 阶段五（175）

展开查看

🥲 阶段四（150）

展开查看

🧑🏻‍💻 阶段三（145）

展开查看

🤣 阶段二（100）

展开查看

🧑🏻‍💻 阶段一（50）

展开查看

全栈架构师

展开查看

Leetcode刷题&答案

展开查看
  • 1.两数之和
  • 2.两数相加
  • 20.有效的括号
  • 21.合并两个有序链表
  • 22.括号生成
  • 24.两两交换链表中的节点
  • 27.移除元素
  • 35.搜索插入位置
  • 49.字母异位词分组
  • 46.全排列
  • 53.最大子序和
  • 56.合并区间
  • 57.插入区间
  • 77.组合
  • 78.子集
  • 90.子集II
  • 94.二叉树的中序遍历

👩🏻‍💻：webVueBlog的leetcode刷题📒

  1. Number题号
  2. Title题目
  3. Difficulty难度
  4. Navigation解答
NumberTitleDifficultyNavigation
1.两数之和两数之和
2.两数相加两数相加
3.无重复字符的最长子串无重复字符的最长子串

以 「早起」、「运动」、「冥想」、「写作」、「阅读」这五件能够快速改变人生的事情为切入点，帮助大家建立良好的生活习惯，技术的成长绝不是一朝一夕，良好的习惯将会帮助我们更快的进步，但在技术之外，我更希望大家能在这些事情的坚持中，收获一份自信，多一份底气，对人生多一份积极。 --- （来源：低调务实优秀中国好青年群）

License

MIT

avatar
文章
阅读
粉丝