第8章算法设计与分析

爱吃蛋炒饭加蛋

已于 2022-11-02 08:54:18 修改

阅读量366

点赞数

分类专栏：软件设计师考试文章标签：软件设计师

于 2022-10-08 21:39:18 首次发布

本文链接：https://blog.csdn.net/qq_27104997/article/details/127216970

版权

软件设计师考试专栏收录该内容

12 篇文章 0 订阅

订阅专栏

排序算法

冒泡排序

💧算法思想：判断两个相邻元素，大于则交换位置

🌀算法步骤
1，从数组中第一个数开始，依次与下一个数比较并次交换比自己小的数，直到最后一个数。如果发生交换，则继续下面的步骤，如果未发生交换，则数组有序，排序结束。
2，每一轮”冒泡”结束后，最大的数将出现在乱序数列的最后一位。重复步骤（1）
🌊复杂度
时间复杂度(平均): O(n²)
时间复杂度(最坏) : O(n²)
时间复杂度 (最好) : O(n)
空间复杂度: O(1)

在这里插入图片描述

 function sortArr(arr) {
        //外层循环，控制趟数，每一次找到一个最大值
        for (var i = 0; i < arr.length; i++) {
            // 内层循环,控制比较的次数，并且判断两个数的大小  -i 是因为每找到一个最大数 后面就不需要在比较了
            for (var j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    var temp = arr[j]
                    arr[j] = arr[j + 1]
                    arr[j + 1] = temp
                }
            }
        }
        return arr
    }

插入排序

💧 算法思想：从待排序的n个记录中的第二个记录开始，依次与前面的记录比较并寻找插入的位置，每次外循环结束后，将当前的数插入到合适的位置。
🌊复杂度
时间复杂度(平均): O(n²)
时间复杂度(最坏) : O(n²)
时间复杂度 (最好) : O(n)
空间复杂度: O(1)
在这里插入图片描述

function insertion_sort(arr) {
        for (var i = 1; i < arr.length; i++) {
            var key = arr[i];
            var j = i - 1;
            while (arr[j] > key) {
                arr[j + 1] = arr[j];
                j--;
            }
            arr[j + 1] = key;
        }
        return arr;
    }

快速排序法
💧 算法思想：取一个基准值，比基准值小的在左边，大的在右边；左右在继续这样的操作，最后合并。
🌀算法步骤：
从待排序的n个记录中任意选取一个记录（通常选取第一个记录）为分区标准;
把所有小于该排序列的记录移动到左边，把所有大于该排序码的记录移动到右边，中间放所选记录，称之为第一趟排序
然后对前后两个子序列分别重复上述过程，直到所有记录都排好序。

🌊复杂度
时间复杂度(平均): O(nlog n)
时间复杂度(最坏) : O(n²)
时间复杂度 (最好) : O(nlogⁿ)
空间复杂度: O(logn)

在这里插入图片描述

 function quick_sort(arr) {
        if (arr.length <= 1) {
            return arr
        }
        var quickIndex = Math.floor(arr.length / 2)
        var mid = arr.splice(quickIndex, 1)[0]
        var left = []
        var right = []
        for (var i = 0; i < arr.length; i++) {
            if (arr[i] > mid) {
                left.push(arr[i])
            } else {
                right.push(arr[i])
            }
        }
        return quick_sort(right).concat([mid], quick_sort(left))
    }

归并排序
💧 算法思想：将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
🌊复杂度
时间复杂度(平均): O(nlogⁿ)
时间复杂度(最坏) : O(nlogⁿ)
时间复杂度 (最好) : O(nlogⁿ)
空间复杂度: O(n)

在这里插入图片描述


function merge(left, right) {
        var result = []
        while (left.length > 0 && right.length > 0) {
            if (left[0] < right[0]) {
                result.push(left.shift())
            } else {
                result.push(right.shift())
            }
        }
        return result.concat(left, right)
    }

    function mergeSort(arr) {
        if (arr.length <= 1) {
            return arr
        }
        var mid = Math.floor(arr.length / 2)
        var left = mergeSort(arr.slice(0, mid))
        var right = mergeSort(arr.slice(mid))

        return merge(left, right)
    }

2，算法分析基础

分治法

将一个难以直接解决的大问题，分割成一些规模较小的相同问题。

步骤：
1，分解：将原问题分解成一系列子问题。
2，求解：递归地求解各个子问题，若子问题足够小，则直接求解。
3，合并，将子问题的解合并成原问题的解。

动态规划法

动态规划算法与分治法类似，其基本思想也是将待求解问题分解成若干子问题。先求解子问题，然后从这些子问题的解得到原问题的解。

与分治法不同的是，适合用动态规划法求解的问题，经分解得到的子问题往往不是独立的。若用分治法来解这类问题，则相同的子问题会被求解多次，以至于最后解决原问题需要耗时费指数级时间。然而，不同子问题的数目常常只有多项式量级，如果能够保存已解决的子问题的答案，在需要时再找出已求得的答案，这样就可以避免大量的重复计算。从而得到多项式时间的算法。

为达到这个目的，可以用一个表来记录所有已解决的子问题的答案，不管该子问题以后是否被用到，只要它被计算过，就将其结果填入表中，这就是动态规划法的基本思路。

动态规划算法通常用于求解具有某种最优性质的问题，在这类问题中，可能会有许多可行解，每个解都对应于一个值。我们希望找到具有最优值（最大或者最小值）的那个界，当然，最优解可能会有多个，动态规划算法能找出其中一个最优解。

步骤
1，找出最优解的性质，并刻画其结构特征。
2，递归地定义最优解的值。
3，以自定向上的方式计算出最优值。
4，根据计算最优值时得到的信息，构造一个最优解。

贪心法

贪心法也是用于解决最优化问题，与动态规划法不同的是，贪心法在解决问题的策略上是仅根据当前已有信息作出选择，而且一旦作出选择，不管将来有什么结果，这个选择都不会改变，换而言之贪心法并不是从整体最优考虑，它作出的选择只是在某种意义上的局部最优。

回溯法

回溯法有“通用的解题法”之称，用它可以系统地搜索一个问题的所有解或任一解。

分支限界法

分支界限法类似于回溯法，也是一种在问题的解空间树T上搜索问题解的算法。但在一般情况下，分支界限法与回溯法的求解目标不同。回溯法的求解目标是找出T中满足约束条件的所有解，而分支界限法的求解目标是找出满足约束条件的一个解，或者在满足约束条件的解中找出使某一目标函数值达到极大或极小的解，即某种意义下的最优解。