排序4-归并排序

最新推荐文章于 2022-10-12 22:10:37 发布
最新推荐文章于 2022-10-12 22:10:37 发布
阅读量593 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 归并排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zwhlxl/article/details/46682545
版权

基本思想

归并排序（Merge Sort）完全遵循上述分治法三个步骤：
1、分解：将要排序的n个元素的序列分解成两个具有n/2个元素的子序列；
2、解决：使用归并排序分别递归地排序两个子序列；
3、合并：合并两个已排序的子序列，产生原问题的解。
所以说归并排序一种分治算法的典型应用。
归并排序过程动态演示
这里写图片描述 这里写图片描述

时间和空间复杂度

时间复杂度是 O(NlogN) ，空间复制度为 O(N) （归并排序的最大缺陷）。归并排序在数据量比较大的时候也有较为出色的表现（效率上），但是，其空间复杂度O(n)使得在数据量特别大的时候（例如，1千万数据）几乎不可接受。而且，考虑到有的机器内存本身就比较小。总结来说，归并排序是一种占用内存，但却效率高且稳定的算法。

代码实现

void merge_array(int arr[], int tmp[], int Left, int mid, int Right)
{
    assert(arr && Left >= 0 && Left <= mid && mid <= Right);
    int i = Left;
    int j = mid + 1;
    int index = 0;

    while(i <= mid && j <= Right)
    {
        if(arr[i] <= arr[j])
            tmp[index++] = arr[i++];
        else
            tmp[index++] = arr[j++];
    }

    while(i <= mid) //拷贝剩下的左半部分
        tmp[index++] = arr[i++];

    while(j <= Right)  //拷贝剩下的右半部分
        tmp[index++] = arr[j++];

    memcpy(arr + Left, tmp, (Right - Left + 1) * sizeof(int)); 
}
void merge_sort(int arr[], int tmp[], int Left, int Right)
{
    assert(arr && Left >= 0);
    int mid;

    if(Left < Right)
    {
        mid = (Left + Right) / 2;
        merge_sort(arr, tmp, Left, mid);
        merge_sort(arr, tmp, mid + 1, Right);
        merge_array(arr, tmp, Left, mid, Right);
    }

}

void Merge_Sort(int arr[], int len)
{
    assert(arr && len);
    int *tmp_arr;
    //tmp_arr = (int *)malloc(len * sizeof(int));
    tmp_arr = new int[len];

    merge_sort(arr, tmp_arr, 0, len - 1);

    delete[] tmp_arr;

}

测试程序

#include <iostream>
#include <cstring>
#include <ctime>
#include <cmath>
using namespace std;


#define ArraySize 100000


void swap(int *x, int *y)
{
    int temp;
    temp = *x;
    *x   = *y;
    *y   = temp;
}

void Bubble_sort(int arr[], int len)
{
    for(int i = 0; i < len; i ++)
    {
        for(int j = i + 1; j < len; j ++)
            if(arr[i] > arr[j])
                swap(arr[i], arr[j]);
    }
}

void Bubble_sort1(int arr[], int len)
{
    for(int i = 0; i < len; i ++)
    {
        for(int j = len - 1; j >= i; j --)
        {
            if(arr[i] > arr[j])
                swap(arr[i], arr[j]);
        }
    }
}

void Bubble_sort2(int arr[], int len)
{
    bool flag = true;

    while(flag)
    {
        flag = false;
        for(int i = 0; i < len; i ++)
            for(int j = len - 1; j >= i; j --)
                if(arr[i] > arr[j])
                    swap(arr[i], arr[j]);
    }
}

void Slect_sort(int arr[], int len)
{
    for(int i = 0; i < len; i ++)
    {
        int min_index = i ;
        for(int j = i + 1; j < len; j ++)
        {
            if(arr[min_index] > arr[j])
                min_index = j;
        }

        if(i != min_index)
            swap(arr[i],arr[min_index]);
    }
}

void Insert_sort(int arr[], int len)
{

    for(int i= 1; i < len; i ++)
    {   
        int key = arr[i];
        int j = i;
        while(j && arr[j - 1] > key)
        {
            arr[j] = arr[j - 1];
            j --;
        }

        arr[j] = key;
    }
}

void Shell_sort(int arr[], int len)
{
    int increment = len / 2;

    while(increment)
    {
        for(int i = increment; i < len; i ++)
        {
            int key = arr[i];
            /*int j ;
            for(j = i; j >= increment; j -= increment)
            {
                if(arr[j-increment] > key )
                    arr[j] = arr[j-increment];
                else 
                    break;

            }*/

            int j = i;
            while(j >= increment && arr[j-increment] > key)
            {
                arr[j] = arr[j-increment];
                j -= increment;
            }

            arr[j] = key;
        }

        increment /= 2;
    }
}

void Shell_sort1(int arr[], int len)
{
    int increment = 0;
    for(increment = len/2; increment > 0; increment /=2)
    {
        for(int i = increment; i < len; i++)
        {
            int key = arr[i];
            int j = 0;
            for(j = i; j >= increment; j -=increment)
            {
                if(arr[j-increment] > key)
                    arr[j] = arr[j-increment];
                else 
                    break;
            }

            arr[j] = key;
        }
    }
}

void Shell_sort2(int arr[], int len)
{
    int index = log( 2*len + 1) / log(3.0);

    //cout << index << endl;

    int increment = ( pow(3.0, index) - 1 ) / 2;

    //cout << increment << endl;

    while(increment)
    {
        for(int i = increment; i < len; i ++)
        {
            int key = arr[i];
            /*int j ;
            for(j = i; j >= increment; j -= increment)
            {
                if(arr[j-increment] > key )
                    arr[j] = arr[j-increment];
                else 
                    break;

            }*/

            int j = i;
            while(j >= increment && arr[j-increment] > key)
            {
                arr[j] = arr[j-increment];
                j -= increment;
            }

            arr[j] = key;
        }
        index -= 1;
        increment = ( pow(3.0, index) - 1 ) / 2;
    }
}

void Heap_adjust(int arr[], int index, int len)
{


    while(true)
    {
        int iMax = index;
        int iLeft = 2 * index + 1;
        int iRight = 2 * index + 2;

        if(iLeft < len && arr[index] < arr[iLeft])
            iMax = iLeft;
        if(iRight < len && arr[index] < arr[iRight])
            iMax = iRight;
        if(iMax != index)
        {
            swap(arr[index], arr[iMax]);
            index = iMax;
        }
        else 
            break;
    }



}

void Heap_adjust2(int arr[], int index, int len)
{
    int iMax = index;
    int iLeft = 2 * index + 1;
    int iRight = 2 * index + 2;

    if(iLeft < len && arr[index] < arr[iLeft])
        iMax = iLeft;

    if(iRight < len && arr[index] < arr[iRight])
        iMax = iRight;

    if(iMax != index)
    {
        swap(arr[index], arr[iMax]);
        Heap_adjust2(arr, iMax, len);
    }
}

void Build_maxheap(int arr[], int len)
{
    for(int i = len / 2; i >= 0; i --)
    {
        Heap_adjust(arr, i , len);
    }
}

void Heap_Sort(int arr[], int len)
{
    Build_maxheap(arr, len);

    for(int i = len - 1; i > 0; i --)
    {
        swap(arr[0], arr[i]);
        Heap_adjust(arr, 0, i);
    }
}

void Print_array(int arr[], int len)
{
    for(int i = 0; i < len; i++)
    {
        cout << arr[i] << " ";
    }
    cout << endl;

}

void merge_array(int arr[], int tmp[], int Left, int mid, int Right)
{
    assert(arr && Left >= 0 && Left <= mid && mid <= Right);
    int i = Left;
    int j = mid + 1;
    int index = 0;

    while(i <= mid && j <= Right)
    {
        if(arr[i] <= arr[j])
            tmp[index++] = arr[i++];
        else
            tmp[index++] = arr[j++];
    }

    while(i <= mid)
        tmp[index++] = arr[i++];

    while(j <= Right)
        tmp[index++] = arr[j++];

    memcpy(arr + Left, tmp, (Right - Left + 1) * sizeof(int)); 
}
void merge_sort(int arr[], int tmp[], int Left, int Right)
{
    assert(arr && Left >= 0);
    int mid;

    if(Left < Right)
    {
        mid = (Left + Right) / 2;
        merge_sort(arr, tmp, Left, mid);
        merge_sort(arr, tmp, mid + 1, Right);
        merge_array(arr, tmp, Left, mid, Right);
    }

}

void Merge_Sort(int arr[], int len)
{
    assert(arr && len);
    int *tmp_arr;
    //tmp_arr = (int *)malloc(len * sizeof(int));
    tmp_arr = new int[len];

    merge_sort(arr, tmp_arr, 0, len - 1);

    delete[] tmp_arr;

}
int main(int argc, char const *argv[])
{
    /* code */
    int Array[ArraySize];
    int Array1[ArraySize];
    int Array2[ArraySize];

    time_t begin , end;

    srand(time(NULL));



    for(int i = 0; i < ArraySize; i ++)
    {
        Array[i] = rand()%ArraySize;
        //cout << Array[i] << " ";
    }

    memcpy(Array1, Array, ArraySize * sizeof(Array1[0]));
    memcpy(Array2, Array, ArraySize * sizeof(Array2[0]));

//  Print_array(Array, ArraySize);

/*  begin = clock();
    Bubble_sort2(Array, ArraySize);
    end = clock();
    cout << "Bubble_sort runtime:   " << double(end - begin) / CLOCKS_PER_SEC << "s" << endl;

    begin = clock();
    Slect_sort(Array1, ArraySize);
    end = clock();
    cout << "Slect_sort runtime:   " << double(end - begin) / CLOCKS_PER_SEC << "s" << endl;

    begin = clock();
    Insert_sort(Array2, ArraySize);
    end = clock();
    cout << "Insert_sort runtime:   " << double(end - begin) / CLOCKS_PER_SEC << "s" << endl;*/ 

    begin = clock();
    Shell_sort2(Array, ArraySize);
    end = clock();
    cout << "Shell_sort2 runtime:   " << double(end - begin) / CLOCKS_PER_SEC << "s" << endl;

    begin = clock();
    Heap_Sort(Array1, ArraySize);
    end = clock();
    cout << "Heap_Sort runtime:   " << double(end - begin) / CLOCKS_PER_SEC << "s" << endl;

    begin = clock();
    Merge_Sort(Array2, ArraySize);
    end = clock();
    cout << "Merge_Sort runtime:   " << double(end - begin) / CLOCKS_PER_SEC << "s" << endl;

    //Print_array(Array2, ArraySize);
    return 0;
}

运行结果如下：

Shell_sort2 runtime:   0.026s
Heap_Sort runtime:   0.004s
Merge_Sort runtime:   0.014s
zengwh513
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
十大经典排序算法-归并排序算法详解
qq_35344198的博客
06-19 11万+
一、什么是归并排序 1.概念 归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法，归并排序对序列的元素进行逐层折半分组，然后从最小分组开始比较排序，合并成一个大的分组，逐层进行，最终所有的元素都是有序的 2.算法原理 这是一个无序数列：4、5、8、1、7、2、6、3，我们要将它按从小到大排序。按照归并排序的思想，我们要把序列逐层进行拆分 序列逐层拆分如下 然后从下往上逐层合并，首先对第一层序列1（只包含元素4）和序列2（只包含元素5）进行合并 创建一个大序列，序列长度为两个小序列长度
排序算法 - 归并排序详解
张大安的博客
05-09 4503
基本介绍 归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。 基本思想 将序列中待排序数字分为若干组，最终每个数字分为一组。（默认长度为1的序列是有序的） 将若干个组两两合并，保证合并后的组是有序的。（俩个子序列头部进行比较大小） 重复第二步操作直到只剩下一组，排序完成。 归并排序思想示
排序算法-归并排序
qq_36944952的博客
12-30 4041
排序算法-归并排序 算法思想 归并：将两个或者两个以上的有序表组合成一个新的有序表的过程。假定待排序表中含有n个记录，则可以看成是n个有序的子表，每个子表的长度为1，然后两两归并，得到⌈n/2⌉\lceil n/2 \rceil⌈n/2⌉个长度为2或1的有序表；再两两归并，如此一直重复，直到合并成一个长度为n的有序表为止，这种排序方法称为2路归并排序。 2路归并排序的过程如下图所示。 从归并的过程不难看出，其代码实现可以基于分治思想递归实现。其基本问题是如何实现两个有序序列的归并操作，该操作可以通过使用辅
排序算法---归并排序
sy4331的博客
03-20 1979
1. 归并操作 归并排序是在归并操作上实现的。先了解一下归并操作的原理。 归并操作：将两个有序数组合并为一个新的有序数组。 如有序数组A=[1, 4, 6], B=[2, 4, 5]，将其进行合并。设置变量下标i和j分别表示数组A和B的下标。遍历完数组A和B，最终合并后数组为C。 若A[i] <= B[j]，则将A[i]保存到数组C，并将i++； 若A[i] > B[j]，则将B[j]保存到数组C，并将j++； 归并操作的具体实现如下： void Merge(int *piAr
C语言实现----归并排序
qq_53436105的博客
10-12 1万+
一、归并排序介绍 将两个的有序数列合并成一个有序数列，我们称之为"归并"。 归并排序（ Merge Sort ）就是利用归并思想对数列进行排序。根据具体的实现，归并排序包括"从上往下"和"从下往上"2种方式。 1．从下往上的归并排序：将待排序的数列分成若干个长度为1的子数列，然后将这些数列两两合并；得到若干个长度为2的有序数列，再将这些数列两两合并；得到若干个长度为4的有序数列，再将它们两两合并；直接合并成一个数列为止。这样就得到了我们想要的排序结果。（参考下面的图2．从上往下的归并排序：它与"从下往上
排序算法-归并排序详细讲解（MergeSort）
GTW、Zeus的博客
07-11 1万+
归并，指合并，合在一起。归并排序（Merge Sort）是建立在归并操作上的一种排序算法。其主要思想是分而治之。若将两个有序集合并成一个有序表，称为2-路归并，与之对应的还有多路归并。借助一个辅助空数组，把左右两边的数组按照大小比较，按顺序放入辅助数组中即可。以下面两个有序数组为例： public static void mergeSort(int[] arr){ if (arr == null || arr.length<2){ return;
排序算法-归并排序的时间复杂度分析
抱愚守拙，持之以恒；不问结果，相信过程.
08-23 1万+
归并排序，其实就是递归+合并。
算法与数据结构 --- 排序 --- 归并排序，基数排序以及总结
qq_51947882的博客
09-29 1020
1.归并排序一次归并只能够归并两个相邻的有序子序列2.归并排序的整个过程就是一棵倒着的树（如上），我们将这棵树称为归并树，树的层数就是我们进行归并操作的总趟数 --- 设完全二叉树的最后一层层数为K，则这一层的最大容量为 2的K-1次方，在归并排序中我们是已知完全二叉树的最后一层的最大元素总数的（就是我们要排序的元素总数），自然就能够得到树的最后一层层数，也就能得到总比较趟数了3.如果说要对奇数个元素进行排序的话，我们需要先将两个相邻的元素进行归，使得等待归并排序的总子序列为偶数个，然后再开始正式对所有子序
基础排序算法----归并排序
蒟蒻达的博客
12-08 2893
归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。归并排序是一种稳定的排序方法。时间复杂度为O(n log n) 。 #include<bits/stdc++.h...
排序算法-归并排序详细图解
08-12 7570
归并排序： 采用了分治策略 就是将原问题分解为一些规模较小的相似子问题，然后递归解决这些子问题，最后合并其结果作为原问题的解。 归并的核心思想 将两个有序的数组合并成一个大的有序的数组，通过递归把待排序数组变成完全有序数组。 归并的核心算法就是如何将2个数组合并 算法思想： 将待排序数组一直往下分解直到不可分解为止也就是一个数为一个子数组 然后对这些子数组层层合并(合并里有排序的过程)...
详解Java常用排序算法-归并排序
08-26
Java常用排序算法-归并排序 归并排序是一种分治思想的排序算法，其基本思想是将待排序的数组分成若干个子序列，每个子序列都是有序的，然后再将子序列合并成一个有序的数组。这种算法的时间复杂度为O(n log n)，...
python-归并排序算法.docx
06-11
python 归并排序算法 归并排序是一种基于分治思想的排序算法，它将待排序的序列分成若干个子序列，每个子序列都是有序的，然后再将这些有序的子序列合并成一个有序的序列。归并排序的时间复杂度为O(nlogn)，是一种...
排序-归并排序（Merge sort）
最新发布
12-22
4. **有序集合合并**：如果需要合并两个已经有序的集合，归并排序的合并过程可以直接应用，无需整个排序过程。 总之，归并排序以其稳定的性能和可扩展性，在很多场合都得到了广泛应用。虽然它的空间复杂度相对较高...
SCAU-8645归并排序.docx
03-16
归并排序是一种基于分治策略的排序算法，其基本思想是将大问题分解为小问题，然后逐个解决这些小问题，最后将解决方案合并成原问题的解。在这个SCAU-8645归并排序的例子中，我们看到了一个完整的C++实现。 首先，...
分治算法例子集锦
热门推荐
zengwh
03-07 2万+
分治算法例子集锦
动态规划（DP）之入门学习-数字三角形
zengwh
05-29 2万+
数字三角形案例题目描述 Description下图给出了一个数字三角形，请编写一个程序，计算从顶至底的某处的一条路径，使该路径所经过的数字的总和最大。 （1）每一步可沿左斜线向下或右斜线向下 （2）1 < 三角形行数 < 100 （3）三角形数字为0，1，…99 输入描述 Input Description有很多个测试案例，对于每一个测试案例， 通过键盘逐行输入，第1行是输入整数（如
二叉树最大深度和最小深度
zengwh
08-12 1万+
二叉树的最大深度给定一个二叉树，找出其最大深度。 二叉树的深度为根节点到最远叶子节点的距离。如果二叉树为空，则深度为0 如果不为空，分别求左子树的深度和右子树的深度，去最大的再加1，因为根节点深度是1，要加进去。int maxDepth(TreeNode *root) { // write your code (here) if(root == NULL)
散列表-开放地址法和链地址法的实现
zengwh
06-30 9894
基本定义散列技术是在记录的存储位置和它的关键字之间建立一个确定的对应关系 f，使得每个关键字key对应一个存储位置f(key)。这种对应关系f称为散列或哈希函数。采用上述思想将数据存储在一块连续的存储空间中，这块连续的存储空间称为散列或哈希表。关键字对应的存储位置称为散列地址。散列技术最适合的求解问题是查找与给定值相等的记录。 如果碰到两个不同的关键字key1≠key2key_1 \neq key
数据结构外排序专题培训课件.ppt
08-03
外排序的基本方法是归并排序法，分为生成初始归并段和多路归并两个步骤。初始归并段是指根据内存大小将文件分成长度为L的子文件，并采用内排序方法排序后送回外存。多路归并是对初始归并段进行多遍归并，使得有序的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值