归并排序算法及优化（java）

最新推荐文章于 2024-09-27 00:45:01 发布
最新推荐文章于 2024-09-27 00:45:01 发布
阅读量1.2k 收藏 19
点赞数 25
分类专栏： 数据结构与算法（JAVA） 文章标签： java 排序算法 归并排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43841461/article/details/141331868
版权

目录

1.1 引言

1.2 归并排序的历史

1.3 归并排序的基本原理

1.3.1 分治策略

1.3.2 算法流程

1.3.3 合并过程

1.4 归并排序的实现

1.4.1 递归方式

1.4.2 迭代方式

1.4.3 递归与迭代的区别和优势

1.5 归并排序的时间复杂度

1.5.1 分析

1.6 归并排序的稳定性

1.7 著名案例

1.7.1 应用场景

1.7.2 具体案例

1.8 归并排序的优化方案

1.8.1 使用插入排序优化小数组

1.8.2 使用双缓冲区

1.8.3 自底向上归并排序

1.9 总结

1.1 引言

归并排序是一种基于分治策略的高效排序算法，广泛应用于计算机科学中。本文将详细介绍归并排序的历史背景、工作原理，并通过具体案例来阐述其应用。此外，我们将探讨归并排序的不同实现方式，并给出相应的Java代码示例。

1.2 归并排序的历史

归并排序的思想最早可以追溯到19世纪末，但其现代形式是由约翰·冯·诺伊曼在20世纪40年代提出的。冯·诺伊曼是一位杰出的数学家、物理学家和计算机科学家，他为计算机科学的发展做出了巨大贡献。

归并排序之所以重要，是因为它具有稳定的排序特性，并且在平均和最坏情况下都表现出 O(nlogn) 的时间复杂度，这使得它成为许多应用场景下的首选排序算法之一。

1.3 归并排序的基本原理

1.3.1 分治策略

归并排序遵循分治策略，该策略可以概括为三个步骤：

  1. 分解：将待排序的序列分成两个子序列。
  2. 解决：递归地对这两个子序列进行排序。
  3. 合并：将排序好的两个子序列合并成一个有序序列。

1.3.2 算法流程

归并排序的具体步骤如下：

  1. 如果序列长度为1，则已经排序完成。
  2. 将序列从中间位置分成两个子序列。
  3. 对两个子序列分别进行归并排序。
  4. 将两个已排序的子序列合并成一个有序序列。

1.3.3 合并过程

合并过程是归并排序的关键步骤之一，其核心在于比较两个子序列中的元素，并依次取出较小的元素放入新序列中，直到其中一个子序列为空，然后将另一个子序列剩余的元素依次加入新序列中。

1.4 归并排序的实现

1.4.1 递归方式

递归方式是归并排序最常见的实现方式。下面是一个使用递归实现的归并排序的Java代码示例：

public class MergeSortRecursive {

    public static void mergeSort(int[] array) {
        if (array == null || array.length <= 1) {
            return;
        }
        mergeSort(array, 0, array.length - 1);
    }

    private static void mergeSort(int[] array, int left, int right) {
        if (left < right) {
            int middle = (left + right) / 2;
            mergeSort(array, left, middle);
            mergeSort(array, middle + 1, right);
            merge(array, left, middle, right);
        }
    }

    private static void merge(int[] array, int left, int middle, int right) {
        int n1 = middle - left + 1;
        int n2 = right - middle;

        int[] leftArray = new int[n1];
        int[] rightArray = new int[n2];

        for (int i = 0; i < n1; ++i) {
            leftArray[i] = array[left + i];
        }
        for (int j = 0; j < n2; ++j) {
            rightArray[j] = array[middle + 1 + j];
        }

        int i = 0, j = 0, k = left;
        while (i < n1 && j < n2) {
            if (leftArray[i] <= rightArray[j]) {
                array[k] = leftArray[i];
                i++;
            } else {
                array[k] = rightArray[j];
                j++;
            }
            k++;
        }

        while (i < n1) {
            array[k] = leftArray[i];
            i++;
            k++;
        }

        while (j < n2) {
            array[k] = rightArray[j];
            j++;
            k++;
        }
    }

    public static void main(String[] args) {
        int[] array = {12, 11, 13, 5, 6, 7};
        System.out.println("原始数组:");
        printArray(array);

        mergeSort(array);

        System.out.println("排序后的数组:");
        printArray(array);
    }

    private static void printArray(int[] array) {
        for (int value : array) {
            System.out.print(value + " ");
        }
        System.out.println();
    }
}

1.4.2 迭代方式

迭代方式可以减少递归调用带来的额外开销。下面是一个使用迭代实现的归并排序的Java代码示例：

public class MergeSortIterative {

    public static void mergeSort(int[] array) {
        int n = array.length;
        int currentSize;  // 子数组的当前大小
        int leftStart;    // 当前子数组的起始索引

        for (currentSize = 1; currentSize < n - 1; currentSize = 2 * currentSize) {
            for (leftStart = 0; leftStart < n - 1; leftStart += 2 * currentSize) {
                int mid = Math.min(leftStart + currentSize - 1, n - 1);
                int rightEnd = Math.min(leftStart + 2 * currentSize - 1, n - 1);
                merge(array, leftStart, mid, rightEnd);
            }
        }
    }

    private static void merge(int[] array, int leftStart, int mid, int rightEnd) {
        int n1 = mid - leftStart + 1;
        int n2 = rightEnd - mid;

        int[] leftArray = new int[n1];
        int[] rightArray = new int[n2];

        for (int i = 0; i < n1; ++i) {
            leftArray[i] = array[leftStart + i];
        }
        for (int j = 0; j < n2; ++j) {
            rightArray[j] = array[mid + 1 + j];
        }

        int i = 0, j = 0, k = leftStart;
        while (i < n1 && j < n2) {
            if (leftArray[i] <= rightArray[j]) {
                array[k] = leftArray[i];
                i++;
            } else {
                array[k] = rightArray[j];
                j++;
            }
            k++;
        }

        while (i < n1) {
            array[k] = leftArray[i];
            i++;
            k++;
        }

        while (j < n2) {
            array[k] = rightArray[j];
            j++;
            k++;
        }
    }

    public static void main(String[] args) {
        int[] array = {12, 11, 13, 5, 6, 7};
        System.out.println("原始数组:");
        printArray(array);

        mergeSort(array);

        System.out.println("排序后的数组:");
        printArray(array);
    }

    private static void printArray(int[] array) {
        for (int value : array) {
            System.out.print(value + " ");
        }
        System.out.println();
    }
}

1.4.3 递归与迭代的区别和优势

  • 递归方式：
    • 优点：代码简洁易懂，更容易理解和实现。
    • 缺点：可能因为大量的递归调用而消耗较多的栈空间，导致性能下降。
  • 迭代方式：
    • 优点：减少了递归调用的开销，提高了空间效率。
    • 缺点：代码实现稍微复杂一些。

1.5 归并排序的时间复杂度

1.5.1 分析

归并排序的时间复杂度分析如下：

  • 最好情况：O(nlogn)
  • 平均情况：O(nlogn)
  • 最坏情况：O(nlogn)

1.6 归并排序的稳定性

归并排序是一种稳定的排序算法，这意味着相等的元素在排序前后保持原有的相对顺序不变。这是因为它在合并两个子数组时，总是先选择左边子数组的元素（如果两个元素相等的话），从而保证了稳定性。

1.7 著名案例

1.7.1 应用场景

归并排序在多种场景中都有广泛应用，特别是在需要稳定排序的情况下，或者当数据集太大而无法一次性放入内存中时。下面通过一个具体的案例来说明归并排序的应用。

1.7.2 具体案例

案例描述：假设我们有一份包含1000条记录的数据库，需要对这些记录按照日期进行排序。这些记录分布在不同的磁盘块上，每次只能读取一定数量的数据到内存中进行处理。

解决方案：使用归并排序可以有效地解决这个问题。

  1. 第一步：将数据分成足够小的部分，以便每次能够将一部分数据加载到内存中进行排序。
  2. 第二步：对每个小部分进行排序。
  3. 第三步：将排序好的部分合并成更大的有序部分。
  4. 第四步：重复上述过程，直到所有数据都被排序好为止。

具体步骤：

  1. 分解：将1000条记录分成100个子集，每个子集包含10条记录。
  2. 排序：对每个子集进行排序。
  3. 合并：将已排序的子集合并成更大的有序子集。
  4. 重复：重复合并过程，直到所有记录都被排序好。

效果：最终结果是一个完全排序好的记录集合，而且这个过程充分利用了有限的内存资源，避免了一次性加载所有数据到内存中的问题。

1.8 归并排序的优化方案

1.8.1 使用插入排序优化小数组

对于小规模的数组，插入排序的性能往往优于归并排序。这是因为插入排序的常数因子较小，且在小规模数据上的表现较好。因此，可以考虑当数组规模小于某个阈值时，使用插入排序代替归并排序。

优化方法：

  1. 确定阈值：设定一个阈值，当子数组的大小小于该阈值时，使用插入排序代替归并排序。
  2. 插入排序实现：在归并排序中嵌入插入排序，用于处理小规模子数组。

示例代码：

private static final int INSERTION_SORT_THRESHOLD = 10;

private static void insertionSort(int[] array, int left, int right) {
    for (int i = left + 1; i <= right; i++) {
        int key = array[i];
        int j = i - 1;
        while (j >= left && array[j] > key) {
            array[j + 1] = array[j];
            j--;
        }
        array[j + 1] = key;
    }
}

private static void mergeSortOptimized(int[] array, int left, int right) {
    if (left < right) {
        if (right - left <= INSERTION_SORT_THRESHOLD) {
            insertionSort(array, left, right);
        } else {
            int middle = (left + right) / 2;
            mergeSortOptimized(array, left, middle);
            mergeSortOptimized(array, middle + 1, right);
            merge(array, left, middle, right);
        }
    }
}

1.8.2 使用双缓冲区

在归并排序的过程中，为了合并两个子数组，通常需要创建一个新的辅助数组。但是，创建多个辅助数组会占用较多的内存空间。通过使用双缓冲区的方法，可以减少内存使用。

优化方法：

  1. 分配两个辅助数组：一个用于当前的排序操作，另一个用于下一阶段的排序。
  2. 交替使用：每次排序时使用不同的辅助数组。

示例代码：

public static void dualBufferMergeSort(int[] array) {
    int n = array.length;
    int[] temp1 = new int[n];
    int[] temp2 = new int[n];
    int[] temp = temp1;

    for (int size = 1; size < n; size *= 2) {
        for (int leftStart = 0; leftStart < n - 1; leftStart += 2 * size) {
            int mid = Math.min(leftStart + size - 1, n - 1);
            int rightEnd = Math.min(leftStart + 2 * size - 1, n - 1);
            merge(array, temp, leftStart, mid, rightEnd);
        }
    }

    if (temp != temp1) {
        System.arraycopy(temp2, 0, array, 0, n);
    }
}

private static void merge(int[] array, int[] temp, int leftStart, int mid, int rightEnd) {
    int n1 = mid - leftStart + 1;
    int n2 = rightEnd - mid;
    System.arraycopy(array, leftStart, temp, 0, n1);
    System.arraycopy(array, mid + 1, temp, n1, n2);

    int i = 0;
    int j = 0;
    int k = leftStart;

    while (i < n1 && j < n2) {
        if (temp[i] <= temp[n1 + j]) {
            array[k] = temp[i];
            i++;
        } else {
            array[k] = temp[n1 + j];
            j++;
        }
        k++;
    }

    while (i < n1) {
        array[k] = temp[i];
        i++;
        k++;
    }

    while (j < n2) {
        array[k] = temp[n1 + j];
        j++;
        k++;
    }
}

1.8.3 自底向上归并排序

传统的归并排序采用的是自顶向下的递归方式，但这种方式可能会导致大量的递归调用，增加额外的空间开销。自底向上的归并排序采用迭代的方式，从最小的子数组开始逐步合并。

优化方法：

  1. 初始化：设置初始子数组大小为1。
  2. 迭代合并：不断增大子数组的大小，每次合并两个相邻的子数组。
  3. 循环：重复此过程直到整个数组排序完成。

示例代码：

public static void bottomUpMergeSort(int[] array) {
    int n = array.length;
    int currentSize;  // 子数组的当前大小
    int leftStart;    // 当前子数组的起始索引

    for (currentSize = 1; currentSize < n - 1; currentSize = 2 * currentSize) {
        for (leftStart = 0; leftStart < n - 1; leftStart += 2 * currentSize) {
            int mid = Math.min(leftStart + currentSize - 1, n - 1);
            int rightEnd = Math.min(leftStart + 2 * currentSize - 1, n - 1);
            merge(array, leftStart, mid, rightEnd);
        }
    }
}

1.9 总结

归并排序是一种高效且稳定的排序算法，它通过分治策略来实现。本文详细介绍了归并排序的历史背景、工作原理以及其实现细节，并通过一个具体案例展示了归并排序在实际应用中的优势。无论是在理论研究还是实际工程中，归并排序都是一个值得深入了解的重要算法。

爱吃土豆的程序员
关注
专栏目录
Java实现归并排序算法详解及优化
qq_40254606的博客
07-14 819
本文将详细讲解如何使用Java实现归并排序算法，并结合图解和实例代码，帮助您全面理解这一高级排序算法。同时，我们探讨了归并排序的优化方法，包括使用插入排序优化小数组，以提高其性能。归并排序是一种分治算法，它将数组分成两个子数组，分别对两个子数组进行排序，然后将排好序的子数组合并成一个有序数组。初始数组: 38, 27, 43, 3, 9, 82, 10。排序结果: 3, 9, 10, 27, 38, 43, 82。数组: 38, 27, 43, 3, 9, 82, 10。右半部分: 9, 82, 10。
归并排序算法（java实现）
qq_45954420的博客
03-10 1万+
基本思想 归并排序是由递归实现的，主要是分而治之的思想，也就是通过将问题分解成多个容易求解的局部性小问题来解开原本的问题的技巧。 归并排序在合并两个已排序数组时，如果遇到了相同的元素，只要保证前半部分数组优先于后半部分数组， 相同元素的顺序就不会颠倒。所以归并排序属于稳定的排序算法。 每次分别排左半边和右半边，不断递归调用自己，直到只有一个元素递归结束，开始回溯，调用 merge 函数，合并两个有序序列，再合并的时候每次给末尾追上一个最大 int 这样就不怕最后一位的数字不会被排序。 归并排序的效率
Java八大算法：归并排序
qq_50838572的博客
02-10 3861
一、什么是归并排序？ 1.概念 归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法，归并排序对序列的元素进行逐层折半分组，然后从最小分组开始比较排序，合并成一个大的分组，逐层进行，最终所有的元素都是有序的 2.算法原理 基本思想 归并排序就是递归得将原始数组递归对半分隔，直到不能再分（只剩下一个元素）后，开始从最小的数组向上归并排序。 将一个数组拆分为两个，从中间点拆开，通过递归操作来实现一层一层拆分。 从左右数组中选择小的元素放入到临时空间，并移动下标到下一位置。 重复
归并排序算法
热门推荐
生活需要深度
06-29 1万+
本章介绍排序算法中的归并排序。内容包括： 1. 归并排序介绍 2. 归并排序图文说明 3. 归并排序的时间复杂度和稳定性 4. 归并排序实现 4.1 归并排序C实现 4.2 归并排序C++实现 4.3 归并排序Java实现转载请注明出处：归并排序 - 如果天空不死 - 博客园更多排序和算法请参考：数据结构与算法系列 目录将两个的有序数列合并成一个有序数列，我们称之为"归并"。 归并排序(Merge Sort)就是利用归并思想对数列进行排序。根据具体的实现，归并排序包括"从上往下"和"从下往上"2种方式
Java【归并排序】算法, 大白话式图文解析(附代码)
yzhcjl_的博客
03-15 2578
学数据结构与算法怎么少得了排序? 七大排序算法之[归并排序]详细图解 , 结尾附[总体对比分析]
（十）Java算法：归并排序（详细图解）
嘉禾嘉宁papa
11-23 6209
归并排序算法详细图解
归并（合并）排序算法（Java实现）
Lyhdreamer的博客
01-16 3079
归并排序算法的思想，实现步骤，二路归并算法步骤，二路归并排序算法代码实现（Java）
Java实现插入排序算法详解及优化
qq_40254606的博客
07-14 762
本文将详细讲解如何使用Java实现插入排序算法，并结合图解和实例代码，帮助您全面理解这一基础排序算法。同时，我们探讨了插入排序的优化方法，包括二分查找优化和哨兵优化，以提高其性能。在标准插入排序中，插入元素时需要从后向前逐一比较，找到合适的位置插入。插入排序的基本思想是：通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入6到正确位置: 5, 6, 11, 12, 13。已排序子数组: 5, 11, 12, 13, 6。初始数组: 12, 11, 13, 5, 6。
Java归并排序
qq_38875964的博客
12-11 2753
归并排序（Merge Sort）是应用分治思想的一个典型例子。把一个待排序序列拆分为两个子序列，分别对两个子序列排序，子序列排序时也采用相同的方法，直至拆分后的两个子序列都是有序的，即长度为1的序列天然有序，这时停止拆分，将两个有序的子序列归并为一个更大的有序序列，与之前拆分时的路径相反，不断的归并有序子序列，最终归并为一个序列。这种将两个有序序列归并为一个有序序列的操作称为二路归并。
深入探究TimSort对归并排序算法的优化及Java实现
09-02
**深入探究TimSort对归并排序算法的优化及Java实现** **一、TimSort简介** TimSort是由Tim Peters在Python语言中设计的一种排序算法，它基于归并排序，并且进行了大量的优化，尤其针对已部分有序的数据。TimSort的...
如何使用Java实现归并排序算法，程序详细解读
06-17
归并排序：如何使用Java实现归并排序算法，程序详细解读； 归并排序：如何使用Java实现归并排序算法，程序详细解读； 归并排序：如何使用Java实现归并排序算法，程序详细解读； 归并排序：如何使用Java实现归并排序...
java实现归并排序算法
09-03
归并排序是一种高效的排序算法，它的基本思想是利用分治法（Divide and Conquer）将大问题分解为小问题来解决。分治法的核心在于将一个复杂的问题分解成两个或更多的相同或相似的子问题，再将子问题分解成更小的子...
Java 归并排序算法、堆排序算法实例详解
08-30
Java 归并排序算法和堆排序算法实例详解 Java 归并排序算法是将两个或两个以上有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。 基本...
java 中归并排序算法详解
08-29
Java 中归并排序算法详解 Java 中归并排序算法是一种时间复杂度为 O(N logN) 的排序算法，因而其在平常生活工作中应用非常广泛。下面是对 Java 中归并排序算法的详细解释： 算法思想 归并排序算法顾名思义，是一...
Spring Boot 学习和使用
cesske的博客
09-24 1089
Spring Boot是一款开源的Java Web应用框架，旨在简化Spring应用的初始搭建以及开发过程。Spring Boot通过整合Spring技术栈中的诸多关键组件，为开发者提供了一种快速、简便的Spring应用开发方式。它遵循“约定优于配置”的原则，通过自动配置、起步依赖和内置的Servlet容器，极大地简化了传统Spring应用的配置和部署过程。Spring Boot通过其自动化配置、起步依赖、内嵌服务器等特性，极大地简化了Spring应用的开发和部署过程。
工厂模式的介绍及实现
户伟伟的博客
09-25 116
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
基于Hive和Hadoop的哔哩哔哩网站分析系统
最新发布
图南的博客
09-27 423
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
智能BI平台项目
2302_79400545的博客
09-22 238
BI商业智能：数据可视化、报表可视化系统。
Java实现：快速排序与归并排序算法详解
该资源是基于Java实现的快速排序和归并排序算法。提供的代码片段展示了如何使用这两种经典的排序算法对一个整数数组进行排序。 快速排序算法是一种高效的排序算法，由C.A.R. Hoare在1960年提出。它的基本思想是通过...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值