Javascript基本算法

原始未排序的数组

const unsortedArray = [3, 1, 4, 1, 5, 9, 2, 6, 7, 8, 9, 10, 5, 9, 9, 9, 9, 3, 5];

快速排序算法，用于对数组进行排序

function quickSort(array) {
    // 如果数组长度小于等于1，直接返回该数组，因为已经是有序的
    if (array.length <= 1) {
        return array;
    }

    // 选择数组的第一个元素作为基准值
    let pivot = array[0];
    let lesser = [];
    let greater = [];

    // 遍历数组中的其他元素，将小于基准值的元素放入 lesser 数组，大于基准值的元素放入 greater 数组
    for (let index = 1; index < array.length; index++) {
        if (array[index] < pivot) {
            lesser.push(array[index]);
        } else if (array[index] > pivot) {
            greater.push(array[index]);
        }
    }

    // 递归排序 lesser 数组和 greater 数组，并与基准值合并返回
    return [...quickSort(lesser), pivot, ...quickSort(greater)];
}

// 对未排序的数组进行快速排序
// const sortedArray = quickSort(unsortedArray);
// console.log(sortedArray);

二分查找算法（要求数组已排序）

function binarySearch(array, target) {
    let left = 0;
    let right = array.length - 1;

    // 在左指针小于等于右指针的情况下，进行查找
    while (left <= right) {
        const mid = Math.floor((left + right) / 2);
        if (array[mid] === target) {
            return mid; // 找到目标元素，返回索引
        } else if (array[mid] < target) {
            left = mid + 1; // 目标元素在右侧，调整左指针
        } else {
            right = mid - 1; // 目标元素在左侧，调整右指针
        }
    }

    return -1; // 没有找到目标元素
}

// 在已排序的数组中查找目标元素的索引
// const targetIndex = binarySearch(sortedArray, 10);
// console.log(targetIndex);

求解斐波那契数列–从第三项开始，每个数等于前两个数的和//-- 1、1、2、3、5、8、13、21、34、……，

// 定义一个函数来计算第 n 个斐波那契数
function fibonacci(n) {
    // 如果 n 小于等于 1，则直接返回 n
    if (n <= 1) {
        return n;
    }

    // 创建一个数组 dp 来存储斐波那契数列的值
    const dp = new Array(n + 1);
    dp[0] = 0; // 第 0 个斐波那契数是 0
    dp[1] = 1; // 第 1 个斐波那契数是 1

    // 从第 2 个数开始计算斐波那契数列，使用动态规划的思想
    for (let i = 2; i <= n; i++) {
        // 当前数等于前两个数之和
        dp[i] = dp[i - 1] + dp[i - 2];
    }

    // 返回第 n 个斐波那契数
    return dp[n];
}

// 要计算的斐波那契数的位置
// const position = 6;

// 调用 fibonacci 函数计算第 position 个斐波那契数
// const result = fibonacci(position);

// console.log(`斐波那契数列第 ${position} 个数是：`, result);

判断是否为素数的函数

// 定义一个函数来判断一个数字是否为素数
function isPrime(num) {
    // 如果数字小于等于1，则不是素数，直接返回false
    if (num <= 1) {
        return `${num} 不是素数。`;
    }
    // 循环从2开始，一直到num的平方根
    // 因为如果num有大于平方根的因子，那么一定有小于平方根的因子，可以减少循环次数
    for (let i = 2; i <= Math.sqrt(num); i++) {
        // 如果num能够被i整除，说明有除了1和num本身以外的因子，不是素数，返回false
        if (num % i === 0) {
            return `${num} 不是素数。`;
        }
    }
    // 如果没有找到能整除num的因子，那么num是素数，返回true
    return `${num} 是素数。`;
}

定义函数以找到数组中的最大值

function maxarr(DataArr) {
    // 初始化最大值为数组的第一个元素
    let max = DataArr[0];
    // 遍历数组中的每个元素
    for (let index = 0; index < DataArr.length; index++) {
        const element = DataArr[index];
        // 如果当前元素大于当前最大值，则更新最大值
        if (element > max) {
            max = element;
        }
    }
    // 返回计算出的最大值
    return max;
}

定义函数以找到数组中的最小值

function minarr(DataArr) {
    // 初始化最小值为数组的第一个元素
    let min = DataArr[0];
    // 遍历数组中的每个元素
    for (let index = 0; index < DataArr.length; index++) {
        const element = DataArr[index];
        // 如果当前元素小于当前最小值，则更新最小值
        if (element < min) {
            min = element;
        }
    }
    // 返回计算出的最小值
    return min;
}