归并排序(详情讲解)

最新推荐文章于 2024-09-16 11:25:31 发布

程序员爱摸鱼

最新推荐文章于 2024-09-16 11:25:31 发布

阅读量5k

点赞数 4

分类专栏：归并排序文章标签：排序算法算法数据结构

本文链接：https://blog.csdn.net/lcshen1234/article/details/124866571

版权

归并排序专栏收录该内容

1 篇文章 0 订阅

订阅专栏

1.0 概述

归并排序，Merging Sort
归并排序：将两个或两个以上的有序表合并成一个新的有序表。
归并排序分类：
- 二路归并排序
- 多路归并排序
二路归并排序：将两个有序表合并成一个有序表的归并排序，称为二路归并排序。也就是将两个相邻的记录有序子序列归并为一个记录的有序序列。
二路归并排序基本思想：
- 将待排序记录r[0]到r[n-1]看成是n个长度为1的有序子表
- 把这些子表依次两两归并，便得到[n/2]个有序子表
- 然后，再把这[n/2]个有序的子表进行两两归并
- 如此重复，直到最后得到一个长度为n的有序表为止

2.0 两个相邻有序序列归并：分析

假设前后两个有序序列分别存放在一维数组人的r[h..m] 和 r[m+1..t]中，同时，提供另一个有序数组order，用于存放归并后的数据
首先在两个有序序列中，分别从第1个记录开始进行对应关键字的比较，将关键字值较小的记录放入有序数据order中
然后，依次对两个有序序列中剩余记录进行相同操作，直到两个有序序列中的所有记录都加入到有序数组order中为止
最后，这个有序数组order中存放的记录序列就是归并排序后的结果。

2.1两个相邻有序序列归并：算法

代码

/**
 *
 * @param r 待排序的数组（多个有序子序列）
 * @param order 已经排序号的数组
 * @param h 第一个子序列开始的位置
 * @param m 第一个子序列结束的位置，第二个子序列开始的位置为m+1
 * @param t 第二个子序列结束的位置
 */
//把r数组中两个相邻的有序表r[h]~r[m]和r[m+1]~r[t]归并为一个有序表order[h]~order[t]
public void merge(RecordNode[] r, RecordNode[] order, int h, int m, int t) {
    int i = h, j = m + 1, k = h;
    while (i <= m && j <= t) {                  // 将r中两个相邻子序列归并到order中
        if (r[i].key.compareTo(r[j].key) <= 0) {// 较小值复制到order中
            order[k++] = r[i++];
        } else {
            order[k++] = r[j++];
        }
    }
    while (i <= m) {                // 将前一个子序列剩余元素复制到order中
        order[k++] = r[i++];
    }
    while (j <= t) {                // 将后一个子序列剩余元素复制到order中
        order[k++] = r[j++];
    }
}

测试

public class TestSeqList13_merge {
    public static void main(String[] args) throws Exception {
        int[] arr = {39,52,67,95,8,25,56,70};
        SeqList seqList = new SeqList(arr.length);
        System.out.print("序列号:");
        for (int i = 0; i < arr.length; i++) {
            System.out.print("  " + i);
            seqList.insert(i, new RecordNode(arr[i]));
        }
        System.out.println();
        System.out.print("归并前:");
        seqList.display();
        // 归并操作
        System.out.print("归并后:");
        RecordNode[] temp = new RecordNode[arr.length];
        // 待归并的数据 {39,52,67,95}和 {8,25,56,70}
        seqList.merge(seqList.r,temp,0,3, 7);
        // 输出归并后的数据
        for (int i = 0; i < temp.length; i++) {
            String str = temp[i].key.toString().length() == 1 ? "  " : " ";
            System.out.print(str + temp[i].key.toString());
        }
        System.out.println();
    }
}
//归并操作
//序列号:  0  1  2  3  4  5  6  7
//归并前: 39 52 67 95  8 25 56 70
//归并后:  8 25 39 52 56 67 70 95

4.0 一趟归并：分析

假设r为待排序的数组，n为待排序列的长度，s为待归并的有序子序列的长度，一趟归并排序的结果存放在数组order中。
两个相邻的有序序列，第一趟处理的长度为1，第二趟为2，第三趟为4 ... ，也就是说s的取值1/2/4/8...
步骤：
1. 根据长度s，进行两两归并
2. 归并操作时，如果最后两个序列长度不等，将剩余内容归并到有序表中
3. 归并操作时，如果有未参加归并操作的内容，直接复制到order中

4.1 一趟归并：算法

代码

//把数组r[n]中每个长度为s的有序表两两归并到数组order[n]中
//s 为子序列的长度，n为排序序列的长度
public void mergepass(RecordNode[] r, RecordNode[] order, int s, int n) {
    System.out.print("子序列长度s=" + s + " ");
    int p = 0;  //p为每一对待合并表的第一个元素的下标，初值为0
    while (p + 2 * s - 1 <= n - 1) {  //两两归并长度均为s的有序表
        merge(r, order, p, p + s - 1, p + 2 * s - 1);
        p += 2 * s;
    }
    if (p + s - 1 < n - 1) {  //归并最后两个长度不等的有序表
        merge(r, order, p, p + s - 1, n - 1);
    } else {
        for (int i = p; i <= n - 1; i++) //将剩余的有序表复制到order中
        {
            order[i] = r[i];
        }
    }
}

测试

public class TestSeqList14_mergepass2 {
    public static void main(String[] args) throws Exception {
        int[] arr = {8,25,39,52,52,67,70,95,56};
        SeqList seqList = new SeqList(arr.length);
        System.out.print("序列号:\t\t ");
        for (int i = 0; i < arr.length; i++) {
            System.out.print("  " + i);
            seqList.insert(i, new RecordNode(arr[i]));
        }
        System.out.println();
        System.out.print("初始值:\t\t ");
        seqList.display();
        // 一趟归并算法
        RecordNode[] temp = new RecordNode[arr.length];
        int s = 8;
        seqList.mergepass(seqList.r, temp, s, arr.length);
        for (int i = 0; i < temp.length; i++) {
            String str = temp[i].key.toString().length() == 1 ? "  " : " ";
            System.out.print(str + temp[i].key.toString());
        }
        System.out.println();

    }
}
//一趟归并算法
//序列号:		 0  1  2  3  4  5  6  7  8
//初始值:		 8 25 39 52 52 67 70 95 56
//子序列长度s=8   8 25 39 52 52 56 67 70 95

5.0 二路归并：分析

设置待排序的n个记录保存在数组r[n]中，归并过程中需要引入辅助数组temp[n]，
第1趟由r归并到temp，第2趟由temp归并到r
如此反复，直到n个记录成为一个有序表为止。

在归并过程中，为了将最后的排序结果仍置于数组中，需要进行的归并趟数为偶数，
如果实际上只需奇数趟即可生成，那么最后还要进行一趟，正好此时temp中的n个有序记录，为一个长度不大于s的表，将会背直接复制r。

5.1 二路归并：算法

代码

public class TestSeqList14_mergepass {
    public static void main(String[] args) throws Exception {
        int[] arr = {52,39,67,95,70,8,25,52,56};
        SeqList seqList = new SeqList(arr.length);
        System.out.print("序列号:\t\t ");
        for (int i = 0; i < arr.length; i++) {
            System.out.print("  " + i);
            seqList.insert(i, new RecordNode(arr[i]));
        }
        System.out.println();
        System.out.print("初始值:\t\t ");
        seqList.display();
        // 一趟归并算法
        RecordNode[] temp = new RecordNode[arr.length];
        int s = 1;
        seqList.mergepass(seqList.r, temp, s, arr.length);
        for (int i = 0; i < temp.length; i++) {
            String str = temp[i].key.toString().length() == 1 ? "  " : " ";
            System.out.print(str + temp[i].key.toString());
        }
        System.out.println();

    }
}
//一趟归并算法
//序列号:		 0  1  2  3  4  5  6  7  8
//初始值:		52 39 67 95 70  8 25 52 56
//子序列长度s=1  39 52 67 95  8 70 25 52 56