JavaScript之算法设计思想

最新推荐文章于 2024-06-18 15:18:41 发布

啊a阿花

最新推荐文章于 2024-06-18 15:18:41 发布

阅读量1.3k

点赞数 5

分类专栏：数据结构文章标签：算法 javascript 数据结构

本文为博主原创文章，未经博主允许禁止转载，转载请注明出处！

本文链接：https://blog.csdn.net/aaahuahua/article/details/120984524

版权

数据结构专栏收录该内容

8 篇文章 0 订阅

订阅专栏

数据结构和算法

1️⃣排序算法

一、冒泡排序

比较所有相邻的元素，如果第一个比第二个大，则交换他们的位置
一轮比较可以保证最后一个数是最大的，然后继续遍历剩余的数
代码实现

const arr = [5,4,3,7,0,2,1]
let temp = 0;
//执行arr.length-1次数组中冒泡的过程
for(let i = 0; i < arr.length -1; i++){
	//遍历整个数组，将数组中最小的一个移动到数组最后面
	//因为每一轮循环后，都是将数组中最小的移动到后面，所以arr.length-i，数组末尾已经是最小元素就不再遍历了
    for(let j = 0; j < arr.length - i; j++){
    //将如果相邻元素中，第一个比第二个大，则第一个元素向后移
        if(arr[j]>arr[j+1]){
            temp = arr[j+1];
            arr[j+1] = arr[j];
            arr[j] = temp
        }
    }
}

二、选择排序

找到未排序的数组中的最小值，将他和第一位互换位置
找到未排序数组中第二小的值，选中并将其放置在第二位
执行n-1轮后得到的就是一个升序数组
代码实现

const arr = [5,4,3,7,0,2,1]
let temp = 0;
//执行arr.length-1次选择
for(let i = 0; i < arr.length - 1; i++){
	//遍历整个数组
	//一轮循环数组中最小的元素保证在第一位。后续循环以此类推
	//所以每一轮循环结束，数组前面都是交换出来的最小值
	//使j=i,可以在后续遍历中忽略前面已经确认的较小值
    for( let j = i; j < arr.length - 1; j++){
    //如果数组中存在元素小于第一位，则两者互换位置-
        if(arr[j] > arr[j+1]){
            temp = arr[j+1];
            arr[j+1] = arr[i];
            arr[i] = temp
        }
   
    }    
}

三、插入排序

从第二个数开始往前比
遇到大于自己的就将其（大值）位置向后移一位，小于自己的就插入到这个值后面
以此类推执行n-1次


const arr = [0,5,2,6,1,9]
//因为是从第二位开始比所以i=1开始
for(let i = 1; i < arr.length; i++){
    let temp = arr[i];
    let j = i;
    while( j > 0){
        if( arr[j-1] > temp ){
            //将大于当前元素的值向后移
            arr[j] = arr[j-1]
        }
        //当前元素大于前面元素时跳出循环，比较下一位
        //这里break跳出的是while循环，因为前面的元素比较过了，都是有序的数组，所以当arr[j-1] < temp是可以判断temp比之前所有的元素都大，跳出本次循环即可
        else break;
        // j-=1如果放在if前面，当前元素大于前面值时arr[j] = temp依然会将当前元素插入到前面的位置
        //而放在后面break跳出循环j-=1没有执行，相当于arr[j] = arr[j],插入操作值未改变
        j -= 1;
    }
//交换元素位置（此时j已经执行了-1操作），如果是通过break跳出来的，实际上j并未发生改变，arr[j] = temp相当于给自身赋值
    arr[j] = temp;
}
//console.log(arr)

四、归并排序

分：把数组从中间分成两半，在不断递归的对数组进行“分”的操作，直到分成一个个只存在单独数的数组
合：把不能再分的两个数组合并为有序数组，然后再对有序数组进行合并，直到全部子数组合并为一个完整的数组

合并方法：

新建一个空数组res用于存放最终排序后的数组
比较两个有序数组的头部·，较小者出队（将拆分后的数组视为为队列）并推入res数组中
如果数组还有值就重复一二步操作

代码实现

const merge = (arr) => {
    // 如果数组长度为1,相当于不能再拆分时返回这些单个数组
    if(arr.length === 1) {return arr;}
    // 获取数组的中间值
    const mid = Math.floor(arr.length / 2)
    // 将数组从中间拆分成开，记为左右新两个数组
    const left = arr.slice(0,mid)
    const right = arr.slice(mid,arr.length)

    // 递归拆分
    const orderLeft = merge(left)
    const orderRight = merge(right)
    let res = []
    //当拆分后的数组不为空时
    while(orderLeft.length || orderRight.length){
        // 如果拆分后左右都存在就比较头元素的大小
        if(orderLeft.length && orderRight.length){
            // 将头元素较小的取出然后加到res数组中
            res.push(orderLeft[0] < orderRight[0] ? orderLeft.shift() : orderRight.shift())
            // 拆分后只有左边数组存在
        }else if(orderLeft.length){
            res.push(orderLeft.shift())
            // 拆分后只有右边数组存在
        }else if(orderRight.length){
            res.push(orderRight.shift())
        }
    }
    return res;
}
const arr = [1,4,3,9,2]
console.log(merge(arr))

五、快速排序

分区：从数组中任意选择一个基准，比基准大的元素放在基准后面，比基准小的元素放在基准前面
递归：分区后得到的数组左边都比基准值小，右边都比基准值大。然后递归的对基准值前后的子数组再进行分区

代码实现

const fastSort = (arr) => {
    if(arr.length === 0) {return arr;}
    // 定义左右两个数组，大于基准的放右边数组，小于基准的放左边基准
    const left = []
    const right = []
    // 基准是随机挑选的一个数
    const stand = arr[0]
    // 因为数组第一个数被挑出来作为基准了，所以这里i从1开始
    for(let i = 1; i < arr.length; i++){
        if(arr[i] < stand){
            left.push(arr[i])
        }else{
            right.push(arr[i])
        }
    }
    // 这里左数组、右数组、基准为三个独立的部分。需要将三者合成一个数组
    //...是ES6中新增的扩展运算符，数组中的扩展运算符(…)用于取出参数数组中的所有可遍历属性，拷贝到当前数组之中。
    return [...fastSort(left),stand,...fastSort(right)]
}
const arr = [1,4,0,3,7]
console.log(fastSort(arr))

但是其实这种快速排序方法是错误的，虽然也是利用快速排序的原理左右分区然后递归，但是使用了两个数组，空间复杂度增加

下面因该是比较贴切一点的快速排序，可以使用console.time()方法来测试一下排序用时

// 计算程序执行时间
console.time('a')
// 函数传入三个参数，依次是：待排序的数组，待排序数组左边第一个元素的索引，待排序元素右边得第一个元素的索引
const fastSort = (arr,began,end) => {  
    // 取数组的第一个元素为基准值
    let print = arr[began]
    //如果不定义i,j 直接改变began,end的值,会影响后面递归开始和结束的索引值
    let i = began;
    let j = end;
    //当左边的索引值大于右边的时,说明本轮排序结束
    if(began >= end) {
        // 将本轮排序后的数组返回
        return arr
    }
    //把所有比基准值小的元素放在基准值左边,大的元素放在基准值右边
    while(i < j){
        // 从后往前查找到比基准值小的元素交换
        //继续判断i<j是因为：如果print值较小,arr[j]>print会持续成立，导致j<=i,索引j<=i表示整个数组已经排序结束
        while(arr[j] >= print && i < j){
            j--
        }
        // 比基准值小的元素放左边,如果不存在比基准值小的元素,此时j=i相当于自身给自身赋值
        arr[i] = arr[j] 
        // 找到比基准值大的元素交换
        // 继续判断i<j，因为print值较大时，arr[i] <= print会持续成立，导致j<=i
        while(arr[i] <= print && i < j){
            i++
        }
        // 比基准值大的元素放在右边,如果不存在比基准值大的元素,此时i=j相当于自身给自身赋值
        arr[j] = arr[i]       
    }
    //一次循环结束,将基准值放在中间位置（此时i=j，arr[i]或者arr[j]都可以）
    arr[j] = print
    //递归,继续对基准值左右两边的数组进行排序
    // 这里began不能直接传入0，会影响到第三轮之后的递归，
    // 因为对基准值右边的数组再进行分区排序时也会使用到began，而此时began并不是0
    fastSort(arr,began,j-1)
    fastSort(arr,j+1,end)
    //返回排序后的数组
    return arr
}	 	  
const arr = [9,5,1,4,8]
console.log(fastSort(arr,0,arr.length-1))
console.timeEnd('a')

之所以从右边开始排序，是因为基准值选择的是最左边，举个例子7 1 2 3 4执行快速排序，假如从左开始排，就会出现1，7，2，3，4

附：这里有一个25w个数据的乱序数组（有重复），可以用来测试这些排序算法的速度 https://download.csdn.net/download/aaahuahua/34715763

2️⃣查找方法

搜索：js中通常使用indexOf方法（返回元素在数组中的下标，不存在返会-1）

一、顺序查找

遍历数组
找到和目标值相等的元素，返回下标
遍历所有值后如果没有目标值返回-1

代码实现

// 在Array数组原型上添加一个方法
Array.prototype.searchWay = function (item){
// this指代这个数组
    for(let i = 0; i < this.length; i++){
        if(item === this[i]){
            return i
        }
    }
    return -1
}
const arr = [1,3,5,2,9]
//调用searchWay方法
console.log(arr.searchWay(5))

二、二分查找

前提： 查找的是有序数组

如果是一个无序数组，需要先将其化为有序数组之后再进行二分搜索

搜索方法

从中间元素开始，如果正好是目标值，则搜索结束
如果目标值小于或者大于中间元素，则在大于或者小于目标值的部分数组中继续进行搜索

// 在数组的原型上添加一个search方法
Array.prototype.search = function (item){4
    // 定义查找的起始位置和结束位置
    let low = 0;
    let height = this.length - 1;
    // 等于号用于判断数组中只剩下最后一个数时，是否为目标值
    while(low <= height){
        // 选取数组中间元素为基准值
        let mid = Math.floor((low + height) / 2);
        const num = this[mid]
        // 如果目标值就是基准值则返回基准值的下标
        if(item === num){    
            return console.log(mid)
        }else if(item > num){ //当目标值大于基准值时，将查找范围缩小为基准值右边的数组
            low = mid + 1
        }else if(item < num ){//当目标值小于基准值时，将查找范围缩小为基准值左边的数组
            height = mid - 1
        }
    }
    // 查找结束后如果还是没有找到目标元素，则返回该元素不存在
    return console.log("该元素不存在")
}
//调用数组原型上的search方法
const arr = [1,2,3,4,5].search(0)

3️⃣算法设计思想

一、动态规划

将一个问题分解成相互重叠的子问题，通过反复求解子问题，来解决原来的问题

步骤：

定义子问题
循环执行子问题中定义的公式

实战练习

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
注意：给定 n 是一个正整数。

输入： 3
输出： 3
解释：有三种方法可以爬到楼顶。
1 阶 + 1 阶 + 1 阶
1 阶 + 2 阶
2 阶 + 1 阶

动态规划

定义子问题，到达第n阶可以有两种方法
（1）从第n-1阶爬一阶
（2）从第n-2阶爬两阶

所以到达第n阶的方法就是到达第n-1阶的方法加上到达第n-2阶方法之和:F(n)=F(n-1)+F(n-2)

从n=2开始循环执行F(n)=F(n-1)+F(n-2)

代码实现


var climbStairs = function(n) {
//当阶数小于2，也就是1阶时，直接返回1（n为正整数所以不存在复数的情况）
    if(n<2) return 1;
//定义数组dp存放到达每一阶的方法数，下标代表阶数，对应值为到达改阶的方法数
//虽然这里0阶定义的是1，但是n为正整数，不会存在n=0的情况
    const dp = [1,1];
//因为前两次已经被列举出来了，所以i从2开始
    for(let i = 2;i <= n; i++){
        dp[i]=dp[i-1]+dp[i-2]
    }
    return dp[n]
};

//代码优化，因为定义了数组，所以空间复杂度为O(n),可以只定义两个变量将复杂度降到O(1)
var climbStairs = function(n) {
    if(n<2) return 1;
    const dp0 = 1;
    const dp1 = 1;
    for(let i = 2;i <= n; i++){
    //临时存储到达第n-2阶的方法
        const temp = dp0;
        dp0 = dp1;
        dp1 = temp + dp1;
    }
    return dp1;
};

二、分而治之

将原问题分为很多个相似的小问题，递归的解决这些小问题，然后再将结果合并以解决原有的问题

1. 设计案例之归并排序

分：将数组一分为二
解：递归的对两个子数组进行归并排序
合：合并有序数组（将递归后长度为1的数组合并成有序数组，然后再把这些有序数组继续合并）

2. 设计案例之快速排序

分：选择基准值将原数组分成大于基准值和小于基准值的两个数组
解：递归的对两个子数组进行快速排序
合：递归到数组中只剩下一个·元素时排序完毕，返回该数组即可

实战练习

猜数字游戏的规则如下：

每轮游戏，都会从 1 到 n 随机选择一个数字。请你猜选出的是哪个数字。如果你猜错了，我会告诉你，你猜测的数字比我选出的数字是大了还是小了。

你可以通过调用一个预先定义好的接口 int guess(int num) 来获取猜测结果，返回值一共有 3 种可能的情况（-1，1 或 0）：

-1：选出的数字比你猜的数字小 pick < num
1：选出的数字比你猜的数字大 pick > num
0：选出的数字和你猜的数字一样。恭喜！你猜对了！pick == num 返回选出的数字。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/guess-number-higher-or-lower

示例 1：输入：n = 10, pick = 6 输出：6
示例 2：输入：n = 1, pick = 1 输出：1
示例 3：输入：n = 2, pick = 1 输出：1
示例 4：输入：n = 2, pick = 2 输出：2

解题思路：

使用二分搜索，分，解，和，利用分而治之的思想来做

分：计算中间元素，分割数组
解：递归的在较大的或者较小的数组中进行二分搜索
合：这一步可以省略，因为如果在子数组中搜索到目标值后就直接将其返回了

代码实现：

var guessNumber = function(n) {
//这里定义一个二分查找的函数
    const divide = (low,height) => {
    //当最小值大于最大值时直接return
        if(low > height) return;
        //取两个数的中间值
        const mid = Math.floor((low+height)/2);
        //调用接口判断猜测结果是否正确
        const res = guess(mid);
        if(res === 0 ){
            return mid
        }else if(res === -1){
        //猜测结果小于真实值
            return divide(1,mid-1)
        }else if(res === 1 ){
        //猜测结果大于真实值
            return divide(mid+1,height)
        }
    }
    return divide(1,n)
};

对称二叉树

给定一个二叉树，检查它是否是镜像对称的。

例如，二叉树 [1,2,2,3,4,4,3] 是对称的。
在这里插入图片描述
但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:

来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/symmetric-tree

解题思路：

可以转换为左右子树是否为镜像的，然后分解为树1的左子树和树2的右子树是否为互为镜像，树1右子树和树2的左子树是否为互为镜像

代码实现：

var isSymmetric = function(root) {
//如果二叉树为空，返回为true
  if(!root) return true;
  //定义一个镜像判断函数
  const isCheck = (left,right) => {
  //如果左右子树都不存在，返回为true
      if(!right && !left){
          return true
      }
      //左右子树存在，值相等，递归左右子节点
      if(right && left && right.val === left.val &&
        isCheck(left.left,right.right) &&
        isCheck(left.right,right.left)
      ){
          return true
      }
      //其他情况下返回false
      return false
  }
    return isCheck(root.left,root.right)
};

三、贪心算法

期盼通过每个阶段的局部最优选择，从而达到全局的最优。但是结果有可能并不是最优的

分发饼干

假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。

对每个孩子 i，都有一个胃口值 g[i]，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j，都有一个尺寸 s[j] 。如果 s[j] >= g[i]，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。

来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/assign-cookies

示例1：

输入: g = [1,2,3], s = [1,1]
输出: 1
解释: 你有三个孩子和两块小饼干，3个孩子的胃口值分别是：1,2,3。
虽然你有两块小饼干，由于他们的尺寸都是1，你只能让胃口值是1的孩子满足。所以你应该输出1。

示例2：

输入: g = [1,2], s = [1,2,3]
输出: 2
解释:
你有两个孩子和三块小饼干，2个孩子的胃口值分别是1,2。
你拥有的饼干数量和尺寸都足以让所有孩子满足。
所以你应该输出2.

解题思路：

局部最优：分发的饼干既能满足孩子，还消耗最少，即先将较小的饼干分给胃口小的孩子

解题步骤：

对饼干数组和胃口数组进行升序排序
遍历饼干数组，找到能满足第一个孩子（胃口最小的孩子）的饼干
继续遍历饼干数组，找到剩下能满足第二、第三、第四…个孩子的饼干

代码实现：

var findContentChildren = function(g,s) {
//快速排序
    const fastSort = (arr,began,end) => {
        let print = arr[began]
        let i = began;
        let j = end;
        if(began >= end){
            return arr;
        }
        while(i < j){
            while(arr[j] >= print && i < j){
                j--
            }
            arr[i] = arr[j]
            while(arr[i] <= print && i < j){
                i++
            }
            arr[j] = arr[i];
        }
        arr[j] = print;
        fastSort(arr,began,j-1)
        fastSort(arr,j+1,end)
        return arr
    } 
    //对小孩的胃口和饼干尺寸两个数组进行排序
    fastSort(s,0,s.length-1)
    fastSort(g,0,g.length-1)
    //定义能满足的小孩个数
    let i = 0;
    //遍历所有饼干
    s.forEach(item =>{
    //如果饼干尺寸大于小孩的胃口，能满足的小孩数加1
        if(item >= g[i]){
            i+=1
        }
    })
    //返回满足的小孩个数
    return i
};

四、回溯算法

一种渐进式寻找并构建问题解决方式的策略，即从一个可能的情况开始解决问题，如果不行，就回溯到另一种情况，直到问题被解决（也可以理解为暴力破解）

回溯思路

使用递归模拟出所有的情况
遇到不满足条件的情况就回溯
收集所有能到达递归终点的情况，并返回

实战练习

全排列规则如下：

给定一个不含重复数字的数组 nums ，返回其所有可能的全排列。你可以按任意顺序返回答案。

示例 1：

输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

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

示例 3：
输入：nums = [1]
输出：[[1]]

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

代码实现

var permute = function(nums) {
	//定义结果集
    let res = []
    //定义已排列结果
    let way = []
    //used（标记数组），用于记录当前该元素是否已经被添加到已排列数组（way）中了
    const backtrack = (arr,used) =>{
    //递归结束条件，当已排列数组的长度等于原数组长度时，表明所有元素都已经被添加到已排列数组中了
        if(way.length === arr.length) {
            //将本次排列的结果添加到结果集中
            res.push([...way])
            return;
        }
        // 遍历数组
        for(let i = 0; i < arr.length; i++){

    // if(way.indexOf(arr[i]) != -1)
    //  不使用这个方法是因为查找的时间复杂度为O(n)，同样的引入used数组会增加空间复杂度也是O(n)

            // undefind转换为布尔值是false
            if(used[i])  // 判断该元素是否已经存在于已排列数组中
            continue;
            //向结果集中添加元素
            way.push(arr[i])
            //标记该元素为已添加，使下一层遍历能够区分哪些元素是未排列的剩余元素
            used[i] = true
            // 递归遍历数组，递归遍历arr.length次就可以将数组中的元素全部添加到排列数组中
            backtrack(arr,used)
            // 这个是本次全排列中回溯的重要体现
            // 使用pop方法删除已经添加到排列数组中的元素，可以使排列过程回到上一层递归
            way.pop()
            // 删除已经添加到排列数组中的元素标记
            used[i] = false
        }    
    }
    backtrack(nums,[])
    return res
};

子集规则如下

给你一个整数数组 nums ，数组中的元素互不相同。返回该数组所有可能的子集（幂集）。
解集不能包含重复的子集。你可以按任意顺序返回解集。

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

示例 2：
输入：nums = [0]
输出：[[],[0]]

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

代码实现

const subsets = (nums) => {
    const res = [];
    const sun = (index, temp) => {
      if (index == nums.length) { // 索引等于数组长度时
        res.push(temp.slice());   // 加入解集
        return;                   // 结束当前的递归
      }
      temp.push(nums[index]); // 将该元素加入数组
      sun(index + 1, temp);   // 往下递归，添加剩余元素
      temp.pop();             // 上面的递归结束，逐步删除已经添加过的元素
      // 删除已添加的元素后，将剩余结果加入结果集；操作剩余元素
      sun(index + 1, temp);   
    };
    sun(0, []);
    return res;
  };