归并排序算法

简介:

归并排序(Merge sort)是创建在归并操作上的一种有效的排序算法。该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。

一个归并排序的例子:对一个随机点的链表进行排序

本文地址:http://www.cnblogs.com/archimedes/p/merge-sort-algorithm.html,转载请注明源地址。

算法描述

归并操作的过程如下:

  1. 申请空间,使其大小为两个已经排序序列之和,该空间用来存放合并后的序列

  2. 设定两个指针,最初位置分别为两个已经排序序列的起始位置

  3. 比较两个指针所指向的元素,选择相对小的元素放入到合并空间,并移动指针到下一位置

  4. 重复步骤3直到某一指针到达序列尾

  5. 将另一序列剩下的所有元素直接复制到合并序列尾

特点:归并排序是稳定的排序.即相等的元素的顺序不会改变,  速度仅次于快速排序,但较稳定。

归并操作

归并操作(merge),也叫归并算法,指的是将两个顺序序列合并成一个顺序序列的方法。

如:设有数列 [6,202,100,301,38,8,1]

初始状态:6, 202, 100, 301, 38, 8, 1

第一次归并后:[6, 202], [100, 301], [8, 38], [1],比较次数:3;

第二次归并后:[6, 100, 202, 301],[1, 8, 38],比较次数:4;

第三次归并后:[1, 6, 8, 38, 100, 202, 301],比较次数:4;

总的比较次数为:3+4+4=11,;

逆序数为14;

算法实现

// Completed on 2014.10.11 17:20
// Language: C99
//
// 版权所有(C)codingwu   (mail: oskernel@126.com) 
// 博客地址:http://www.cnblogs.com/archimedes/
#include<stdio.h>
#include<stdlib.h>void merge_sort(int *list, const int first, const int last)
{
    int len= last-first+1;  
    int left_min,left_max;    //左半区域边界 
    int right_min,right_max;  //右半区域边界 
    int index;
    int i;
    int *tmp;
    tmp = (int *)malloc(sizeof(int)*len);
    if( tmp == NULL || len <= 0 )
        return;
    
    for( i = 1; i < len; i *= 2 )
    {
        for( left_min = 0; left_min < len - i; left_min = right_max)
        {
            int j;
            right_min = left_max = left_min + i;
            right_max = left_max + i;
            j = left_min;
            if ( right_max > len )
                right_max = len;
            index = 0;
            while( left_min < left_max && right_min < right_max )
            {
                tmp[index++] = (list[left_min] > list[right_min] ? list[right_min++] : list[left_min++]);
            }
            while( left_min < left_max )
            {
                list[--right_min] = list[--left_max];
            }
            while( index > 0 )
            {
                list[--right_min] = tmp[--index];
            }
        }
    }
    free(tmp);
}
int main()
{
    int a[] = {288, 52, 123, 30, 212, 23, 10, 233};
    int n, mid;
    n = sizeof(a) / sizeof(a[0]);
    mid = n / 2;
    merge_sort(a, 0, n - 1);
    for(int k = 0; k < n; k++)
        printf("%d ", a[k]);
    printf("\n");
    return 0;
}

使用递归实现:

// Completed on 2014.10.11 18:20
// Language: C99
//
// 版权所有(C)codingwu   (mail: oskernel@126.com) 
// 博客地址:http://www.cnblogs.com/archimedes/
#include<stdio.h>
#include<stdlib.h>
void merge(int *array,const int first, const int mid, const int last)
{
    int i,index;
    int first1,last1;
    int first2,last2;
    int *tmp;
    tmp = (int *)malloc((last-first+1)*sizeof(int));
    if( tmp == NULL )
        return;
    first1 = first;
    last1  = mid;
    first2 = mid+1;
    last2  = last;
    index = 0;
    while( (first1 <= last1) && (first2 <= last2) )
    {
        if( array[first1] < array[first2] )
        {
            tmp[index++] = array[first1];
            first1++;
        }
        else{
            tmp[index++] = array[first2];
            first2++;
        }
    }
    while( first1 <= last1 )
    {
        tmp[index++] = array[first1++];
    }
    while( first2 <= last2 )
    {
        tmp[index++] = array[first2++];
    }
    for( i=0; i<(last-first+1); i++)
    {
        array[first+i] = tmp[i];
    }
    free(tmp);
}
void merge_sort(int *array, const int first, const int last)
{
    int mid = 0;
    if(first < last)
    {
        mid = (first + last) / 2;
        merge_sort(array, first, mid);
        merge_sort(array, mid + 1, last);
        merge(array, first, mid, last);
    }
}
int main()
{
    int a[] = {288, 52, 123, 30, 212, 23, 10, 233};
    int n, mid;
    n = sizeof(a) / sizeof(a[0]);
    mid = n / 2;
    merge_sort(a, 0, n - 1);
    for(int k = 0; k < n; k++)
        printf("%d ", a[k]);
    printf("\n");
    return 0;
}
目录
相关文章
|
1月前
|
算法 搜索推荐 Java
算法实战:手写归并排序,让复杂排序变简单!
归并排序是一种基于“分治法”的经典算法,通过递归分割和合并数组,实现O(n log n)的高效排序。本文将通过Java手写代码,详细讲解归并排序的原理及实现,帮助你快速掌握这一实用算法。
37 0
|
1月前
|
数据采集 搜索推荐 算法
【高手进阶】Java排序算法:从零到精通——揭秘冒泡、快速、归并排序的原理与实战应用,让你的代码效率飙升!
【8月更文挑战第21天】Java排序算法是编程基础的重要部分,在算法设计与分析及实际开发中不可或缺。本文介绍内部排序算法,包括简单的冒泡排序及其逐步优化至高效的快速排序和稳定的归并排序,并提供了每种算法的Java实现示例。此外,还探讨了排序算法在电子商务、搜索引擎和数据分析等领域的广泛应用,帮助读者更好地理解和应用这些算法。
21 0
|
2月前
|
存储 算法 搜索推荐
算法进阶之路:Python 归并排序深度剖析,让数据排序变得艺术起来!
【7月更文挑战第12天】归并排序是高效稳定的排序算法,采用分治策略。Python 实现包括递归地分割数组及合并已排序部分。示例代码展示了如何将 `[12, 11, 13, 5, 6]` 分割并归并成有序数组 `[5, 6, 11, 12, 13]`。虽然 $O(n log n)$ 时间复杂度优秀,但需额外空间,适合大规模数据排序。对于小规模数据,可考虑其他算法。**
65 4
|
2月前
|
算法 搜索推荐 C#
|
3月前
|
搜索推荐 算法 Java
Java中的快速排序、归并排序和堆排序是常见的排序算法。
【6月更文挑战第21天】Java中的快速排序、归并排序和堆排序是常见的排序算法。快速排序采用分治,以基准元素划分数组并递归排序;归并排序同样分治,先分割再合并有序子数组;堆排序通过构建堆来排序,保持堆性质并交换堆顶元素。每种算法各有优劣:快排平均高效,最坏O(n²);归并稳定O(n log n)但需额外空间;堆排序O(n log n)且原地排序,但不稳定。
35 3
|
3月前
|
算法
数据结构与算法-归并排序
数据结构与算法-归并排序
25 2
|
3月前
|
搜索推荐 C语言
【C/排序算法】:快速排序和归并排序的非递归实现
【C/排序算法】:快速排序和归并排序的非递归实现
21 0
|
3月前
|
搜索推荐 算法
【C/排序算法】:归并排序和计数排序
【C/排序算法】:归并排序和计数排序
27 0
|
3月前
|
搜索推荐
归并排序算法总结
归并排序算法总结
|
3月前
|
算法 C语言
数据结构和算法——归并排序(有序子列的归并、递归算法、非递归算法、思路图解、C语言代码)
数据结构和算法——归并排序(有序子列的归并、递归算法、非递归算法、思路图解、C语言代码)
21 0