学习笔记-数据结构与算法-归并排序

关注

原创最新推荐文章于 2026-03-14 01:43:06 发布 333 阅读 AI 写同款· GEO 优化 ›

数据结构与算法之美 | 学习笔记09 ——归并排序&快速排序 归并排序和快速排序都用到了分治思想，的时间复杂度都为O(nlogn)O(nlogn)O(nlogn)，适合大规模的数据排序。一、归并排序（Merge Sort） 1. 归并排序实现分治算法一般都是用递归来实现的，分治是解决问题的处理思想，递归是一种编程技巧。用递归来代码实现归并排序，首先写出递推公式的伪代码：递推公式： merge_sort(p…r) = merge(merge_sort(p…q), merge_sort(q+1…r)) //下标p到r之间的数组排序，转化为p到q和q+1到r的数组排阅读详情

归并排序核心思想：

将一个数组一分二，然后将两个数组分别排序，最后将两个有序数据合并，就完成了归并排序。

归并排序使用的是分治思想，分而治之，将一个大问题分解为n个小问题，小问题解决了，大问题也就解决了。

归并排序一般使用递归来实现，要写出递归代码的关键，写出递推公式，找到终止条件。

归并排序的递推公式：

merge_sort(p…r) = merge(merge_sort(p…q),merge_sort(q+1….r))

终止条件:q>= r

递推公式注释：

merge_sort(p…r)表示我们要排序的数组的下标在p…r区间，将这个大的数组的排序问题转化为了两个子数组排序的问题。即排序p到q区间和q+1到r区间，q=(p+r)/2,当这两个数组排序完成后，使用merge合并函数进行数组的合并，整个数组即可为有序。

再来说说merge合并函数

还是先画个图

代码实现

public class MergerSort<T> implements SortInf<T> {

@Override
public void sort(T[] data) {

    if (null == data || data.length <= 1) {
      return;
    }
    if (!(data[0] instanceof Comparable)) {
      throw new IllegalArgumentException("data not implement compator interface");
    }

    // 1,归并排序操作
    recurstion(data, 0, data.length - 1);
}

private void recurstion(T[] data, int start, int end) {
    // 递归的终止条件
    if (start >= end) {
      return;
    }

    // 1,找到中间的索引位置
    int midIndex = (start + end) / 2;
    // 进行左半边数据递归操作
    recurstion(data, start, midIndex);
    // 进行右半边数据递归操作
    recurstion(data, midIndex + 1, end);

    // 进行mergesort的合并操作
    merget(data, start, midIndex, midIndex + 1, end);
}

/**
   * 进行数据的合并操作
   *
   * @param data 原始数据
   * @param leftstart 左开始索引
   * @param leftEnd 左结束索引
   * @param rightStart 右边开始索引
   * @param end 右边结束索引
   */
private void merget(T[] data, int leftstart, int leftEnd, int rightStart, int end) {

    int dataLength = end - leftstart + 1;

    // 声明一个目标的数组大小
    T[] target = (T[]) Array.newInstance(data[0].getClass(), dataLength);
    int tarIndex = 0;

    int leftIndex = leftstart;
    int rightIndex = rightStart;

    while (leftIndex <= leftEnd && rightIndex <= end) {
      // if i < j ? -1 == 0 > 1
      if (((Comparable) data[leftIndex]).compareTo(data[rightIndex]) > 0) {
        target[tarIndex++] = data[rightIndex++];
      } else {
        target[tarIndex++] = data[leftIndex++];
      }
    }

    // 将剩余的值拷贝到目标数组中
    if (leftIndex <= leftEnd) {
      for (int i = leftIndex; i <= leftEnd; i++) {
        target[tarIndex++] = data[i];
      }
    } else if (rightIndex <= end) {
      for (int i = rightIndex; i <= end; i++) {
        target[tarIndex++] = data[i];
      }
    }

    // 将数据拷贝回原数组中
    for (int i = leftstart; i <= end; i++) {
      data[i] = target[i - leftstart];
    }

    System.out.println(Arrays.toString(data));
}
}