Kiner算法刷题记（八）：归并排序MergeSort（手撕算法篇）

置顶 于 2021-06-09 09:48:15 发布
阅读量597 收藏
点赞数
分类专栏： 数据结构 前端基础 知识梳理 文章标签： 算法 刷题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010651383/article/details/117731616
版权

系列文章导引

开源项目

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

GitHub传送门：Kiner算法算题记

23. 合并K个升序链表

解题思路

这道题算一个比较综合性的题目，既涉及到了之前学过的链表，也涉及到了堆，还涉及到了归并排序的逻辑。首先，我们来想一下，合并三个链表的过程，是不是跟归并排序的过程及其相似，在几个链表中找到他们的最小值，然后放入到一个临时的链表中，然后继续找下一个最小值。而在找链表最小值的时候，又可以使用我们之前学过的小顶堆来快速获取最小值对应的节点。

代码实现

/*
 * @lc app=leetcode.cn id=23 lang=typescript
 *
 * [23] 合并K个升序链表
 */

// @lc code=start
/**
 * Definition for singly-linked list.
 * class ListNode {
 *     val: number
 *     next: ListNode | null
 *     constructor(val?: number, next?: ListNode | null) {
 *         this.val = (val===undefined ? 0 : val)
 *         this.next = (next===undefined ? null : next)
 *     }
 * }
 */

export type HeapDataStruct<T> = {
    idx?: number,
    data: T
};
export type CompareFn<T> = (x: HeapDataStruct<T>, y: HeapDataStruct<T>) => boolean;
class Heap<T> {
    private arr: HeapDataStruct<T>[] = [];
    private count: number = 0;
    constructor(private cmpFn: CompareFn<T>) {

    }

    // 比较方法，决定了我们要构建的堆是一个大顶堆还是小顶堆
    private _compare(curIdx: number, pIdx: number): boolean {
        return this.cmpFn(this.arr[curIdx], this.arr[pIdx])
    }

    private _shift_up(idx: number): void {
        // 然后对堆进行向上调整
        // 我们需要通过子节点坐标得到父节点的坐标，因为我们这边的下标是从0开始的，所以左子树根节点坐标为：2 * i + 1，右子树根节点坐标为：2 * i + 2。那么我们父节点的编号：parseInt((子节点编号 - 1) / 2)，如知道左节点编号为：2 * i + 1，那么他的父节点坐标就是： parseInt((2 * i + 1 - 1) / 2) = parseInt(i);如果知道有节点的编号：2 * i + 2，那么他的父节点的坐标为：parseInt((2 * i + 2 - 1) / 2) = parseInt((2*i+1)/2) = i
        // 上面我们讲过，我们需要如果在一个大顶堆中，如果我们父节点的值小于子节点的值的话，就要交换这两个值
        // while(idx && this.arr[parseInt(String((idx - 1) / 2))].data < this.arr[idx].data) {
        while(idx && this._compare(parseInt(String((idx - 1) / 2)), idx)) {
          // 父节点编号
          const pIdx = parseInt(String((idx - 1) / 2));
          // 交换父节点和当前节点的值
          [ this.arr[pIdx], this.arr[idx] ] = [ this.arr[idx], this.arr[pIdx] ];
          // 然后再让idx变成父节点的编号，这样就能依次向上调整了
          idx = pIdx;
        }
      }

      private _shift_down(idx: number): void {
        // 交换之后，根节点再依次向下调整
        // 最大的子节点的下标
        let n = this.count - 1;
        // 当idx的子节点的下标比最大的子节点的下标小，就说明还有子节点，就要往下继续调整
        while(idx * 2 + 1 <= n) {
          // max代表在根节点、左子树、右子树中最大值的下标
          let max = idx;
          // 如果左子树的根节点的值比当前值大，就把max更新为左子树根节点的下标
        //   if(this.arr[max].data < this.arr[2*idx+1].data) max = 2*idx+1;
          if(this._compare(max, 2*idx+1)) max = 2*idx+1;
          // 如果右子树根节点的值比当前节点大，就把max更新为右子树根节点的下标
          // 需要注意的是，我们当前的节点，可能存在左子树，但不一定存在右子树，所以需要多加一个2*idx+2<=n的条件
          if(2*idx+2<=n && this._compare(max, 2*idx+2)) max = 2*idx+2;
        //   if(2*idx+2<=n && this.arr[max].data < this.arr[2*idx+2].data) max = 2*idx+2;
          // 如果我的最大值的下标就是当前的这个值，那就不需要向下调整了，直接结束循环
          if(max === idx) break;
          // 然后交换这个最大值的下标和根节点
          [ this.arr[idx], this.arr[max] ] = [ this.arr[max], this.arr[idx] ];
          // 然后把idx改为原最大值的下标，继续向下调整
    
          idx = max;
        }
      }

    push(item: HeapDataStruct<T>): void {
        this.arr[this.count++] = item;
        this._shift_up(this.count-1);
        // this.output('push: ');
    }

    pop(): HeapDataStruct<T>|null {
      if(this.size()===0) return null;
      const tmp = this.arr[0];
      // 根据上面的讲解，我们首先需要让队尾元素与根节点交换
      [ this.arr[0], this.arr[this.count-1] ] = [ this.arr[this.count-1], this.arr[0] ];
      // 交换之后记得count要减1
      this.count--;
      // 进行向下调整
      this._shift_down(0);
    //   this.output('pop: ');
      return tmp;
    }

    size(): number {
        return this.count;
    }

    top(): HeapDataStruct<T> {
        return this.arr[0];
    }

    output(pre: string = ""): void {
        console.log(pre+JSON.stringify(this.getArray()));
    }

    // 将堆中的数据里面的data单独拿出来放到数组返回
    getArray(sort: (a: HeapDataStruct<T>, b: HeapDataStruct<T>) => number = () => 0): T[] {
        return this.arr.slice(0, this.count).sort(sort).map(item=>item.data);
    }
}

function mergeKLists(lists: Array<ListNode | null>): ListNode | null {
    // 建立一个小顶堆，用于每次获取最小的一个链表节点
    const heap = new Heap<ListNode>((a, b) => a.data.val > b.data.val);
    // 将所有的链表头结点放入小顶堆中（如果是空链表就不用放进去了）
    for(const listNode of lists) {
        if(!listNode) continue;
        heap.push({
            data: listNode
        });
    }

    // 建立一个虚拟头结点用来存储合并后的链表，并让q指针初始指向该虚拟头结点
    let head: ListNode = new ListNode(), q = head;

    // 如果小顶堆不为空，则进入循环
    while(heap.size()) {
        // 每次弹出小顶堆的堆顶元素，即最小的元素
        const minListNode = heap.pop();
        // 把这个节点挂在新链表的后面
        q.next = minListNode.data;
        // 让q指针移动到当前节点，方便下一轮将下一个节点挂在当前节点后边
        q = minListNode.data;
        // 如果当前节点有下一个节点，继续将下一个节点加入到小顶堆中
        if(minListNode.data && minListNode.data.next) heap.push({
            data: minListNode.data.next
        })
    }
    // 返回新链表虚拟头结点的下一个节点即可
    return head.next;

};
// @lc code=end

148. 排序链表

解题思路

这一题我们在之前学习快速排序时使用快速排序的思路实现了一次，现在，我们学习了归并排序，我们就用归并排序的方式实现。首先，我们需要知道链表总共的长度，然后再根据长度将链表划分为左右两个部分，使用归并思想分别对左右两部分进行排序，最终合并左右两部分有序链表

代码实现

/*
 * @lc app=leetcode.cn id=148 lang=typescript
 *
 * [148] 排序链表
 */

// @lc code=start
/**
 * Definition for singly-linked list.
 * class ListNode {
 *     val: number
 *     next: ListNode | null
 *     constructor(val?: number, next?: ListNode | null) {
 *         this.val = (val===undefined ? 0 : val)
 *         this.next = (next===undefined ? null : next)
 *     }
 * }
 */

// 使用快排方式实现
function _sortList_quickSort(head: ListNode | null): ListNode | null {
    if(!head) return head;
    let p = head, q, h1=null,h2=null,mid;
    let min = Number.MAX_SAFE_INTEGER,max = Number.MIN_SAFE_INTEGER;

    // 找出最小值和最大值
    while(p) {
        min = Math.min(p.val, min);
        max = Math.max(p.val, max);
        p = p.next;
    }

    if(min === max) return head;

    // 求中间值
    mid = (min + max) >> 1;
    // 复位p
    p = head;

    // 将小于中间值的节点挂在h1，将大于中间值的节点挂在h2
    while(p) {
        q = p.next;
        if(p.val <= mid) {
            p.next = h1;
            h1 = p;
        } else {
            p.next = h2;
            h2 = p;
        }
        p = q;
    }

    // 递归操作h1和h2
    h1 = sortList(h1);
    h2 = sortList(h2);

    // 将h1尾结点与h2的头结点链接起来成为一个新链表
    p = h1;
    while (p.next) {
        p = p.next;
    }
    p.next = h2;
    return h1;
}

function _mergeSort(head: ListNode | null, n: number): ListNode | null {
    // 当只有一个节点或没有节点时无需排序
    if(!head || !head.next) return head;
    // 计算链表左边的节点数量和右边的节点数量
    // 左边链表节点数量就拿链表总长度除以2舍弃小数部分，右边长度就直接用总长度减去左边长度
    let l = n >> 1, r = n - l;
    // 我们首先需要将链表断开成长度分别为l和r的两个链表
    // 左指针指向原链表头部，初始时右指针先指向左指针，稍后会将右指针移动到正确位置，并将链表拆分成两个分别以lp和rp
    // 作为头结点的链表，p是一个临时节点，用于临时存储链表有半部分的前一个节点
    let lp = head, rp = lp, p = new ListNode();

    // 让rp向右移动至链表左半部分的最后一个节点的位置，之所以不移动到右半边的第一个位置，是因为我们要断开链表
    // 就需要知道链表头结点的上一个节点是谁才能断开
    for(let i=1;i<l;i++,rp = rp.next);
    // 使用p临时存储右半边链表的上一个节点，让rp指向右半边链表的头结点，然后断开左右链表
    p = rp, rp = rp.next,p.next = null;
    // 至此，我们就生成了分别以lp和rp为头结点的两个链表了
    // 然后，根据归并排序的思想，分别排序左半边链表和右半边链表
    lp = _mergeSort(lp, l);
    rp = _mergeSort(rp, r);

    // 排序完毕之后，我们就可以合并了
    // 定义一个虚拟头结点用来存储最终合并的链表，并让p指针指向这个虚拟头结点
    let res = new ListNode();
    p = res;

    // 只要左右链表有一个没有遍历结束就继续
    while(lp || rp) {
        // 如果右边链表为空或者左边链表不为空且左边链表的值小于右边链表的值
        if(!rp || (lp && lp.val < rp.val)) {
            // 将做链表的头结点放入到结果链表当中
            p.next = lp;
            // 左边链表指针右移一位
            lp = lp.next;
            // 结果链表指针右移一位
            p = p.next;
        } else {
            // 将右边链表加入到结果链表
            p.next = rp;
            // 右边链表指针右移一位
            rp = rp.next;
            // 结果链表右移一位
            p = p.next;
        }
    }

    // 结果就是我们虚拟头结点的下一个节点
    return res.next;
}
// 使用归并排序方式实现
function _sortList_mergeSort(head: ListNode | null): ListNode | null {
    let n = 0;
    let p = head;
    while(p) p = p.next,n++;
    return _mergeSort(head, n);
}

function sortList(head: ListNode | null): ListNode | null {
    // return _sortList_quickSort(head);
    return _sortList_mergeSort(head);
};
// @lc code=end

1305. 两棵二叉搜索树中的所有元素

解题思路

二叉搜索树又称为二叉排序树，其中序遍历的结果是一个有序序列，我们可以先获取两个二叉搜索树的中序遍历结果，然后剩下的就是利用归并排序思想合并两个有序数组了

代码实现

/*
 * @lc app=leetcode.cn id=1305 lang=typescript
 *
 * [1305] 两棵二叉搜索树中的所有元素
 */

// @lc code=start
/**
 * Definition for a binary tree node.
 * class TreeNode {
 *     val: number
 *     left: TreeNode | null
 *     right: TreeNode | null
 *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
 *         this.val = (val===undefined ? 0 : val)
 *         this.left = (left===undefined ? null : left)
 *         this.right = (right===undefined ? null : right)
 *     }
 * }
 */

// 对一个二叉树进行中序遍历，并将结果存到数组中
function getTreeInOrderedResult(root: TreeNode, arr: number[]): void {
    if(!root) return;
    getTreeInOrderedResult(root.left, arr);
    arr.push(root.val);
    getTreeInOrderedResult(root.right, arr);
}

function getAllElements(root1: TreeNode | null, root2: TreeNode | null): number[] {
    const lVals: number[] = [], rVals: number[] = [];
    // 分别获得两个二叉搜索树的中序遍历结果（二叉搜索树的中序遍历结果是一个有序的序列）
    getTreeInOrderedResult(root1, lVals);
    getTreeInOrderedResult(root2, rVals);

    // 然后根据归并排序的思想将两个有序序列合并
    let lp = 0,rp = 0,res = [];

    // 归并排序合并思想，不再赘述
    while(lp < lVals.length || rp < rVals.length) {
        
        if(rp>=rVals.length || (lp<lVals.length && lVals[lp] <= rVals[rp])) res.push(lVals[lp++])
        else res.push(rVals[rp++])
    }

    return res;

};
// @lc code=end

327. 区间和的个数

解题思路

依据题意，区间和值其实就是所提共数组下标所对应的封闭区间内元素的和值，如例1中：nums = [-2,5,-1], lower = -2, upper = 2

我们来列举一下所有区间以及他对应的和值([-2,5,-1]的数组索引分别为：0,1,2)：

  • （0,0）此区间内只包含-2一个元素，因此区间和值为-2
  • （0,1）此区间包含-2和5两个元素，区间和值为-3
  • （0,2）区间和值为2
  • （1,1）区间和值为5
  • （1,2）区间和值为4
  • （2,2）区间何志伟-1

综上所述，区间和满足在-2~2的有(0,0) (0,2) (2,2)总共3个。

接下来我们再来想想，我们要怎么来求区间和呢？其实我们要求区间和，首先我们就要先求出数组的前缀和，前缀和的通俗理解是：第一项为0，以后每一项都是前面元素之和，如上面的数组[-2,5,-1]的前缀和数组为[0,-2,3,2]，有了前缀和数组之后，我们的区间和值就等于前缀和数组中两项相减的值。即;区间和=前缀和两项相减。那么，我们就把原文题转换成了，在前缀和数组中满足：lower <= sum(j) - sum(i) <= upper | i < j这样的一个问题。

将上面的公式转化一下：sum(j) - lower <= sum(i) >= sum(j) - upper,这样，我们就得出了sum(i)的一个特性：

sum(i) >= sum(j) - lower && sum(i) >= sum(j) - upper

代码实现

/*
 * @lc app=leetcode.cn id=327 lang=typescript
 *
 * [327] 区间和的个数
 */

// @lc code=start

function countTowPart(nums: number[], l1: number, r1: number, l2: number, r2: number, lower: number, upper: number): number { 
    let res = 0;
    // 定义两个指针，初始都指向l1
    let lp = l1, rp = l1;
    // 在右区间中循环查找每一个元素，看看他们在左区间中有多少个满足条件的数
    for(let j=l2; j <= r2; j++) {
        // 根据上面推到的公式：sum(i) >= sum(j) - lower && sum(i) >= sum(j) - upper
        let a = nums[j] - upper;
        let b = nums[j] - lower;
        // 接下来就要找到大于等于a的第一个位置和大于b的第一个位置即可
        // 由于我们的nums拆分的左右两个分区数组经过下面归并排序的过程已经有序了，因此，我们借助数组的有序性
        // 当左指针没有到达左分区末尾，并且不满足上面我们推到的公式：sum(i) >= sum(j) - upper
        // 因此，如果当nums[lp] < a时，就要让区间左指针向右移动
        while(lp <= r1 && nums[lp] < a) lp++;
        while(rp <= r1 && nums[rp] <= b) rp++;
        // 符合条件的元素数量就是左右两个指针的差值
        res += rp - lp;
    }

    return res;
}

function mergeSort(nums: number[], l: number, r: number, lower: number, upper: number): number {
    let res = 0;
    if(l >= r) return res;
    let mid = (l + r) >> 1;

    // 分别计算所半边数量和右半边数量
    res += mergeSort(nums, l, mid, lower, upper);
    res += mergeSort(nums, mid + 1, r, lower, upper);
    // 计算横跨两边的数量，只需在右边找一下有多少左边的元素满足条件即可
    res += countTowPart(nums, l, mid, mid+1, r, lower, upper);

    // 进行归并过程
    let tmp: number[] = [], lp = l, rp = mid + 1;

    while(lp <= mid || rp <= r) {
        if(rp > r||(lp <= mid && nums[lp] < nums[rp])) tmp.push(nums[lp++])
        else tmp.push(nums[rp++]);
    }

    // 将临时数组替换到元素组中，完成排序
    nums.splice(l, tmp.length, ...tmp);

    return res;
}

function countRangeSum(nums: number[], lower: number, upper: number): number {
    // 先求出目标数组的前缀和数组
    const sums: number[] = [];

    // 前缀和数组第一项固定为0，后面每一项都是前几项之和
    sums[0] = 0;

    // 计算前缀和
    for(let i=0;i<nums.length;i++) sums[i+1] = sums[i] + nums[i];

    return mergeSort(sums, 0, sums.length - 1, lower, upper);
};
// @lc code=end

315. 计算右侧小于当前元素的个数

解题思路

这题我们同样也能使用归并排序的过程求解，与之前的归并排序不同的是，我们之前是从小到大排序，而这里，因为我们要查找比当前数小的数的个数，所以要保证右侧的数比较小，因此，要使用从大到小的排序，然后我们只需要计算在右侧区间中的元素数量并累加即可得到我们想要的答案，不过在此期间，我们需要使用一个自定义数据结构来存储索引、值、计数器之间的关系，方便最终将结果输出。

代码实现

/*
 * @lc app=leetcode.cn id=315 lang=typescript
 *
 * [315] 计算右侧小于当前元素的个数
 *
 * https://leetcode-cn.com/problems/count-of-smaller-numbers-after-self/description/
 *
 * algorithms
 * Hard (41.96%)
 * Likes:    585
 * Dislikes: 0
 * Total Accepted:    45.1K
 * Total Submissions: 107.4K
 * Testcase Example:  '[5,2,6,1]'
 *
 * 给定一个整数数组 nums，按要求返回一个新数组 counts。数组 counts 有该性质： counts[i] 的值是  nums[i] 右侧小于
 * nums[i] 的元素的数量。
 * 
 * 
 * 
 * 示例：
 * 
 * 输入：nums = [5,2,6,1]
 * 输出：[2,1,1,0] 
 * 解释：
 * 5 的右侧有 2 个更小的元素 (2 和 1)
 * 2 的右侧仅有 1 个更小的元素 (1)
 * 6 的右侧有 1 个更小的元素 (1)
 * 1 的右侧有 0 个更小的元素
 * 
 * 
 * 
 * 
 * 提示：
 * 
 * 
 * 0 <= nums.length <= 10^5
 * -10^4 <= nums[i] <= 10^4
 * 
 * 
 */

// @lc code=start
// 用于存储索引、值和目标计数器的数据结构
interface Data {
    idx: number,
    val: number,
    count: number
}

// 归并排序
function mergeSort(nums: Data[], l: number, r: number): void {
    // 以下就是归并排序过程，不再赘述
    if(l >= r) return;
    let mid = (l + r) >> 1;
    mergeSort(nums, l, mid);
    mergeSort(nums, mid + 1, r);

    let lp = l, rp = mid + 1, tmp: Data[] = [];

    while(lp <= mid || rp <= r) {
        // 与之前的归并排序不同的是，此处我们要从大到小排序，这样就能够保证，我们右边每一个数都肯定比左边的数小
        // 我们只要计算右边元素的数量即可
        if(rp > r || (lp <= mid && nums[lp].val > nums[rp].val)) {
            // 累加当前元素的元素数量
            nums[lp].count += (r - rp + 1);
            tmp.push(nums[lp++]);
        } else {
            tmp.push(nums[rp++]);
        }
    }
    // 更新原数组
    nums.splice(l, tmp.length, ...tmp);
}

function countSmaller(nums: number[]): number[] {
    // 为了存储每个数字的值与索引的关系，也为了方便存储每个数组对应的结果值，先按照数据结构要求，将原始数组中
    // 的数据存储到自定义数据结构中，每个数字后面比当前数字小的数量初始为0
    const arr: Data[] = [];
    for(let i=0;i<nums.length;i++) arr.push({
        idx: i,
        val: nums[i],
        count: 0
    });

    // 在进行归并排序的过程中，不断计算每个值后面比他小的数的数量
    mergeSort(arr, 0, nums.length - 1);

    // 用于存储所有数量的结果数组
    const res: number[] = [];

    // 将所有的计数器按照期对应的索引存储到结果数组当中
    arr.forEach((item) => res[item.idx] = item.count);

    return res;

};
// @lc code=end

53. 最大子序和

解题思路

遇到求区间和问题，我们第一时间就要想到先求前缀和,有了前缀和数组后，就可以通过前缀和的差值求出区间和。如例题：

nums: [-2,1,-3,4,-1,2,1,-5,4]

前缀和数组sums: [0,-2,-1,-4,0,-1,1,2,-3,1]

求出了前缀和数组之后，我们只需要让前缀和数组除了第一项之外的每一项减去前面几项中的最小值，就能够得到当前项的区间和了:

索引1的子序和：-2

索引2的子序和：-1 - (-2) = 1

索引3的子序和：-4 - (-2) = -2

索引4的子序和：0 - (-4) = 4

索引5的子序和：-1 - (-4) = 3

索引6的子序和：1 - (-4) = 5

索引7的子序和：2 - (-4) = 6

索引8的子序和：-3 - (-4) = 1

索引9的子序和：1 - (-4) = 5

[-2,1,-2,4,3,5,6,1,5]，所以，我们最大子序列和就是这个数组的最大值，即6。

代码实现
/*
 * @lc app=leetcode.cn id=53 lang=typescript
 *
 * [53] 最大子序和
 *
 * https://leetcode-cn.com/problems/maximum-subarray/description/
 *
 * algorithms
 * Easy (54.06%)
 * Likes:    3243
 * Dislikes: 0
 * Total Accepted:    515.4K
 * Total Submissions: 951.1K
 * Testcase Example:  '[-2,1,-3,4,-1,2,1,-5,4]'
 *
 * 给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
 * 
 * 
 * 
 * 示例 1：
 * 
 * 
 * 输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
 * 输出：6
 * 解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。
 * 
 * 
 * 示例 2：
 * 
 * 
 * 输入：nums = [1]
 * 输出：1
 * 
 * 
 * 示例 3：
 * 
 * 
 * 输入：nums = [0]
 * 输出：0
 * 
 * 
 * 示例 4：
 * 
 * 
 * 输入：nums = [-1]
 * 输出：-1
 * 
 * 
 * 示例 5：
 * 
 * 
 * 输入：nums = [-100000]
 * 输出：-100000
 * 
 * 
 * 
 * 
 * 提示：
 * 
 * 
 * 1 
 * -10^5 
 * 
 * 
 * 
 * 
 * 进阶：如果你已经实现复杂度为 O(n) 的解法，尝试使用更为精妙的 分治法 求解。
 * 
 */

// @lc code=start
function maxSubArray(nums: number[]): number {
    if(nums.length===1) return nums[0];
    // 要求区间和，就先求前缀和
    const sums: number[] = [0];
    // 生成前缀和数组
    for(let i=0;i<nums.length;i++) sums[i+1] = sums[i] + nums[i];

    let min = sums[0], max = Number.MIN_SAFE_INTEGER;
    for(let i=1;i<sums.length;i++) {
        // 如果当前值减去当前值之前的最小值比当前的最大值大，则更新为最大值
        if(sums[i] - min > max) max = sums[i] - min;
        // 如果当前值比最小值小，则更新最小值
        if(sums[i] < min) min = sums[i];
    }

    return max;
};
// @lc code=end
星河阅卷
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
[刷题] MergeSort
programmingfool5的博客
10-06 141
题目1️⃣: 数组中的逆序对数. 思路: 利用归并排序的思想. 首先将数组分为两两组合, 再对两两组合排序, 排序的过程中记录是不是逆序对数. 然后再对这些组合排序, 在排序的过程中, 再对左右两边的子串进行逆序的计数.然后再对这些组合排序, 在排序的过程中, 再对左右两边的子串进行逆序的计数. 采用递归, 终止条件肯定是字符串的字数小于2. 每次对字符串分两组递归. 计数的条件是当前面的数...
排序算法--归并排序(MergeSort)原理、适用场景及代码示例
penriver的博客
10-18 3285
集合排序算法 归并排序 和快速排序一样，归并排序也是一种分治算法。它将输入数组分成两半，为这两半调用自己，然后合并已排序的两半。 merge函数的作用是合并两个部分。合并merge(arr, l, m, r)是一个关键过程，它假设arr[l…m] 和 arr[m+1…r] 已经排好序，并将两个已排序的子数组合并为一个。 分治【 Divide and Conquer 】算法介绍 Divide : 将问题划分为更小的子问题。 Conquer: 通过递归调用来解决子问题，直到解决为止。 combine 或 mer
java归并排序（Merge Sort）—— 详解 + 案例 +时间复杂度
qq_46533383的博客
12-15 4819
文章目录前言排序原理代码实现时间复杂度 前言 归并排序是建立在归并操作上的一种有效的排序算法，该算法是采用分治法的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。 排序原理 需求： 排序前：{8,4,5,7,1,3,6,2} 排序后：{1,2,3,4,5,6,7,8} 排序原理： 尽可能的一组数据拆分成两个元素相等的子组，并对每一个子组继续拆分，直到拆分后的每个子组的元素个数是1为止。 将相邻的两个
合并两个无序数组，并且按照从小到大的顺序排列
jiangfullll的专栏
01-28 7285
package algori; import java.util.Random; /** * Created by jiang on 2018/1/28. */ public class MergeArray { public static void main(String[] args) { MergeArray mergeArray = new MergeAr
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...
基本算法：合并排序
编程故事的地方
02-29 423
每个程序员都需要了解他们的算法和数据结构。 在研究它们时，您需要确保确切了解它的功能，时间和空间的复杂性以及采用这种方法的原因，并且不仅能够对其进行编码，而且能够手动执行。 这就是基本算法的全部意义。 欢迎来到基本算法的第一次安装，今天在这里，我们将介绍合并排序。 合并排序是用于对大型数据集进行排序的最可靠的一致且性能最佳的排序算法之一，与快速排序相比， 最糟糕的情况是平均执行的比较少了近40...
归并排序给定一个数列,用归并排序算法把它排成升序c语言吧,C++习题-归并排序...
weixin_30746159的博客
05-23 620
有数列{6 58 14 2 19 354 684 4}(1)申请一个数组q，准备存放合并后的序列(2)将原序列拆分为左序列{6 58 14 2}与右序列{19 354 68 4}(3)将左右数组分别有序排列成{2 6 14 58}及{4 19 68 354} [这一过程通过递归重复(2)～(7)实现](4)设定i，j分别为两序列的初始位置(5)比较i，j位置对应元素大小，选择小的放入数组q，同时将...
给定一个数列，用归并排序算法把它排成升序。
08-09
输入： 第一行是一个整数n（n不大于10000），表示要排序的数的个数； 下面一行是用空格隔开的n个整数。 输出： 输出排序后的数列，每个数字占一行。 输入样例： 5 3 2 1 4 5 输出样例： 1 2 3 4 5
归并排序给定一个数列,用归并排序算法把它排成升序c语言吧,算法竞赛入门实验指导书201710s.pdf...
weixin_39611930的博客
05-23 181
《算法竞赛入门》实验指导书2014年1月目 录实验 1：地铁线路问题 1实验 2 ：装箱问题 6实验 3 ：数字三角形 10实验 4 ：报数问题 13实验 5 ：邮局选址问题 15实验 6 ：归并排序 19实验 7 ：最少硬币问题 22实验 8 ：装载问题 24实验 9 ：防卫导弹问题 27实验 10 ：堡垒问题 30实验 11 ：最长公共子序列 34附录 1 ：ACM 国际...
LeetCode 面试题10.01 合并排序 C语言
weixin_44916945的博客
05-29 88
题目描述 给定两个排序后的数组 A 和 B，其中 A 的末端有足够的缓冲空间容纳 B。 编写一个方法，将 B 合并入 A 并排序。 初始化 A 和 B 的元素数量分别为 m 和 n。 示例: 输入: A = [1,2,3,0,0,0], m = 3 B = [2,5,6], n = 3 输出: [1,2,2,3,5,6] 说明: A.length == n + m 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/s...
面经算法题手撕补充
向着星辰大海
07-12 618
目录 Perfect Squares 完全平方数 合并K个链表（hard） 相同原理：最小区间原题 LRU Cache（双向链表+hash map） 查找兄弟单词 快速幂 找出字符数组中出现次数最多的字符 给你一个数组，求一个k值，使得前k个数的方差 + 后面n-k个数的方差最小 。 我手中有一堆扑克牌， 但是观众不知道它的顺序。 两个排序好的数组，找第k小的数字，要求logn...
归并排序和快速排序比较
热门推荐
Jymn_Chen
12-30 3万+
最近在做一个算法实验：归并排序和快速排序的比较。 这两种算法在排序方面是非常非常的通俗的了，权威的文献和网上的相关文章也是一大堆，在这里就简单贴下代码，写下个人从这个实验中学到的东西。 先说说个人对这两个算法的理解： 归并排序，简单来说就是先将数组不断细分成最小的单位，然后每个单位分别排序，排序完毕后合并，重复以上过程最后就可以得到排序结果。 快速排序，简单来说就是先选定一个基准元素，然后
刷题笔记13——合并两个排序的链表（图文说明）
CSDN_dzh的博客
11-13 261
题目描述 输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。 方法1：使用vector保存，再将元素存到新链表中 ① 首先有几种特殊情况，需要返回对应的值 思路：考虑一般的情况 这里为了避免去创建结点，想了一个办法： 就是让新链表的表头指向pHead1，然后链表1到头后再将pHead2连接上去，这样，在后面赋值的时候就可以一一对应起来。 ② 取...
排序算法及并行分析
secyb的博客
05-05 1万+
最近学了高性能计算这门课程，老师让用OpenMP、MPI或mapReduce写个大作业。我之前刚好在写排序，于是我就将常用的排序写了一遍并且用OpenMP进行并行，计算加速比等数据进行分析。在这篇文章中我主要介绍八大基本排序的实现原理及代码，以及对这些算法进行改进从而让它们可以并行，并且对他们的性能进行了比较。首先跟大家分享一下我的心得体会，所谓排序算法，就是通过调整元素的位置达到想要的结果。我...
算法(第四版)学习笔记之归并排序的优化
seabear008的专栏
09-08 3819
在之前的文章中记录过归并排序的笔记，只是学习了基本的排序原理，并未对归并排序有更加深入的了解，现在重新回过头来仔细研究了一下归并排序的算法优化。归并排序的优点在于我们只需要比遍历整个数组多个对数因子的时间就能将一个庞大的数组排序，即对于长度为N的任意数组，自顶向下的归并排序(之前的文章中有自顶向上和自底向上两种归并排序的写法)需要1/2NlgN至NlgN次比较次数，最多需要访问数组6NlgN次。那
【算法学习笔记】9：归并排序与统计逆序对
LauZyHou的笔记
01-28 536
归并排序 归并排序的思想是基于分治法，其思路是： 将待排序区间平分成左右两半，左右两侧分别递归地做归并排序。 将这两个有序的区间合并（每次落一个较小的下来），就将这个区间排好序了。 #include <iostream> using namespace std; const int N = 1e5 + 10; int a[N], tmp[N]; void merge_sort(int q[], int l, int r) { // 如果区间里已经<=1个数了，就直接返回
算法学习—002—js实现归并排序—mergeSort
chenmoquan的专栏
05-27 3023
var count=0; var A=['x','x','x','x','x','x','x','x','x',2,4,5,7,1,2,3,6,'x']; document.write("数组A ：") for (var n = 0; n < A.length; n++) { document.write(A[n] + " "); } document.write("") functi

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

星河阅卷

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

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

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

打赏作者

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

抵扣说明：

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

余额充值