Kiner算法刷题记（九）：有趣的排序思想（手撕算法篇）

最新推荐文章于 2023-08-05 09:00:35 发布
置顶 最新推荐文章于 2023-08-05 09:00:35 发布
阅读量145 收藏
点赞数
分类专栏： 前端基础 知识梳理 文章标签： 算法 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010651383/article/details/117871091
版权

系列文章导引

开源项目

本系列所有文章都将会收录到GitHub中统一收藏与管理，欢迎ISSUE和Star。

GitHub传送门：Kiner算法算题记

1122. 数组的相对排序

解题思路

这题是典型使用计数排序的题目，我们只需要根据第二个数组中的元素对第一个数组中每一个元素统计数量，然后按照计数排序的规则先将第二个数组中有的数放入结果数组，然后再将第二个数组中没有的元素依次加入到结果数组即可。

代码演示
/*
 * @lc app=leetcode.cn id=1122 lang=typescript
 *
 * [1122] 数组的相对排序
 *
 * https://leetcode-cn.com/problems/relative-sort-array/description/
 *
 * algorithms
 * Easy (70.81%)
 * Likes:    175
 * Dislikes: 0
 * Total Accepted:    59.6K
 * Total Submissions: 84.1K
 * Testcase Example:  '[2,3,1,3,2,4,6,7,9,2,19]\n[2,1,4,3,9,6]'
 *
 * 给你两个数组，arr1 和 arr2，
 * 
 * 
 * arr2 中的元素各不相同
 * arr2 中的每个元素都出现在 arr1 中
 * 
 * 
 * 对 arr1 中的元素进行排序，使 arr1 中项的相对顺序和 arr2 中的相对顺序相同。未在 arr2 中出现过的元素需要按照升序放在 arr1
 * 的末尾。
 * 
 * 
 * 
 * 示例：
 * 
 * 
 * 输入：arr1 = [2,3,1,3,2,4,6,7,9,2,19], arr2 = [2,1,4,3,9,6]
 * 输出：[2,2,2,1,4,3,3,9,6,7,19]
 * 
 * 
 * 
 * 
 * 提示：
 * 
 * 
 * 1 
 * 0 
 * arr2 中的元素 arr2[i] 各不相同
 * arr2 中的每个元素 arr2[i] 都出现在 arr1 中
 * 
 * 
 */

// @lc code=start
function relativeSortArray(arr1: number[], arr2: number[]): number[] {
    // 统计第一个数组中每个元素出现的次数,依据题意，我们值域最大值是1000，因此，用于计数用的数组大小设置为1001,
    // 确保能够放下所有满足值域的数字
    const count: number[] = new Array<number>(1001);
    const temp: number[] = [];
    count.fill(0);
    for(let num of arr1) count[num] += 1;
    // 用来标记当前已经替换的元素数量
    let p = 0;
    // 然后将arr2出现的数字先放入到arr1的前半段
    for(let num of arr2) {
         线面几行代码其实做的工作就是将arr2中存在的数字按照数量替换到arr1中，替换完就将计数器置为0，因此，我们可以简化一下代码：
        // // 需要往arr1数组中塞count[num]个元素
        // for(let i=0;i<count[num];i++) {
        //     arr1[p++] = num;
        // }
        // // 塞进去之后，将当前数据的计数器设置为0，代表已经处理过了
        // count[num] = 0;

        // 这行代码实际上跟上面的for的代码用处是一样的，但是更加精简一些
        while(count[num]--) arr1[p++] = num;
    }

    // 经过上面的步骤，我们已经完成了arr2中存在元素的排序了，接下来就对arr2中不存在元素进行排序
    for(let i=0;i<count.length;i++) {
        // 如果计数为0代表不存在该数字或者该数字在第二个数组中已经存在并在上面的步骤已经处理完了，无需处理
        // 那么，为什么会有小于0的情况呢？是因为我们进行count[i]--时，后可能出现0--为-1的情况，因此兼容一下
        // if(count[i] === 0) continue;
        // for(let j=0;j<count[i];j++) arr1[p++] = i;
        // 上面两行代码实际上跟下面的代码是等效的，只是代码量会稍微精简一点
        if(count[i] <= 0) continue;
        // 否则就将目标数字加到数组某位，不过要记住，此处不应该取count中的元素，而应该获取count的索引，
        // 因为count的元素代表的是元素的数量，他的索引才是真正的值
        while(count[i]--) arr1[p++] = i;
    }
    return arr1;

};
// @lc code=end

164. 最大间距

解题思路

依题意，要求我们要用线性的复杂度解决，由于快速排序和归并排序都是nlogn的，是非线性的，而又因为我们值域的范围过于庞大，我们也没办法使用计数排序，因此，这道题最适合使用基数排序实现。

代码演示

PS: 受限于语言特性和LeetCode判题逻辑，下面代码有一定概率会超出内存限制，但基数排序的思想是没错的

/*
 * @lc app=leetcode.cn id=164 lang=typescript
 *
 * [164] 最大间距
 *
 * https://leetcode-cn.com/problems/maximum-gap/description/
 *
 * algorithms
 * Hard (60.96%)
 * Likes:    383
 * Dislikes: 0
 * Total Accepted:    52.9K
 * Total Submissions: 86.6K
 * Testcase Example:  '[3,6,9,1]'
 *
 * 给定一个无序的数组，找出数组在排序之后，相邻元素之间最大的差值。
 * 
 * 如果数组元素个数小于 2，则返回 0。
 * 
 * 示例 1:
 * 
 * 输入: [3,6,9,1]
 * 输出: 3
 * 解释: 排序后的数组是 [1,3,6,9], 其中相邻元素 (3,6) 和 (6,9) 之间都存在最大差值 3。
 * 
 * 示例 2:
 * 
 * 输入: [10]
 * 输出: 0
 * 解释: 数组元素个数小于 2，因此返回 0。
 * 
 * 说明:
 * 
 * 
 * 你可以假设数组中所有元素都是非负整数，且数值在 32 位有符号整数范围内。
 * 请尝试在线性时间复杂度和空间复杂度的条件下解决此问题。
 * 
 * 
 */

// @lc code=start

const halfBit32 = Math.pow(2, 16);
function getLow16(num: number): number {
    // 依据题意，不需要考虑负数情况，可以使用这种方式
    // return Math.floor(num % halfBit32);
    // 或使用位运算
    return num & 0xffff;
}

function getHeigh16(num: number): number {
    // return Math.floor(num / halfBit32);
    // 或使用位运算
    return (num & 0xffff0000) >> 16
}

function maximumGap(nums: number[]): number {
    const count: number[] = new Array<number>(halfBit32);
    const tmp: number[] = [];
    count.fill(0);
    // 对低16位进行处理
    // 首先进行计数
    for(let num of nums) count[num] += 1;
    // 求前缀和
    for(let i=1;i<count.length;i++) count[i] += count[i-1] 
    // 归位
    for(let i=nums.length - 1; i>=0;--i) tmp[--count[getLow16(nums[i])]] = nums[i];
    // 复位count
    count.fill(0);
    // 处理高16位
    for(let num of tmp) count[num] += 1;
    for(let i=1;i<count.length;i++) count[i] += count[i-1];
    for(let i=tmp.length - 1;i>=0;--i) nums[--count[getHeigh16(tmp[i])]] = tmp[i];

    // 至此，数组就已经用线性复杂度排好序了，然后就是计算差值
    let res = 0;
    for(let i=1;i<nums.length;i++) {
        res = Math.max(res, nums[i] - nums[i-1]);
    }
    return res;
};
// @lc code=end

207. 课程表

解题思路

这道题因为涉及到学习课程与期对应先修课的关系，其实就可以建立起一个以课程为节点，以先修关系为有向边的图，我们只需要对这个图进行拓扑排序，如果我们的课程关系中存在环，即ai的先修课为bi，bi的先修课为ci，ci的先修课为ai,那么这几节课就形成了环，每个节点的入度都不可能为0，此时使用拓扑排序，这三门课就不会被加入到结果中，因此，我们只需要通过拓扑排序之后，判断一下节点数量是否等于课程数量便可判断是否能够完成所有课程的学习了。

代码演示
/*
 * @lc app=leetcode.cn id=207 lang=typescript
 *
 * [207] 课程表
 *
 * https://leetcode-cn.com/problems/course-schedule/description/
 *
 * algorithms
 * Medium (54.64%)
 * Likes:    816
 * Dislikes: 0
 * Total Accepted:    112.3K
 * Total Submissions: 205.6K
 * Testcase Example:  '2\n[[1,0]]'
 *
 * 你这个学期必须选修 numCourses 门课程，记为 0 到 numCourses - 1 。
 * 
 * 在选修某些课程之前需要一些先修课程。 先修课程按数组 prerequisites 给出，其中 prerequisites[i] = [ai, bi]
 * ，表示如果要学习课程 ai 则 必须 先学习课程  bi 。
 * 
 * 
 * 例如，先修课程对 [0, 1] 表示：想要学习课程 0 ，你需要先完成课程 1 。
 * 
 * 
 * 请你判断是否可能完成所有课程的学习？如果可以，返回 true ；否则，返回 false 。
 * 
 * 
 * 
 * 示例 1：
 * 
 * 
 * 输入：numCourses = 2, prerequisites = [[1,0]]
 * 输出：true
 * 解释：总共有 2 门课程。学习课程 1 之前，你需要完成课程 0 。这是可能的。
 * 
 * 示例 2：
 * 
 * 
 * 输入：numCourses = 2, prerequisites = [[1,0],[0,1]]
 * 输出：false
 * 解释：总共有 2 门课程。学习课程 1 之前，你需要先完成​课程 0 ；并且学习课程 0 之前，你还应先完成课程 1 。这是不可能的。
 * 
 * 
 * 
 * 提示：
 * 
 * 
 * 1 
 * 0 
 * prerequisites[i].length == 2
 * 0 i, bi < numCourses
 * prerequisites[i] 中的所有课程对 互不相同
 * 
 * 
 */

// @lc code=start
function canFinish(numCourses: number, prerequisites: number[][]): boolean {
    // 用于存储每个节点的入度（即指向该节点的节点数量）是多少，默认都为0
    const indeg: number[] = new Array<number>(numCourses);
    indeg.fill(0);
    // 定义一个队列用来辅助拓扑排序
    const queue: number[] = [];
    // 定义一个二维数组用于存储每个先修课程学完之后要学的是哪一门或几门课程
    const dep: number[][] = [];

    // 首先初始化入度和依赖数组
    for(let num of prerequisites) {
        // num数组第一个元素代表课程，第二个代表先修课程
        // 因此如果prerequisites包含了num[0]课程，说明这个课程有依赖课程，所以入度加1
        indeg[num[0]] += 1;
        // 将依赖关系存入二维数组中
        (dep[num[1]]||(dep[num[1]] = [])).push(num[0])
    }

    // 按照拓扑排序的规则，只有入度为0的节点才能进入队列，初始时，我们将所有入度为0的节点
    // 都先放入队列
    for(let i=0;i<numCourses;i++) indeg[i] === 0 && queue.push(i);

    // 初始化准备完毕，我们就可以在进行拓扑排序的过程中计算能够学习完的课程的数量了
    let res = 0;

    // 如果队列不为空则继续执行
    while(queue.length !== 0) {
        // 从队首出元素
        const node = queue.shift();
        // 每弹出一个元素，计数器加1
        res++;
        // 然后将依赖弹出元素的课程的入度减一,如果减一后发现该课程入度为0，则加入队列
        if(dep[node]) {
            for(let num of dep[node]) {
                indeg[num]--;
                indeg[num] === 0 && queue.push(num);
            }
        }
    }
    // console.log(res, numCourses);
    // 只需判断拓扑序的节点树是否与总课程数相等即可
    return res === numCourses;

};
// @lc code=end

210. 课程表 II

解题思路

这题其实跟上一题的解题思路是一样的，我们只需要把计算数量改成将拓扑排序的结果加入到数组中，如果最终数组的长度与课程数量相等则说明能修完全部课程，直接返回改排序后的数组，否则不能修完全部课程，直接返回空数组

代码演示
/*
 * @lc app=leetcode.cn id=210 lang=typescript
 *
 * [210] 课程表 II
 *
 * https://leetcode-cn.com/problems/course-schedule-ii/description/
 *
 * algorithms
 * Medium (53.28%)
 * Likes:    413
 * Dislikes: 0
 * Total Accepted:    71.1K
 * Total Submissions: 133.3K
 * Testcase Example:  '2\n[[1,0]]'
 *
 * 现在你总共有 n 门课需要选，记为 0 到 n-1。
 * 
 * 在选修某些课程之前需要一些先修课程。 例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示他们: [0,1]
 * 
 * 给定课程总量以及它们的先决条件，返回你为了学完所有课程所安排的学习顺序。
 * 
 * 可能会有多个正确的顺序，你只要返回一种就可以了。如果不可能完成所有课程，返回一个空数组。
 * 
 * 示例 1:
 * 
 * 输入: 2, [[1,0]] 
 * 输出: [0,1]
 * 解释: 总共有 2 门课程。要学习课程 1，你需要先完成课程 0。因此，正确的课程顺序为 [0,1] 。
 * 
 * 示例 2:
 * 
 * 输入: 4, [[1,0],[2,0],[3,1],[3,2]]
 * 输出: [0,1,2,3] or [0,2,1,3]
 * 解释: 总共有 4 门课程。要学习课程 3，你应该先完成课程 1 和课程 2。并且课程 1 和课程 2 都应该排在课程 0 之后。
 * 因此，一个正确的课程顺序是 [0,1,2,3] 。另一个正确的排序是 [0,2,1,3] 。
 * 
 * 
 * 说明:
 * 
 * 
 * 输入的先决条件是由边缘列表表示的图形，而不是邻接矩阵。详情请参见图的表示法。
 * 你可以假定输入的先决条件中没有重复的边。
 * 
 * 
 * 提示:
 * 
 * 
 * 这个问题相当于查找一个循环是否存在于有向图中。如果存在循环，则不存在拓扑排序，因此不可能选取所有课程进行学习。
 * 通过 DFS 进行拓扑排序 - 一个关于Coursera的精彩视频教程（21分钟），介绍拓扑排序的基本概念。
 * 
 * 拓扑排序也可以通过 BFS 完成。
 * 
 * 
 * 
 */

// @lc code=start
function findOrder(numCourses: number, prerequisites: number[][]): number[] {
    let indeg: number[] = new Array<number>(numCourses);
    indeg.fill(0);
    let queue: number[] = [];
    let dep: number[][] = [];

    // 先初始化入度和依赖关系
    for(let course of prerequisites) {
        indeg[course[0]] += 1;
        (dep[course[1]] || (dep[course[1]] = [])).push(course[0]);
    }

    // 将所有入度为0的节点放入队列当中
    for(let i=0;i<indeg.length;i++) {
        if(indeg[i] === 0) queue.push(i);
    }

    // 进行拓扑排序
    let res: number[] = [];
    while(queue.length!==0) {
        const top = queue.shift();
        res.push(top);
        indeg[top] = 0;
        if(dep[top]) {
            for(let num of dep[top]) {
                indeg[num]--;
                indeg[num] === 0 && queue.push(num);
            }
        }
    }

    // 如果拓扑排序后的节点数量等于课程数量，说明可以修完全部课程，直接返回排序后的数组
    if(res.length === numCourses) return res;
    // 否则不能修满全部课程，返回空数组
    return [];
};
// @lc code=end

56. 合并区间

解题思路

这道题的难点其实就在于如何判断两个区间重合可以进行合并。其实我们可以借助类似于之前栈的一个思想。我们之前学习栈的时候有说过，栈不仅仅是一个数据结构，还代表的一类思想，就是遇到开始标记则加1，遇到结束标记则减1，当计数为0时说明已经抵消掉一对起始标记了。在这里也同样适用。我们拿例题举一个例子：

[[1,3],[2,6],[8,10],[15,18]]
# 上面的二维数组代表的是一个区间，但是区间可能出现重合。我们要做的就是合并重合区间，那么，怎么合并呢？
# 我们可以这样，当遇到区间起始点时+1，遇到区间结束点时-1，当计数为0时，从第一个区间起始点到当前区间的终点就是可以我们合并后的区间
# 为了实现上述的操作，我们先处理一下这个数组
[[1,1], [3,-1], [2,1],[6,-1],[8,1],[10,-1],[15,1],[16,-1]]
# 如上操作，将二位数组根据起始点和结束点拆分并打上+1和-1的标记
# 然后我们现根据起始点进行从小到大排序，如果起始点相同，就根据+1和-1从大到小排序
[[1,1],[2,1], [3,-1],[6,-1],[8,1],[10,-1],[15,1],[16,-1]]
# 当我们循环这个二位数组时，刚好到了6为其实点时，我们的计数器为0，此时，我们合并后区间就是[1,6],剩下的也以此类推，遍历结束后，我们就已经得到了最终的答案了
[[1,6],[8,10],[15,18]]
代码演示
/*
 * @lc app=leetcode.cn id=56 lang=typescript
 *
 * [56] 合并区间
 *
 * https://leetcode-cn.com/problems/merge-intervals/description/
 *
 * algorithms
 * Medium (45.39%)
 * Likes:    945
 * Dislikes: 0
 * Total Accepted:    237.9K
 * Total Submissions: 521.2K
 * Testcase Example:  '[[1,3],[2,6],[8,10],[15,18]]'
 *
 * 以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi]
 * 。请你合并所有重叠的区间，并返回一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间。
 * 
 * 
 * 
 * 示例 1：
 * 
 * 
 * 输入：intervals = [[1,3],[2,6],[8,10],[15,18]]
 * 输出：[[1,6],[8,10],[15,18]]
 * 解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].
 * 
 * 
 * 示例 2：
 * 
 * 
 * 输入：intervals = [[1,4],[4,5]]
 * 输出：[[1,5]]
 * 解释：区间 [1,4] 和 [4,5] 可被视为重叠区间。
 * 
 * 
 * 
 * 提示：
 * 
 * 
 * 1 
 * intervals[i].length == 2
 * 0 i i 
 * 
 * 
 */

// @lc code=start
function merge(intervals: number[][]): number[][] {
    let tmp: number[] = [];
    let res: number[][] = [];
    // 将原本区间范围改造成[[起点,1],[终点,-1],....]的数组
    for(let num of intervals) {
        tmp[0] = num[0];
        tmp[1] = 1;
        res.push([...tmp]);
        tmp[0] = num[1];
        tmp[1] = -1;
        res.push([...tmp]);
    }
    // 将改造后的数组先按每个元素的第一个从小到大排序，如果两个相同，则按第二个数从大到小排
    res.sort((a, b) => {
        if(a[0] === b[0]) return b[1] - a[1];

        return a[0]-b[0];
    });
    
    // pre用于记录区间初始位置，count用来辅助判断是否已经左右断点相互抵消
    let pre = -1, count = 0, ret: number[][] = [];

    for(let num of res) {
        // 当pre为-1时，说明是初始状态,让pre指向区间头部元素
        if(pre === -1) pre = num[0];
        // 计数器累加
        count += num[1];
        // 当计数器为0时，说明左右断点已经销户抵消了，那么，此时pre所指向的就应该是合并后区间的起始值，而当前num的
        // 第一个元素则是区间的终止值
        if(count === 0) {
            tmp[0] = pre;
            tmp[1] = num[0];
            ret.push([...tmp]);
            // 将合并后的区间压入结果数组之后，需要重置pre,以便进入下一轮的合并
            pre = -1;
        }
    }

    return ret;
};
// @lc code=end
星河阅卷
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Algorithm：【算法进阶之路】之算法面试刷题集合—十大经典排序算法(​简单插入排序/希尔排序、选择排序/堆排序、冒泡排序/快速排序、归并排序、计数排序/桶排序/基数排序)动态图文讲解及其代码实现
近期请国内外头部出版社可尽快私信博主！——心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，谦虚，自律，反思，成长，还算是比较正能量的博主，公益免费传播……内心特别想在AI界做出一些可以推进历史进程影响力的东西(兴趣使然，有点小情怀，也有点使命感呀)…
05-21 4万+
​ Algorithm：【算法进阶之路】之算法面试刷题集合—十大经典排序算法(​简单插入排序/希尔排序、选择排序/堆排序、冒泡排序/快速排序、归并排序、计数排序/桶排序/基数排序)动态图文讲解及其代码实现 目录 相关文章 排序算法思维导图 十大算法复杂度、稳定性比较 十大排序算法 相关文章 DSt：数据结构的简介、最强学习路线(逻辑结构【数组-链表-栈和队列/树-图-哈希】、物理结构【元素/关系】、数据运算【十大排序/四大查找-图三大搜索-树三大遍历】
【算法总结系列-2】有趣的排序-冒泡排序-C++演示
Veyron_wu
05-20 663
首先，冒泡排序的思想：每次比较两个相邻的元素，如果它们的顺序“错误”就把它们交换过来。这里指的错误就是左边的元素大于右边的元素 代码示例： #include using namespace std; int main() { int a[100],i,j,t,n; cin>>n;//输入一个数，表明有多少个待排序的数 for(i = 1;i <= n;i++)
Kiner算法刷题记（九）：有趣的排序思想（算法基础篇）
u010651383的专栏
06-13 203
计数排序基础知识与原理 当我们待排序的序列中只有有限种类的数，如只有1，2，3三个数字时，适合使用计数排序，因为只有这么几种情况，我们只需要把每个数字出现的次数统计出来，然后按照顺序依次输出每个数字统计个数的数即可。如： 原数组：[3,2,2,3,1,1,2] 计数：1出现了2次，2出现了3次，3出现了两次 排序: 先输出两个1，在输出3个2，最后输出2个三 结果: [1,1,2,2,2,3,3] 应用场景 综上所述：计数排序适用于简单的单值排序问题，排序问题中，数据的值域很有限 例如：我现在要统计全国所有
algorithm中的排序算法详解
秋名山码民的技术小屋
10-04 1645
文章目录前言一、algorithm是什么？二、有哪些排序算法？sortrandom_shufflemergereverse总结 前言 雨下不停，爱意难眠，说一下algorithm中的几个排序算法吧，干什么总要排个序吧，有单纯排序的算法题可以看一下，我写的码神说排序算法不多说了，来看吧，系好安全带，发车了！ 一、algorithm是什么？ 如果说algorithm是个什么东西的话，百度百科是这样说的，算法（algorithm），也如其名，这就是一个算法的头文件，如果展开了来说的话，可能国庆假期都不够我写的
Kiner算法刷题记（十九）：动态规划（手撕算法篇）
u010651383的专栏
05-28 116
系列文章导引 系列文章导引 开源项目 本系列所有文章都将会收录到GitHub中统一收藏与管理，欢迎ISSUE和Star。 GitHub传送门：Kiner算法算题记 1143. 最长公共子序列 解题思路 递推状态：我们最长公共子序列的长度取决于以第i-1个字符作为结尾的A字符串与以第j-1个字符作为结尾的B字符串公共子串长度。因此，我们的递推状态应为：dp[i,j]，代表：A串长度为i位，B串长度为j位的最长公共子序列的长度。 递推公式（状态转移方程）：当我们A串第i-1个字符与B串第j-1个字符相等时
Kiner算法刷题记（八）：归并排序MergeSort（手撕算法篇）
u010651383的专栏
06-09 602
系列文章导引 系列文章导引 开源项目 本系列所有文章都将会收录到GitHub中统一收藏与管理，欢迎ISSUE和Star。 GitHub传送门：Kiner算法算题记 23. 合并K个升序链表 解题思路 这道题算一个比较综合性的题目，既涉及到了之前学过的链表，也涉及到了堆，还涉及到了归并排序的逻辑。首先，我们来想一下，合并三个链表的过程，是不是跟归并排序的过程及其相似，在几个链表中找到他们的最小值，然后放入到一个临时的链表中，然后继续找下一个最小值。而在找链表最小值的时候，又可以使用我们之前学过的小顶堆来快
Kiner算法刷题记（十三）：单调队列(手撕算法篇)
u010651383的专栏
07-25 134
系列文章导引 系列文章导引 开源项目 本系列所有文章都将会收录到GitHub中统一收藏与管理，欢迎ISSUE和Star。 GitHub传送门：Kiner算法算题记 239. 滑动窗口最大值 解题思路 求取滑动窗口最大值，由于滑动窗口问题实际上就是固定结尾的RMQ问题，我们可以使用单调队列解决，而要求解的是最大值，因此应该使用单调递增队列。 代码演示 /* * @lc app=leetcode.cn id=239 lang=typescript * * [239] 滑动窗口最大值 */ // @
Kiner算法刷题记（七）：快排及快排思想（手撕算法篇）
u010651383的专栏
06-06 181
系列文章导引 系列文章导引 前言 我们熟悉了快速排序的思想与其实现原理之后，可以在我们实际开发中带来很多的启发与灵感，借助快速排序双指针的游走的思想，我们也可以解决很多类快排问题。现在就来借助一些算法题巩固一下对于讨论的快排思想。 刷题 剑指 Offer 21. 调整数组顺序使奇数位于偶数前面 解题思路 这道题的要点就是我们要找到数组中的奇偶数，并将他们按照规则放到他们改在的地方。我们可以借助快排中的双指针思想，让左右游标不断在数组中游走，左游标遇到偶数和右游标遇到奇数时，我们就可以让左右游标对应的值交
Kiner算法刷题记（十八）：递推算法与递推套路（手撕算法篇）
u010651383的专栏
02-13 185
系列文章导引 系列文章导引 开源项目 本系列所有文章都将会收录到GitHub中统一收藏与管理，欢迎ISSUE和Star。 GitHub传送门：Kiner算法算题记 前言 之前学习基础知识的时候也说了，递推和动态规划有这暧昧不清的关系，可以说，动态规划就是多了一个决策过程的递推，因此，我们今天的刷题也会涉及到一些比较简单的动态规划的题目，同样能够对我们深刻的理解递推算法起到帮助，也为我们之后深入学习动态规划算法和动态规划的优化打下基础。 前置知识 滚动数组 使用场景：当我们下（上）一行的状态可以仅仅通过上
chrome-extensions-kiner-switch-hosts:chrome快速切换host的扩展程序
05-14
chrome-extensions-kiner-switch-hosts chrome快速切换host的扩展程序 已实现功能 实时切换host 对多个host配置进行统一管理 支持导入csv数据 支持批量开启和关闭 支持批量删除 实现switch host的偏好设置保存...
逆波兰表达式实现的简易计算器
06-01
接着是`kiner-calc.js`，这是一个JavaScript脚本文件，实现了逆波兰表达式的解析和计算逻辑。它可能包括以下功能： 1. **输入解析**：将用户输入的常规表达式转换为逆波兰表达式。这个过程涉及到操作符优先级的处理...
指标 - BirkiBlæ的电子诗歌书「Vísur - rafræn ljóðabók eftir Birki Blæ」-crx插件
03-13
Bókiner 16síðuraðlendd。 garegaröllljóðinhafaveriðbirt munvafraviðbótineyðasjálfrisérogathugasemdakerfiðbirtastáný。 MeðgönguljóðumísamstarfiviðVísurgefinút。 （smelliðábláa...
哈夫曼编码与二叉字典树
u010651383的专栏
07-31 4014
你知道计算机底层是如何存储数据的吗？你了解什么是编码吗？你知道定长编码和变长编码的区别吗？你知道最优的变长编码是怎样的吗？我们今天就带着这些问题来一探究竟吧
前端面试知识梳理（高级前端开发工程师）
u010651383的专栏
03-11 3188
css部分 盒子模型 margin+border+padding+content Content边界/内边界: content边界环绕在由该元素的宽和高决定的一个矩形上,这个尺寸通常由该元素渲染后的内容决定,这四个content边界组成的矩形框就是该元素的content box. Padding边界:padding边界环绕在该元素的padding区域的四周,顾名思义,填充背景色.如果pad...
gitlab 创建 merge-request 时执行作业
u010651383的专栏
07-21 1721
为了项目代码更加健壮，避免一些低级错误以及有一些业务不了解而导致的问题，我们每个需求上线之前都需要邀请其他同学进行代码评审，然而每次都要手动在群里面邀请其他同学未免有一些麻烦了，因此，想要使用`CI`工具，在创建`merge-request`请求时自动发送代码评审邀请。但目前`gitlab`中的事件触发`merge_requests`不仅仅在创建`merge-request`时会触发，我们每次推送更改到已经提过`merge-request`的源分支时，都会触发改工作，导致我们每次推送都会发送一次邀请通知。.
金三银四：基于AST的简易代码自动生成工具实现思路与原理剖析
u010651383的专栏
02-18 1598
基于AST的简易代码自动生成工具实现思路与原理剖析 背景 经常负责业务系统开发的小伙板门应该会经常遇到这样的一种情况，刚开始跟服务端约定好了接口文档之后，前端的小伙伴就会开始巴拉巴拉地根据接口文档提供的请求参数、响应结构等信息编写属于前端Models层用于描述接口请求参数、响应结果的结构，编写Services层用于发起接口请求等。但是，一旦服务端稍微改动了某一个接口的字段描述或代码接口，我们又得抱着开（捅）开（他）心（一）心（刀）的心态去调整我们的Models和Services结构，反复几次的话，简直不要
参与开源项目指南（偏前端方向）
u010651383的专栏
01-24 1365
相信有不少前端小伙伴都过想要参与一些开源项目开发的想法，但是有些时候由于一些客观原因，如无人指导、没有比较完善的一个参与开源项目的流程与步骤，不知如何下手。刚好，最近业务上使用antd-design/pro-components这个开源框架比较多，在开发时也遇到了一些框架本身的bug或者是用起来不方便的地方，因此，也向antd-design/pro-components提了多次PR，并全部审核通过。借此机会梳理一下参与开源项目的一些流程和注意事项，也为一些没有参与过开源项目开发的小伙伴提供一下参考，不至于像
循环依赖的那些事儿
最新发布
u010651383的专栏
08-05 673
在业务开发过程中，经常会使用 antd 作为 UI 组件库构建页面，然而在 antd@5.7.0 版本之前的版本，众多组件存在循环依赖的现象，导致在 vite 、rollup、microbundle 等构建工具中都出现大量的警告。对于一个用户量庞大的组件库来说，这无疑是一个巨大的隐患，有可能导致使用者在使用 antd 时出现一些不可预料的问题。因此，antd 的核心贡献者 afc163 决定立项整改 antd 当中循环依赖的乱象
前缀和与树状数组（数据结构基础篇）
u010651383的专栏
07-31 526
在我们以往的文章中，经常会出现使用`前缀和`求取区间和的场景。但是，很多同学对于`前缀和`的概念和一些优缺点并不清楚，因此，这边发个单章单独聊一下前缀和与树状数组。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

星河阅卷

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值