JavaScript算法（一）

已于 2024-03-14 14:48:02 修改
阅读量990 收藏 19
点赞数 14
文章标签： 算法 前端 javascript
于 2024-03-11 13:49:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37633967/article/details/136191091
版权
本文详细介绍了JavaScript中的数据结构（如栈、队列、链表、集合和字典）及其操作，包括时间复杂度和空间复杂度的概念，以及如何在实际问题中运用这些概念解决LeetCode题目，如括号匹配、数组操作和字符串处理等。
摘要由CSDN通过智能技术生成

目录​​​​​​​

前言

1.数据结构与算法

2.时间复杂度

3.空间复杂度

4.栈

5.队列

6.链表

7.集合

Set操作

8.字典

总结

前言

数据结构与算法

1.数据结构与算法

数据结构：计算机存储、组织数据的方法

算法：一系列解决问题的清晰指令

程序 = 数据结构 + 算法

数据结构为算法提供服务，算法围绕数据结构操作

2.时间复杂度

O(1) :执行一次

let i = 0;
i += 1;

O(n)

for(let i = 0; i < n; i+=1) {
    console.log(i)
}

O(n)*O(n) = O(n^2)

for(let i = 0; i < n; i += 1){
    for(let j = 0; j < n; j += 1){
        console.log(i ,j)
    }
}

O(logN)

let i = 1;
while (i < n ) {
    console.log(i)
    i*=2;
}

3.空间复杂度

O(1) :声明单个变量

let i = 0;
i += 1;

O(n)：声明数组，添加n个值，占用n个内存单元

const list = [];
for(let i = 0; i < n; i+=1){
    list.push(i)
}

O(n^2)：矩阵-二维数组

const matrix = [];
for(let i = 0; i < n; i+=1){
    matrix.push([])
    for(let j = 0; j < n; j+=1){
        matrix[i].push(j)
    }
}

4.栈

  • 一个后进先出的数据结构
  • JavaScript 中没有栈，但可以用Array实现栈的所有功能
const stack = [];
stack.push(1);
stack.push(2);
const item1 = stack.pop();
const item2 = stack.pop();

应用场景：十进制转二进制、判断字符串的括号是否有效、函数调用堆栈

​​​​​​​

// LeetCode 20 有效括号
输入 '()' '()[]{}' '(}'
输出 true  true    false

var isValid = function(s) {
    if(s.length % 2 === 1){return false;}
    const stack = [];
    for(let i = 0;i < s.length; i++){
        const c = s[i];
        if(c === '(' || c === '{' || c === '['){
            stack.push(c)
        }else{
            const t = stack[stack.length - 1];
            if((t === '(') && c === ')' ||
               (t === '{') && c === '}' ||
               (t === '[') && c === ']' 
            ){
                stack.pop();
            }else{
                return false;
            }
        }
    }
    return stack.length === 0;
}

5.队列

  • 一个先进先出的数据结构
  • JavaScript 中没有队列，但可以用Array实现队列的所有功能

const queue = [];
queue.push(1);
queue.push(2);
const item1 = queue.shift();
const item2 = queue.shift();

应用场景：JS异步中的任务队列、计算最近请求次数

// 最近的请求次数
// 示例 
输入 inputs = ['RecentCounter','ping','ping','ping','ping']
inputs = [[],[1],[100],[3001],[3002]]
输出 [null,1,2,3,3]

var RecentCounter = function() {
    this.q = [];
};

RecentCounter.prototype.ping = function(t) {
    this.q.push(t);
    while(this.q[0] < t - 3000) {
        this.q.shift();
    }
    return this.q.length;
};

6.链表

  • 多个元素组成的列表
  • 元素存储不连续，用next指针连在一起

数组vs链表

数组：增删非首尾元素时，往往需要移动元素

链表：增删非首尾元素时，不需要移动元素，只需要更改next的指向即可

// JavaScript中没有链表
// 用Object模拟链表

const a = { val: 'a' };
const b = { val: 'b' };
const c = { val: 'c' };
const d = { val: 'd' };
a.next = b;
b.next = c;
c.next = d;

// 遍历链表
let p = a;
while(p){
    console.log(p.val);
    p = p.next;
}

// 插入
const e = { val: 'e' };
c.next = e;
e.next = d;

// 删除
c.next = d;
// leetCode 237 删除链表中的节点
// 输入 head = [4,5,1,9] node = 5
// 输出 [4,1,9]

var deleteNode = function(node){
    node.val = node.next.val;
    node.next = node.next.next;
}
// leetCode 206 翻转链表
// 输入 1-2-3-4-5-NULL
// 输出 5-4-3-2-1-NULL
// 双指针一前一后遍历链表，反转双指针

var reverseList = function(head){
    let p1 = head;
    let p2 = null;
    while(p1){
        const tmp = p1.next;
        p1.next = p2;
        console.log(p1.val, p2&&p2.val)
        p2 = p1;
        p1 = tmp;
    }
    return p2;
}

// leetCode 2 两数相加
// 输入 (2-4-3) + (5-6-4)
// 输出 7-0-8
// 原因 342 + 465 = 807
// 新建一个空链表
// 遍历被相加的两个链表，模拟相加操作，将个位数追加到新链表上，将十位数留到下一位去相加

var addTwoNumbers = function(l1,l2) {
    const l3 = new ListNode(0);
    let p1 = l1;
    let p2 = l2;
    let p3 = l3;
    let carry = 0;
    while(p1 || p2){
        const v1 = p1? p1.val : 0;
        const v2 = p2? p2.val : 0;
        const val = v1 + v2 + carry;
        carry = Math.floor(val / 10);
        p3.next = new ListNode(val % 10);
        if(p1) p1 = p1.next;
        if(p2) p2 = p2.next;
        p3 = p3.next;
    }
    if(carry){
        p3.next = new ListNode(carry);
    }
    return l3.next;
}
// leetCode 83 删除排序链表中的重复元素
// 输入1-1-2
// 输出1-2
// 因为链表是有序的，所以重复元素一定是相邻的
// 遍历链表，如果发现当前元素和下个元素值相同,就删除下个元素值

var deleteDuplicates = function(head){
    let p = head;
    while(p && p.next){
        if(p.val === p.next.val){
            p.next = p.next.next
        }else{
            p = p.next;
        }
    }
    return head;
}
// leetCode 141 环形链表
// 输入 head = [3,2,0,-4], pos = 1
// 输出 true
// 用一快一慢两个指针遍历链表，如果指针能够相逢，就返回true
// 遍历结束后，还没有相逢就返回false

var hasCycle = function(head){
    let p1 = head;
    let p2 = head;
    while(p1 && p2 && p2.next){
        p1 = p1.next;
        p2 = p2.next.next;
        if(p1 === p2){
            return true;
        }
    }
    return false;
}

JS中的原型链

  • 原型链的本质是链表
  • 原型链上的节点是各种原型对象，比如 Function.prototype/Object.prototype...
  • 原型链通过 __proto__ 属性连接各种原型对象

原型链知识点

  • 如果A沿着原型链能找到 B.prototype，那么A instanceof B 为 true
  • 如果在A对象上没有找到 x 属性，那么会沿着原型链找到 x 属性
// instanceof原理
const instanceof = (A,B) => {
    let p = A;
    while(p) {
        if(p === B.prototype){
            return true;
        }
        p = p.__proto__;
    }
    return false;
}
instanceof([], Object); // true
instanceof(1, Number); // true
// 使用链表指针获取JSON的节点值
const json = {
    a: { b: { c: 1}},
    d: { e: 2}    
}

const path = ['d','e'];

let p = json;
path.forEach(k => {
    p = p[k];
})

7.集合

  • 一种无序且唯一的数据结构
  • ES6中有集合，Set
  • 集合的常用操作：去重、判断某元素是否在集合中、求交集
// 去重
const arr = [1,1,2,2];
const arr2 = [...new Set(arr)];

// 判断元素是否在集合中
const set = new Set(arr);
const has = set.has(1); // true/false

// 求交集
const set2 = new Set([2,3]);
const set3 = new Set([...set].filter(item => set2.has(item)));


// leetCode 349 两个数组的交集
// 输入： nums1 = [1,2,2,1], nums2 = [2,2]
// 输出： [2]
// 输入： nums1 = [4,9,5], nums2 = [9,4,9,8,4]
// 输出： [9,4]


var intersection = function(nums1,nums2){
   return [...new Set(nums1)].filter(n => nums2.includes(n))
}

Set操作

  • 使用 Set 对象：new、add、delete、has、size
  • 迭代 Set：多种迭代方法、Set 与 Array 互转、求交集/差集
let mySet = new Set();

mySet.add(1); // {0:1}
mySet.add(5); // {0:1,1:5}
mySet.add(5); // {0:1,1:5}
mySet.add('haha') // {0:1,1:5,2:'haha'}
let o = {a:1,b:2};
mySet.add(o); // {0:1,1:5,2:'haha',3:{a:1,b:2}}
mySet.add({a:1,b:2}); // {0:1,1:5,2:'haha',3:{a:1,b:2},4:{a:1,b:2}}
// 添加对象，对象存储位置不一样，所以可以添加成功

const has = mySet.has('1');

mySet.delete(5);

for(let item of mySet) console.log(item);
for(let item of mySet.keys()) console.log(item);
for(let item of mySet.values()) console.log(item);
for(let [key, value] of mySet.entries()) console.log(key,value);

// set转换array
const myArr = [...mySet];
const myArr1 = Array.from(mySet);

// array转换set
const mySet2 = new Set([1,2,3,4]);

// 求交集
const intersection = new Set([...mySet].filter(x => mySet2.has(x)));

// 求差集
const difference = new Set([...mySet].filter(x => !mySet2.has(x)));

8.字典

  • 与集合类似，字典也是一种存储唯一值的数据结构，但它是以键值对的形式来存储
  • ES6中有字段，名为 Map
  • 字典常用操作：键值对的增删改查
const m = new Map();
// 增
m.set('a','aa'); // Map{ 'a' => 'aa' }
m.set('b','bb');

// 查
m.get('a'); // 'aa'

// 删
m.delete('b');
// m.clear();

// 改
m.set('a','aaa');

// leetCode 349 两个数组的交集
// 输入 nums1 = [1,2,2,1],nums2 = [2,2]
// 输出 [2]
var intersection = function(nums1,nums2){
    const map =  new Map();
    nums1.forEach(n => {
        map.set(n,true)
    });
    const res = [];
    nums2.forEach(n => {
        if(map.get(n)){
            res.push(n);
            map.delete(n)
        }
    })
}

// leetCode 20 有效的括号
// 输入 '()'  输出:true
// 输入 '(){}[]'  输出：true
var isVaild = function(s){
    if(s.length % 2 === 1) return false;
    const stack = [];
    const map = new Map();
    map.set('(',')');
    map.set('[',']');
    map.set('{','}');
    for(let i = 0; i < s.length;i++){
        const c = s[i];
        if(map.has(c)){
            stack.push(c);
        }else{
            const t = stack[stack.length-1];
            if(map.get(t) === c){
                stack.pop()
            }else{
                return false
            }
        }
    }
    return stack.length === 0;
}

// leetCode 1 两数之和
// nums = [2,7,11,15], target = 9
// 因为 nums[0]+nums[1] = 9 返回 [0,1]
var s = function(nums,target){
    const map = new Map();
    for(let i = 0; i < nums.length;i++){
        const n = nums[i];
        const n2 = target - n;
        if(map.has(n2)){
            return [map.get(n2), i]
        }else{
            map.set(n,i)
        }
    }
}

// leetCode 3 无重复字符的最长子串
// 输入 'abcabcbb'
// 输出  3
var lengthOfLongestSubstring = function(s){
    let l = 0;
    let res = 0;
    const map = new Map()
    for(let r = 0; r < s.length; r++){
        if(map.has(s[r]) && map.get(s[r]) >= l){
            l = map.get(s[r]) +1;
        }
        res = Math.max(res, r - l + 1);
        map.set(s[r],r)
    }
    return res;
}

总结

算法知识

海阔凭鱼跃学习笔记
关注
  • 14
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
JavaScript常用基础算法
玖尘的博客
02-18 4279
一、字符串 1.字符串中出现最多次数的字符 function findMaxDuplicateChar(str) { var cnt = {}, // 用来记录所有的字符的出现频次 c = ""; // 用来记录最大频次的字符 for (var i = 0; i < str.length; i++) { var ci = str[i]; if (!cnt[ci]) {
JavaScript算法小集（一）
Small_Dark的博客
04-20 569
最近回顾了一些js相关的趣味算法，又有一些新收获。感觉个人搭建的博客对有代码的文章的格式支持不是很给力1.回文 忽略标点、空格以及大小写，正序和反序字符串相同 function palindrome(str) { var str1 = str.replace(/\W+/g, ''); str1 = str1.replace(/\_+/g, ''); str1 = str1
JavaScript算法 — 二叉树遍历
小绵杨
11-11 2892
和前序遍历思想相反。先序是使用push往res数组后面加数据，二后序是使用unshift往数组前面加数据。先序：“中 - 左 - 右” 0137849256。中序：“左 - 中 - 右” 7381940526。后序：“右 - 左 - 中” 7839415620。调用递归的位置不同，结果分为三种。
关于 Javascript 算法
梁什么鸭“的博客
04-26 1483
Javascript 算法
Javascript算法练习（一）
风起叶落，若是不知，岂会心动！
06-20 1040
Javascript算法练习（一）反转字符串 方法一：split() + unshift() + join()// 将__string反转返回 function myReverse ( __string ) { if ( !__string ) return; var aTarget = __string.split(""), // 将__string分割成单个字符，保存到数
JavaScript 算法题
06-11
学习JavaScript 的基本算法题
javascript算法训练营
05-29
JavaScript算法训练营是一个专注于提升JavaScript开发者算法能力的学习资源。在这个训练营中，参与者将深入学习和实践各种算法，从而提高编程技巧，理解数据结构，并掌握解决复杂问题的方法。JavaScript作为前端开发...
JavaScript前端算法.zip
06-12
本压缩包包含了一系列与JavaScript算法相关的学习资料和代码示例，主要涉及了数据结构如链表、树，以及排序算法等主题。 1. **链表**：在"2链表.js"中，你可以找到关于链表操作的实现，如插入、删除、遍历等。链表...
javascript算法
02-18
JavaScript算法和数据结构 该存储库包含许多流行算法和数据结构的基于JavaScript的示例。 每种算法和数据结构都有自己单独的自述文件，并提供相关说明和链接以供进一步阅读（包括YouTube视频的自述文件）。 用其他...
JavaScript算法和数据结构
09-13
数据结构是在计算机中组织和存储数据的一种特殊方式，以便可以有效地访问和修改数据。更准确地说，数据结构是数据值、它们之间的关系以及可应用于数据的功能或操作的集合...这是基于 JavaScript 的算法和数据结构教程。
算法014：找到字符串中所有字母异位词
m0_62319039的博客
07-14 438
算法014：找到字符串中所有字母异位词
LC53最大子数组和、lc5最长回文子串、lc283移动零
m0_47536537的博客
07-14 203
请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。连续子数组 [4,-1,2,1] 的和最大，为 6。移动到数组的末尾，同时保持非零元素的相对顺序。，必须在不复制数组的情况下原地对数组进行操作。"aba" 同样是符合题意的答案。是数组中的一个连续部分。，编写一个函数将所有。LC53最大子数组和。
树状数组（Binary Indexed Tree, BIT）
qq_73702550的博客
07-12 397
树状数组（Binary Indexed Tree, BIT），也称为 Fenwick Tree，是一种用于高效处理数组前缀和查询和单点更新的数据结构。它能够在 (O(\log n)) 时间内完成单点更新和前缀和查询操作。
代码随想录算法训练营第三十二天
weixin_44791877的博客
07-14 217
这道题自己思考ac出来了，主要是这道题需要使用二维的dp数组进行规划，由于动归是递推的，所以从结果向前思考，因此到右下角的方法只能由右下角这个格子或者左边这个格子走过来，因此右下角这个格子的方法数应该等于上一个格子的方法数加上左边这个格子的方法数。值得注意的是只有一行的或者一列的每个格子都只有1种方法，还有就是多行多列的边界格子也是只有一种方法，这个也是要初始化的。然后初始化边界的时候在障碍物之前的都初始化为1，障碍物以及障碍物之后的都初始化为0；首先几个特殊情况 当障碍物在起点或者终点的话直接返回0；
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
m0_74586426的博客
07-12 954
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
算法刷题笔记 KMP字符串（C++实现，并给出了求next数组的独家简单理解方式）
hanmo22357的博客
07-12 844
一道经典且较难的算法题，给出了C++代码实现，以及自己对next数组求解的独家简单的理解方式。
摩尔投票算法
qq_55846232的博客
07-14 465
摩尔投票算法的介绍以及相关例题的讲解
手撕七大排序(三)
Zbldx的博客
07-14 307
手撕七大排序 （三）
【JavaScript 算法】哈希表：快速查找与存储
最新发布
Allen-
07-15 773
哈希表（Hash Table）是一种非常高效的数据结构，用于实现快速的查找和存储操作。通过使用哈希函数将数据映射到数组中的某个位置，哈希表能够在常数时间内完成插入、删除和查找操作。
Javascript算法
05-05
JavaScript算法是指在JavaScript语言中实现的各种算法。下面是一些常见的JavaScript算法： 1. 快速排序算法：快速排序是一种高效的排序算法，可以用JavaScript实现。它的时间复杂度为O(nlogn)。 2. 归并排序算法：归并排序也是一种高效的排序算法，可以用JavaScript实现。它的时间复杂度为O(nlogn)。 3. 二分查找算法：二分查找是一种常用的查找算法，可以用JavaScript实现。它的时间复杂度为O(logn)。 4. 哈希表算法：哈希表是一种常用的数据结构，可以用JavaScript实现。它的时间复杂度为O(1)。 5. 动态规划算法：动态规划是一种常用的优化算法，可以用JavaScript实现。它的时间复杂度根据具体问题而定。 6. 贪心算法：贪心算法是一种常用的求解最优解的算法，可以用JavaScript实现。它的时间复杂度根据具体问题而定。 7. 广度优先搜索算法：广度优先搜索是一种常用的搜索算法，可以用JavaScript实现。它的时间复杂度为O(|V|+|E|)，其中|V|表示顶点数，|E|表示边数。 8. 深度优先搜索算法：深度优先搜索也是一种常用的搜索算法，可以用JavaScript实现。它的时间复杂度为O(|V|+|E|)，其中|V|表示顶点数，|E|表示边数。 以上是一些常见的JavaScript算法，还有很多其他的算法也可以用JavaScript实现。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值