【LeetCode】经典题分类（链表 ）精选 - JavaScript - ES6 - 技巧总结

最新推荐文章于 2024-04-27 14:46:37 发布
最新推荐文章于 2024-04-27 14:46:37 发布
阅读量355 收藏 1
点赞数
分类专栏： 算法 文章标签： leetcode javascript 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44972008/article/details/117857353
版权

在这里插入图片描述

文章目录

序号为LeetCode的题序，语言选择的是JavaScript

707. 设计链表

设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。

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

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/design-linked-list

/**
 * Initialize your data structure here.
 * 初始化数据结构
 */
var MyLinkedList = function () {
  // 初始化 链表长度 和 头指针
  this.length = 0;
  this.head = null;
};

/**
 * 初始化链表中的节点
 * @param {*} val
 */
MyLinkedList.prototype.node = function (val) {
  this.val = val;
  this.next = null;
};

/**
 * Get the value of the index-th node in the linked list. If the index is invalid, return -1.
 * 获取链表中第 index 个节点的值。如果索引无效，则返回-1
 * @param {number} index
 * @return {number}
 */
MyLinkedList.prototype.get = function (index) {
  if (index < 0 || index >= this.length) {
    return -1;
  }

  // 从头结点开始遍历
  let current = this.head;
  for (let i = 0; i < index; i++) {
    current = current.next;
  }

  return current ? current.val : -1;
};

/**
 * Add a node of value val before the first element of the linked list. After the insertion, the new node will be the first node of the linked list.
 * 在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点
 * @param {number} val
 * @return {void}
 */
MyLinkedList.prototype.addAtHead = function (val) {
  // 新建一个节点，将值val传递进去
  let headNode = new this.node(val);
  // 将新建的节点的next指向当前链表头结点
  headNode.next = this.head;
  // 将链表头结点指针指向新建的节点
  this.head = headNode;
  // 链表长度增加
  this.length++;
};

/**
 * Append a node of value val to the last element of the linked list.
 * 将值为 val 的节点追加到链表的最后一个元素
 * @param {number} val
 * @return {void}
 */
MyLinkedList.prototype.addAtTail = function (val) {
  // 新建尾结点
  let tailNode = new this.node(val);

  // 遍历到链表当前尾节点
  let current = this.head;

  while (current && current.next) {
    current = current.next;
  }

  if (current) {
    current.next = tailNode;
  } else {
    current = tailNode;
    this.head = tailNode;
  }

  this.length++;
};

/**
 * Add a node of value val before the index-th node in the linked list. If index equals to the length of linked list, the node will be appended to the end of linked list. If index is greater than the length, the node will not be inserted.
 * 在链表中的第 index 个节点之前添加值为 val  的节点。
 * 如果 index 等于链表的长度，则该节点将附加到链表的末尾。
 * 如果 index 大于链表长度，则不会插入节点。
 * 如果index小于0，则在头部插入节点。
 * @param {number} index
 * @param {number} val
 * @return {void}
 */
MyLinkedList.prototype.addAtIndex = function (index, val) {
  if (index <= 0) return this.addAtHead(val);
  if (index === this.length) return this.addAtTail(val);
  if (index > this.length) return;

  let addNode = new this.node(val);

  // 找到index位置的前一个节点
  let prev = this.head;
  for (let i = 0; i < index - 1; i++) {
    prev = prev.next;
  }

  // 添加节点操作
  addNode.next = prev.next;
  prev.next = addNode;

  this.length++;
};

/**
 * Delete the index-th node in the linked list, if the index is valid.
 * @param {number} index
 * @return {void}
 */
MyLinkedList.prototype.deleteAtIndex = function (index) {
  if (index < 0 || index >= this.length) return;
  if (index === 0) {
    this.head = this.head.next;
    this.length--;
  } else {
    // 找到index前一个节点
    let prev = this.head;
    for (let i = 0; i < index - 1; i++) {
      prev = prev.next;
    }

    // 删除节点
    if (prev && prev.next) {
      prev.next = prev.next.next;
    }

    this.length--;
  }
};

2. 两数相加

https://leetcode-cn.com/problems/add-two-numbers/

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。
请你将两个数相加，并以相同形式返回一个表示和的链表。
你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

/**
 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */
/**
 * @param {ListNode} l1
 * @param {ListNode} l2
 * @return {ListNode}
 */
var addTwoNumbers = function(l1, l2) {
	// 创建两个指针，一个指向链表头部一个空的0节点，一个指向尾部
    let head = new ListNode(0)
    let tail = head
	// 进位计数变量
    let add = 0
	// 只要两个链表有一个不为空就一直循环
    while(l1 || l2){
    	// 如果有一个遍历结束了，后面都置0
        let num1 = l1 ? l1.val : 0
        let num2 = l2 ? l2.val : 0
        
        // 两数之和，加上进位
        let sum = num1 + num2 + add

		// 如果求和超过10，就要进位，add就是进位的数字
        add = Math.floor(sum/10)
        // sum小于10就还是自己，超过10就是个位
        sum = sum % 10
        // 在尾指针后添加新节点
        tail.next = new ListNode(sum)
		// 尾指针后移
        tail = tail.next
        
		// 只要传入的链表还有元素就一直遍历
        if(l1) l1 = l1.next
        if(l2) l2 = l2.next
    }
	// 遍历结束，如果最后还有一个进位，就把他添加到最后
    if(add === 1){
        tail.next = new ListNode(add)
    }
	// 最后返回头节点的后一个节点就是所求的链表
    return head.next
};

在这里插入图片描述

剑指 Offer 22. 链表中倒数第k个节点

双指针

/**
 * @param {ListNode} head
 * @param {number} k
 * @return {ListNode}
 */
var getKthFromEnd = function(head, k) {
    let left = head
    let right = head
    for(let i = 0; i < k; i++){
        right = right.next
    }
    while(right){
        right = right.next
        left = left.next
    }
    return left
};

在这里插入图片描述

141. 环形链表

给定一个链表，判断链表中是否有环。
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。
如果链表中存在环，则返回 true 。 否则，返回 false 。

【解法一 JS特性】

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

/**
 * @param {ListNode} head
 * @return {boolean}
 */
var hasCycle = function(head) {
    try{
        JSON.stringify(head)
    }catch(e){
        return true
    }
    return false
};

【解法二】使用Map

var hasCycle = function(head) {
    let map = new Map()
    while(head) {
        if(map.has(head)) return true
        map.set(head, true)
        head = head.next
    }
    return false
};

【解法三】快慢指针

var hasCycle = function(head) {
    let fast = head
    let slow = head
    while(fast){
        if(fast.next === null) return false
        slow = slow.next
        fast = fast.next.next
        if(slow === fast) return true
    }
    return false
};

142. 环形链表 II

给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
说明：不允许修改给定的链表。

【解法一】使用Map

var detectCycle = function(head) {
    let map = new Map()
    while(head){
        if(map.has(head)){
            return head;
        }
        map.set(head, true)
        head = head.next
    }
    return null
};

【解法二】快慢指针

在这里插入图片描述

在这里插入图片描述

var detectCycle = function(head) {
    if(head === null) return null
    let slow = head
    let fast = head
    while(fast){
        if(fast.next===null) return null
        slow = slow.next
        fast = fast.next.next
        if(slow === fast){
            let pre = head
            while(slow !== pre){
                pre = pre.next
                slow = slow.next
            }
            return pre
        }
    }
    return null
};

160. 相交链表

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

【解法一】使用Map

var getIntersectionNode = function(headA, headB) {
    if(headA === null || headB === null) return null
    let map = new Map()
    let a = headA
    let b = headB
    while(a){
        map.set(a, true)
        a = a.next
    }
    while(b){
        if(map.has(b)){
            return b
        }
        b = b.next
    }
    return null
};

【解法二】双指针

将两个链表拼在一起，就可以同时到达相交的地方了
在这里插入图片描述

var getIntersectionNode = function(headA, headB) {
    if(headA === null || headB === null) return null

    let a = headA
    let b = headB

    while(a!== b){
        a = a.next;
        b = b.next;
        if(a === null && b === null) return null
        // a遍历完了就把b链表接后面
        if(a === null){
            a = headB
        }
        // b遍历完了就把a链表接后面
        if(b === null){
            b = headA
        }
    }
    // a指针和b指针相同 null或者具体结点
    return a
};

21. 合并两个有序链表

迭代

/**
 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */
 
/**
 * @param {ListNode} l1
 * @param {ListNode} l2
 * @return {ListNode}
 */
var mergeTwoLists = function (l1, l2) {
  const prehead = new ListNode(-1);
  let prev = prehead;
  while (l1 !== null && l2 !== null) {
    if (l1.val <= l2.val) {
      prev.next = l1;
      l1 = l1.next;
    } else {
      prev.next = l2;
      l2 = l2.next;
    }
    prev = prev.next;
  }

  if (l1 === null) {
    prev.next = l2;
  } else{
    prev.next = l1;
  }

  return prehead.next;
};

递归

在这里插入图片描述

首先找到递归终止条件出口，就是一方元素为空，返回另一方

if(l1 === null){
    return l2
}else if(l2 === null){
    return l1
}

然后进行一般的判断
将头结点小的那个指针

if(l1.val < l2.val){
	l1.next = mergeTwoLists(l1.next, l2)
	return l1;
}

/**
 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */
/**
 * @param {ListNode} l1
 * @param {ListNode} l2
 * @return {ListNode}
 */
var mergeTwoLists = function(l1, l2) {
    if(l1 === null){
        return l2
    }else if(l2 === null){
        return l1
    }else if(l1.val < l2.val){
        l1.next = mergeTwoLists(l1.next, l2)
        return l1;
    }else{
        l2.next = mergeTwoLists(l1, l2.next)
        return l2
    }
};

237. 删除链表中的节点

注意题目给的条件，没有传入head，所以是直接对传入的node进行操作的

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * @param {ListNode} node
 * @return {void} Do not return anything, modify node in-place instead.
 */
var deleteNode = function(node) {
    node.val = node.next.val;
    node.next = node.next.next;
};

剑指 Offer 24. 反转链表

【解法一】非递归

var reverseList = function(head) {
    let prev = null;
    let curr = head;
    while (curr) {
        let temp = curr.next;
        curr.next = prev;
        prev = curr;
        curr = temp;
    }
    return prev;
};

【解法二】递归

var reverseList = function(head) {
    if (head == null || head.next == null) {
        return head;
    }
    const newHead = reverseList(head.next);
    
    head.next.next = head;
    head.next = null;
    return newHead;
};

876. 链表的中间结点

给定一个头结点为 head 的非空单链表，返回链表的中间结点。
如果有两个中间结点，则返回第二个中间结点。

/**
 * 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}
 */
var middleNode = function(head) {
    let fast = head
    let slow = head
    while(fast && fast.next){
        fast = fast.next.next
        slow = slow.next
    }
    return slow
};

在这里插入图片描述

YK菌
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaScript刷LeetCode拿offer-经典高频40题
m0_67615103的博客
12-20 126
给定一个仅包含大小写字母和空格 ’ ’ 的字符串，返回其最后一个单词的长度。};
【算法】经典排序算法总结-JavaScript描述-图解-复杂度分析
YK菌的博客
04-20 2027
文章目录1. 冒泡排序流程图示代码复杂度分析2. 选择排序流程图示代码复杂度分析3. 插入排序流程图示代码复杂度分析3. 插入排序流程图示代码复杂度分析总结 已经有很多排序算法的文章了，这里主要是做一个总结。内容大部分整合自《算法第四版》，图示大部分来自菜鸟教程网。语言选择的当然是JavaScript啦~ 1. 冒泡排序 流程 比较相邻的元素。如果前者大于后者就交换 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数 针对所有的元素重复以上的步骤，除了最后一
【LeetCode】经典题分类（树&图 ）精选 - JavaScript - ES6 - 技巧总结
YK菌的博客
08-01 377
持续不定期更新中...
leetcode(领扣)---javascript参考答案
yipanhuasheng的博客
11-17 1201
记录一些leetcode上的题，其中涉及到es6语法,可以Ctrl + F自行查找题号。我会时不时更新新的解法，从时间或者空间上来考虑。不得不说javascript虽然提供了很多好用强大的函数，但是不一定就快，没准只是简洁易读。有些题目，只要应用得当，可以使用更新的api来完成，当然不一定变快了，就当做是练手了。毕竟前端对算法要求不是那么苛刻，但是要有解题的能力，优化什么的还是绕不开的。 源码放...
LeetCode算法题 - 面试题 02.07. 链表相交(c语言)
1900's 88 keys的博客
11-28 103
面试题 02.07. 链表相交 难度：简单 题目连接：https://leetcode-cn.com/problems/intersection-of-two-linked-lists-lcci/ 给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。 图示两个链表在节点 c1 开始相交： 题目数据 保证 整个链式结构中不存在环。 注意，函数返回结果后，链表必须 保持其原始结构 。 示例 1： 输入：intersectVal
leetcode算法题-链表操作（两数相加）
12-20
leetcode 算法题： 两数相加 给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。 如果，我们将这两个数相加起来，则会返回一个新...
leetcode-js:LeetCode精选习题，直通BAT大厂
05-04
leetcode习题 - js版
leetcode伪代码-LeetCode-[removed]LeetCode-JavaScript
06-30
leetcode伪代码 Introduction 无意中看到一个 B 站小姐姐的数据结构与算法系列视频： 感觉还是挺不错的，有下面几个原因： 已经完结，不会有催更的烦恼； 循序渐进得带你了解各种常用的数据结构，非常详细； 提供...
leetcode答案-LeetCode-50-JavaScript-Answers:Leetcode集合50个JavaScript答案
06-30
leetcode ...LeetCode-50-JavaScript-Answers 题目来源: 腾讯精选练习（50 题） 信息更新时间：2019-3-11，因为要准备面前端，就用js做了遍来熟悉JavaScript这门语言，50道题均已提交通过。 相关博客：
leetcode购买-LeetCode-[removed]LeetCode-Javascript
07-01
LeetCode：面试训练营（经典版） 这是经典版的课程代码。 先决条件 例子 运行测试 cd进入文件夹 然后运行： jest --watch LC102_levelOrder 笔记 我创建了这门课程，其中包含其他问题、改进的解释、全新的提示和技巧...
【剑指Offer】整数（一）整数除法 - 两数相除 - JavaScript
YK菌的博客
06-15 1267
从今天开始我们一起来刷《剑指offer（专项突破版）》，原书是Java版本的，这里就是以JavaScript角度来看这些算法题。第一题：整数除法！
【LeetCode】LRU缓存 - 最近最少使用缓存机制 - JavaScript描述 - Map - 双向链表
YK菌的博客
12-09 1132
今天分享一道高频面试算法题：LRU缓存机制。运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制
【剑指Offer】整数（二）二进制 - 二进制加法 - JavaScript
YK菌的博客
08-13 1066
从今天继续来刷《剑指offer（专项突破版）》，原书是Java版本的，这里就是以JavaScript角度来看这些算法题。剑指 Offer II 002. 二进制加法
【LeetCode】经典题分类（数学 - 数组 - 字符串）精选 - JavaScript - ES6 - 技巧总结
YK菌的博客
07-11 589
不定期持续更新
【LeetCode】斐波那契数列 - 递归 - 缓存递归 - 动态规划 - 矩阵快速幂 - 通项公式 - JavaScript描述 - 相关问题拓展 - 爬楼梯
YK菌的博客
04-28 407
1. 题目来源 509. 斐波那契数 这题的要求是0 <= n <= 30 （用无脑递归可以通过） 剑指 Offer 10- I. 斐波那契数列 这题的要求是0 <= n <= 100 （用无脑递归不可以通过） 2. 题目描述 写一个函数，输入 n ，求斐波那契（Fibonacci）数列的第 n 项（即 F(N)）。 斐波那契数列的定义如下： F(0) = 0, F(1) = 1 F(N) = F(N - 1) + F(N - 2), 其中 N > 1. 斐波那契数列由 0
【算法】浅析JavaScript中快速幂操作的使用
YK菌的博客
09-19 318
快速幂思想很重要啊xdm一定要学学
LeetCode---394周赛
最新发布
V_zjs的博客
04-27 348
LeetCode---394周赛---模拟+位运算优化+状态转移+动规+Dijkstra算法
力扣-1844.将所有数字用字符替换
qq_73454087的博客
04-23 404
具体来说，`ord(arr[i - 1])` 返回前一个字符的 ASCII 码，`int(arr[i])` 将当前位置的字符转换为整数，然后二者相加，并用 `chr()` 方法将结果转换为对应的字符。2. `def replaceDigits(self, s: str) -> str:`：定义了一个名为 `replaceDigits` 的方法，该方法接受一个字符串 `s` 作为参数，并返回一个字符串。4. `arr = list(s)`：将字符串 `s` 转换为字符列表，并将其赋值给变量 `arr`。
leetcode-5:实现链表的首尾链接
12-30
leetcode-5题要求我们实现链表的首尾链接，即将链表中最后一个节点的next指针指向链表中的第一个节点，并将链表中的第一个节点的prev指针指向链表中最后一个节点。 解题思路如下： 1. 首先，判断链表是否为空，若为...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值