Javascript常见算法详解

news2024/11/20 21:32:52

在JavaScript（JS）中，常见的算法涵盖了多个领域，从基础的数组操作到更复杂的排序、搜索和数据结构算法。下面是一些在JS中常见的算法示例：

1. 排序算法

Java排序算法-CSDN博客

  • 冒泡排序（Bubble Sort）：通过重复遍历要排序的数列，比较每对相邻元素的值，若发现顺序错误则交换之。应用场景：冒泡排序由于其实现简单，适合小规模数据或基本有序的数据排序。
function bubbleSort(arr) {  
    const len = arr.length;  
    for (let i = 0; i < len - 1; i++) {  
        for (let j = 0; j < len - i - 1; j++) {  
            if (arr[j] > arr[j + 1]) {  
                [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];  
            }  
        }  
    }  
    return arr;  
}  
const nums = [4, 5, 2, 7, 8];  
console.log(bubbleSort(nums)); // [2, 4, 5, 7, 8]
  • 选择排序（Selection Sort）：在要排序的一组数中，选出最小（或最大）的一个数与第一个位置的数交换；然后在剩下的数当中再找最小（或最大）的与第二个位置的数交换，依此类推。应用场景：选择排序同样适合小规模数据的排序。
function selectionSort(arr) {  
    const len = arr.length;  
    for (let i = 0; i < len - 1; i++) {  
        let minIndex = i;  
        for (let j = i + 1; j < len; j++) {  
            if (arr[j] < arr[minIndex]) {  
                minIndex = j;  
            }  
        }  
        [arr[i], arr[minIndex]] = [arr[minIndex], arr[i]];  
    }  
    return arr;  
}  
const nums = [4, 5, 2, 7, 8];  
console.log(selectionSort(nums)); // [2, 4, 5, 7, 8]
  • 插入排序（Insertion Sort）：通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。小规模数据或基本有序的数据。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，找到排序位置后，需要将已排序元素逐步向后挪位，为新元素提供插入空间。

function insertionSort(arr) {  
    for (let i = 1; i < arr.length; i++) {  
        let key = arr[i]; // 当前需要插入的元素  
        let j = i - 1;  
  
        // 将大于key的元素向后移动一位  
        while (j >= 0 && arr[j] > key) {  
            arr[j + 1] = arr[j];  
            j = j - 1;  
        }  
        arr[j + 1] = key; // 插入key到正确的位置  
    }  
    return arr;  
}  
  
// 示例  
const nums = [12, 11, 13, 5, 6];  
console.log(insertionSort(nums)); // 输出: [5, 6, 11, 12, 13]
  • 归并排序（Merge Sort）：分治法的一个典型应用，将已有序的子序列合并，得到完全有序的序列。它将一个数组分成两半，对每半部分递归地应用归并排序，然后将排序好的两半合并成一个有序数组。归并排序的主要优点是稳定、效率高（平均和最坏时间复杂度均为O(n log n)），并且易于实现并行化。
function mergeSort(arr) {  
    if (arr.length < 2) {  
        // 基本情况：如果数组只有一个元素或为空，则直接返回该数组  
        return arr;  
    }  
  
    // 找到中间位置，将数组分成两部分  
    const middle = Math.floor(arr.length / 2);  
    const left = arr.slice(0, middle);  
    const right = arr.slice(middle);  
  
    // 递归地对左右两部分进行归并排序  
    return merge(mergeSort(left), mergeSort(right));  
}  
  
function merge(left, right) {  
    let result = [], leftIndex = 0, rightIndex = 0;  
  
    // 当左右两部分都还有元素时，比较并合并  
    while (leftIndex < left.length && rightIndex < right.length) {  
        if (left[leftIndex] < right[rightIndex]) {  
            result.push(left[leftIndex]);  
            leftIndex++;  
        } else {  
            result.push(right[rightIndex]);  
            rightIndex++;  
        }  
    }  
  
    // 如果左部分还有剩余元素，则将它们添加到结果数组中  
    while (leftIndex < left.length) {  
        result.push(left[leftIndex]);  
        leftIndex++;  
    }  
  
    // 如果右部分还有剩余元素，则将它们添加到结果数组中  
    while (rightIndex < right.length) {  
        result.push(right[rightIndex]);  
        rightIndex++;  
    }  
  
    return result;  
}  
  
// 示例  
const nums = [38, 27, 43, 3, 9, 82, 10];  
console.log(mergeSort(nums)); // 输出: [3, 9, 10, 27, 38, 43, 82]
  • 快速排序（Quick Sort）：是一种高效的排序算法，采用分而治之的策略来把一个序列分为较小和较大的两个子序列，然后递归地排序两个子序列。在JavaScript中，快速排序的实现通常涉及选择一个“基准”元素（pivot），然后将数组分成两个子数组：一个包含所有小于基准值的元素，另一个包含所有大于基准值的元素。最后，递归地对这两个子数组进行快速排序。
    。应用场景：快速排序适用于大规模数据的排序，平均时间复杂度为O(n log n)。
function quickSort(arr) {  
    if (arr.length <= 1) {  
        return arr;  
    }  
    const pivot = arr[0];  
    const left = [];  
    const right = [];  
    for (let i = 1; i < arr.length; i++) {  
        if (arr[i] < pivot) {  
            left.push(arr[i]);  
        } else {  
            right.push(arr[i]);  
        }  
    }  
    return [...quickSort(left), pivot, ...quickSort(right)];  
}  
const nums = [4, 5, 2, 7, 8];  
console.log(quickSort(nums)); // [2, 4, 5, 7, 8]

2. 搜索算法

  • 线性搜索（Linear Search）：逐个检查每个元素，直到找到所需的特定元素为止。
function linearSearch(arr, target) {  
    for (let i = 0; i < arr.length; i++) {  
        if (arr[i] === target) {  
            // 找到目标值，返回其索引  
            return i;  
        }  
    }  
  
    // 未找到目标值，返回-1  
    return -1;  
}  
  
// 示例  
const arr = [3, 5, 7, 9, 11, 13, 15];  
const target = 9;  
console.log(linearSearch(arr, target)); // 输出: 3  
  
const missingTarget = 10;  
console.log(linearSearch(arr, missingTarget)); // 输出: -1
  • 二分搜索（Binary Search）：在有序数组中查找某一特定元素的搜索算法，搜索过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜索过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。

function binarySearch(arr, target) {  
    let left = 0;  
    let right = arr.length - 1;  
  
    while (left <= right) {  
        let mid = Math.floor((left + right) / 2);  
  
        if (arr[mid] === target) {  
            // 找到目标值，返回其索引  
            return mid;  
        } else if (arr[mid] < target) {  
            // 目标值在中间值的右侧，调整左边界  
            left = mid + 1;  
        } else {  
            // 目标值在中间值的左侧，调整右边界  
            right = mid - 1;  
        }  
    }  
  
    // 未找到目标值，返回-1  
    return -1;  
}  
  
// 示例  
const arr = [1, 3, 5, 7, 9, 11, 13, 15, 17, 19];  
const target = 7;  
console.log(binarySearch(arr, target)); // 输出: 3  
  
const missingTarget = 10;  
console.log(binarySearch(arr, missingTarget)); // 输出: -1

3. 数组和字符串操作

  • 反转数组：通过交换首尾元素的方式实现。

反转数组是一个基础且常见的算法问题，可以通过多种编程语言实现。在JavaScript中，我们已经知道有一个内置的reverse()方法可以直接用来反转数组，但如果你想要自己实现一个反转数组的算法，你可以通过交换数组的首尾元素，然后向中心移动，直到到达数组的中间位置。

下面是一个使用JavaScript实现的反转数组算法的例子：

function reverseArray(arr) {  
    let left = 0; // 左指针  
    let right = arr.length - 1; // 右指针  
  
    while (left < right) {  
        // 交换左右指针所指的元素  
        let temp = arr[left];  
        arr[left] = arr[right];  
        arr[right] = temp;  
  
        // 移动指针  
        left++;  
        right--;  
    }  
  
    // 由于是在原数组上进行操作，所以不需要返回新的数组  
    // 但为了演示，我们可以返回原数组或者null，表示操作已完成  
    return arr;  
}  
  
// 示例  
let arr = [1, 2, 3, 4, 5];  
reverseArray(arr);  
console.log(arr); // 输出: [5, 4, 3, 2, 1]

这个算法的时间复杂度是O(n/2)，但通常我们将其简化为O(n)，因为n/2和n在算法分析中属于同一数量级。空间复杂度是O(1)，因为我们只是使用了常量级别的额外空间（几个变量）来执行操作，而没有使用与输入规模成比例的额外空间。

需要注意的是，这个算法直接修改了原数组。如果你不想修改原数组，你可以先复制一份数组，然后在复制的数组上进行反转操作。例如：

function reverseArrayWithoutMutating(arr) {  
    let copy = [...arr]; // 使用扩展运算符创建数组的一份浅拷贝  
    let left = 0;  
    let right = copy.length - 1;  
  
    while (left < right) {  
        let temp = copy[left];  
        copy[left] = copy[right];  
        copy[right] = temp;  
  
        left++;  
        right--;  
    }  
  
    return copy; // 返回反转后的新数组  
}  
  
// 示例  
let arr = [1, 2, 3, 4, 5];  
let reversedArr = reverseArrayWithoutMutating(arr);  
console.log(reversedArr); // 输出: [5, 4, 3, 2, 1]  
console.log(arr); // 输出: [1, 2, 3, 4, 5]（原数组未改变）
  • 字符串去重：使用Set或遍历字符串，利用对象记录字符出现情况，实现去重。
function uniqueCharsInOrder(str) {  
    // 创建一个 Set 对象，用于存储已经遇到的字符  
    let seen = new Set();  
    // 初始化一个空字符串，用于存放去重后的结果  
    let result = '';  
  
    // 遍历原字符串中的每个字符  
    for (let char of str) {  
        // 检查当前字符是否已经在 Set 中  
        if (!seen.has(char)) {  
            // 如果没有，则将其添加到 Set 中，并追加到结果字符串的末尾  
            seen.add(char);  
            result += char;  
        }  
        // 如果字符已经在 Set 中，则跳过它，不添加到结果字符串中  
    }  
  
    // 返回去重后且保持原始顺序的字符串  
    return result;  
}  
  
// 示例  
console.log(uniqueCharsInOrder('hello world!')); // 输出: "helo wrd!"
  • 子字符串搜索：使用indexOf或includes等方法。

indexOf() 方法

indexOf() 方法用于返回在父字符串中首次出现的子字符串的索引，如果没有找到则返回 -1。这个方法对于需要知道子字符串具体位置的场景非常有用。

let str = "Hello, world!";  
let index = str.indexOf("world");  
console.log(index); // 输出: 7  
  
let fromIndex = 8;  
let notFoundIndex = str.indexOf("world", fromIndex);  
console.log(notFoundIndex); // 输出: -1，因为从索引8开始找不到"world"

includes() 方法

includes() 方法用于判断一个字符串是否包含在另一个字符串中，根据情况返回 true 或 false。这个方法对于只需要知道子字符串是否存在，而不需要知道其位置的场景很有用。

let str = "Hello, world!";  
let found = str.includes("world");  
console.log(found); // 输出: true  
  
let notFound = str.includes("universe");  
console.log(notFound); // 输出: false  
  
let fromPosition = 7;  
let foundAtPosition = str.includes("world", fromPosition);  
console.log(foundAtPosition); // 输出: true，即使起始位置是7，"world"依然从该位置开始  
  
// 注意：如果fromIndex大于字符串长度，则includes方法返回false  
let fromIndexTooHigh = str.includes("world", 20);  
console.log(fromIndexTooHigh); // 输出: false

4. 动态规划

  • 斐波那契数列：经典的动态规划问题，每个数是前两个数的和。

  • 最长公共子序列（LCS）：寻找两个序列共有的最长子序列的问题。

5. 图论算法

  • 深度优先搜索（DFS）：沿着树的深度遍历树的节点，尽可能深地搜索树的分支。

  • 广度优先搜索（BFS）：从根节点开始，沿着树的宽度遍历树的节点。

6. 递归算法

递归算法在JS中非常常见，如计算阶乘、遍历文件目录等。

7. 数据结构相关算法

  • 栈和队列的基本操作：如入栈（入队）、出栈（出队）、查看栈顶（队首）等。

  • 链表操作：包括创建链表、添加节点、删除节点、反转链。表等

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1978815.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【C++从小白到大牛】多态那些事儿（上）

【C++从小白到大牛】多态那些事儿（上）

一、多态的概念 1.1概念: 通俗来说&#xff0c;就是多种形态&#xff0c;具体点就是去完成某个行为&#xff0c;当不同的对象去完成时会产生出不同的状态。 二、 多态的定义及实现 2.1多态的构成条件 多态是在不同继承关系的类对象&#xff0c;去调用同一函数&#xff0c;产…
阅读更多...
flutter开发windows应用程序（.exe）配置环境搭建 以及 visual studio配置flutter windows所需环境

flutter开发windows应用程序（.exe）配置环境搭建 以及 visual studio配置flutter windows所需环境

flutter 开发 windows 应用程序&#xff08;.exe&#xff09;配置环境搭建 安装 android studio 开发工具 并配置相关所需环境 参考该文章&#xff1a;我还没写完你上百度上搜一下吧我帮你付钱了&#x1f602; 控制台运行 flutter doctor 命令 查看当前 flutter 开发环境 报…
阅读更多...
傅里叶级数的数学描述

傅里叶级数的数学描述

目录 概述 1 傅里叶级数 1.1 概念 1.2 表示形式 2 傅里叶变换 2.1 概念 2.2 数学描述 2.3 应用 3 傅里叶级数的数学推论 3.1 三角函数的正交性 3.1.1 正交性介绍 3.1.2 正交性证明 3.1.3 相同函数乘积积分 3.2 理论介绍 3.3 傅里叶级数的表述 概述 傅里叶级数是…
阅读更多...
sais复杂推理能力评估笔记（一）：baseline简介

sais复杂推理能力评估笔记（一）：baseline简介

赛题流程 初赛数据集为逻辑推理数据&#xff0c;其中训练集中包含500条训练数据&#xff0c;测试集中包含500条测试数据。每个问题包括若干子问题&#xff0c;每个子问题为单项选择题&#xff0c;选项不定&#xff08;最多5个&#xff09;。目标是为每个子问题选择一个正确答案…
阅读更多...
前端需要了解的数据库基础与身份认证

前端需要了解的数据库基础与身份认证

目录 数据库与身份认证数据库的基本概念常见数据库和分类传统型数据库的数据组织结构安装并配置MySQL MySQL的基本使用使用SQL管理数据库SQL中的SELECT语句SQL中的INSERT INTO语句SQL中的UPDATE语句SQL中的DELETE语句SQL中的WHERE子句SQL中的AND和OR运算符SQL中的ORDER BY子句S…
阅读更多...
Pip 使用报错及解决

Pip 使用报错及解决

pip install 是Python 包管理器命令&#xff0c;常用参数&#xff1a; -r&#xff1a;从一个需求文件中安装所有的包。-U 或 --upgrade&#xff1a;升级一个已经安装的包到最新版本。-I 或 --ignore-installed&#xff1a;即使包已经安装&#xff0c;也重新安装。--no-cache-d…
阅读更多...
奥运会Ⅴ--具有混合模型的 Transformer 架构

奥运会Ⅴ--具有混合模型的 Transformer 架构

Transformer 架构的变革性影响和混合模型的未来&#xff0c;将 Transformer 与其他架构相结合&#xff0c;突破 AI 能力的界限。 Transformer 架构从根本上重塑了自然语言处理 (NLP) 和机器学习的格局。这种序列建模和传导任务的创新方法不仅超越了之前最先进的模型&#xff0c…
阅读更多...
每日OJ_牛客WY15 幸运的袋子

每日OJ_牛客WY15 幸运的袋子

目录 牛客HJ62 查找输入整数二进制中1的个数 解析代码 牛客HJ62 查找输入整数二进制中1的个数 查找输入整数二进制中1的个数_牛客题霸_牛客网 解析代码 本题是计算一个数二进制表示中1的个数&#xff0c;通过&#xff08;n >> i) & 1可以获取第i位的二进制值&…
阅读更多...
阿里云文件上传之客户端上传

阿里云文件上传之客户端上传

阿里云文件上传之前一直是使用服务端上传,但一直存在上传不稳定问题,三兆以上的文件上传经常出现上传超时问题.究其原因客户端将文件上传到业务服务器&#xff0c;然后业务服务器将文件上传到OSS。在这个过程中&#xff0c;一份数据需要在网络上传输两次&#xff0c;会造成网络…
阅读更多...
Vuforia AR篇（九）— AR塔防下篇

Vuforia AR篇（九）— AR塔防下篇

目录 前言一、搭建UI二、创建脚本 前言 在增强现实&#xff08;AR&#xff09;技术快速发展的今天&#xff0c;Vuforia作为一个强大的AR开发平台&#xff0c;为开发者提供了许多便捷的工具和功能。在本篇博客中&#xff0c;我们将介绍如何使用Vuforia在Unity中创建一个简单的塔…
阅读更多...
46 class添加与颜色分配47 区域规则介绍与添加48 走线修线介绍49 复制、改变、删除操作

46 class添加与颜色分配47 区域规则介绍与添加48 走线修线介绍49 复制、改变、删除操作

46 class添加与颜色分配&&47 区域规则介绍与添加&&48 走线修线介绍&&49 复制、改变、删除操作 第一部分 46 class添加与颜色分配创建网络类CLS创建网络组net-group NG颜色分配**填充类型设置****高亮关闭****修改颜色面板的颜色**从其它已有PCB设计中导…
阅读更多...
用Manim实现——计算和绘制图形下方区域

用Manim实现——计算和绘制图形下方区域

用Manim实现——计算和绘制图形下方区域 get_area 函数 get_area是一个用于计算和绘制图形下方区域的函数&#xff0c;常用于图形动画库&#xff08;如 Manim&#xff09; get_area(graph, x_rangeNone, color(ManimColor(#58C4DD),ManimColor(#83C167)), opacity0.3, bounde…
阅读更多...
市场主流 AI 视频生成技术的迭代路径

市场主流 AI 视频生成技术的迭代路径

AI视频生成技术的迭代路径经历了从GANVAE、Transformer、Diffusion Model到Sora采用的DiT架构&#xff08;TransformerDiffusion&#xff09;等多个阶段&#xff0c;每个阶段的技术升级都在视频处理质量上带来了飞跃性的提升。这些技术进步不仅推动了AI视频生成领域的快速发展&…
阅读更多...
大载重无人机必备：适航证技术详解

大载重无人机必备：适航证技术详解

随着无人机技术的飞速发展&#xff0c;大载重无人机在物流运输、农业植保、应急救援等领域展现出巨大潜力。然而&#xff0c;为确保这些无人机在空中运行的安全性与高效性&#xff0c;获取适航证成为不可或缺的关键步骤。本文将深入探讨大载重无人机适航证的必备要素&#xff0…
阅读更多...
用phpstudy搭建MySQL数据库

用phpstudy搭建MySQL数据库

使用环境&#xff1a;win11 使用软件&#xff1a;phpstudy 下载地址&#xff1a;小皮面板(phpstudy) - 让天下没有难配的服务器环境&#xff01; MySQL数据库搭建步骤&#xff1a; 1、在小皮的设置界面检测 3306 端口&#xff0c;保障 3306 端口可用&#xff1b; 2、在小皮…
阅读更多...
42 PCB布线叠层与阻抗介绍43 PCB布线过孔添加与设置44 差分对添加与设置45 布线间距规则与介绍

42 PCB布线叠层与阻抗介绍43 PCB布线过孔添加与设置44 差分对添加与设置45 布线间距规则与介绍

42 PCB布线叠层与阻抗介绍&&43 PCB布线过孔添加与设置&44 差分对添加与设置&&45 布线间距规则与介绍 第一部分 42 PCB布线叠层与阻抗介绍1 板子是怎么来的。2 四层板为例&#xff0c;做叠层和阻抗计算。 第二部分 43 PCB布线过孔添加与设置介绍PCBEdotor中…
阅读更多...
STM32F28335实验：蜂鸣器实验

STM32F28335实验：蜂鸣器实验

实验三个文档&#xff1a; 蜂鸣器驱动&#xff1a; 1.5KHZ-5KHZ之间&#xff0c;我们取5KHZ 也就是高低点平各100um&#xff0c;周期为200um的方波 LED1还是GPIO68管脚 蜂鸣器管脚GPIO6 蜂鸣器驱动&#xff1a; beep.c /** heep.c** Created on: 2024年8月4日* Au…
阅读更多...
Studying-代码随想录训练营day54| 110.字符串接龙、105.有向图的完全可达性、106.岛屿的周长

Studying-代码随想录训练营day54| 110.字符串接龙、105.有向图的完全可达性、106.岛屿的周长

第53天&#xff0c;图论04&#xff0c;加强广搜和深搜的理解练习&#x1f4aa;(ง •_•)ง&#xff0c;编程语言&#xff1a;C 目录 110.字符串接龙 105.有向图的完全可达性 106.岛屿的周长 总结 110.字符串接龙 文档讲解&#xff1a;手撕字符串接龙 题目&#xff1a;110…
阅读更多...
黑马Java零基础视频教程精华部分_12_面向对象进阶(4)_内部类

黑马Java零基础视频教程精华部分_12_面向对象进阶(4)_内部类

《黑马Java零基础视频教程精华部分》系列文章目录 黑马Java零基础视频教程精华部分_1_JDK、JRE、字面量、JAVA运算符 黑马Java零基础视频教程精华部分_2_顺序结构、分支结构、循环结构 黑马Java零基础视频教程精华部分_3_无限循环、跳转控制语句、数组、方法 黑马Java零基础视…
阅读更多...
【九】Hadoop3.3.4HA高可用配置

【九】Hadoop3.3.4HA高可用配置

文章目录 1.高可用基本原理1.NameNode 高可用性主备 NameNodeJournalNode 2.Zookeeper 协调3.Quorum Journal Manager (QJM)4.Failover 控制器5.元数据共享6.检查点机制7.切换过程 2.Hadoop高可用配置1.环境背景2.hdfs-site.xml基本配置高可用配置 3.core-site.xml基本配置代理…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023