数组和链表的归并排序算法实现(C语言)

原创 2015年03月05日 21:11:25

归并排序

二路归并

描述

时间复杂度是O(NlogN),空间复制度为O(N)(归并排序的最大缺陷)
归并排序(Merge Sort)完全遵循上述分治法三个步骤:
1、分解:将要排序的n个元素的序列分解成两个具有n/2个元素的子序列;
2、解决:使用归并排序分别递归地排序两个子序列;
3、合并:合并两个已排序的子序列,产生原问题的解。

数组代码实现

#include "stdio.h"
#include "stdlib.h"
#include "assert.h"
#include "string.h"

void print_arr(int *arr, int len)
{
    int i = 0;

    for(i = 0; i < len; i ++)
        printf("%d ",arr[i]);
    printf("\n");
}

void merge(int *arr, int low, int mid, int hight, int *tmp)
{
    assert(arr && low >= 0 && low <= mid && mid <= hight);


    int i = low;
    int j = mid + 1;
    int index = 0;

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

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

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


    memcpy((void *)(arr + low), (void *)tmp, (hight - low + 1) * sizeof(int));



}

void mergesort(int *arr, int low, int hight, int *tmp)
{
    assert(arr && low >= 0);
    int mid;
    if(low < hight)
    {
        mid = (hight + low) >> 1;
        mergesort(arr, low, mid,tmp);
        mergesort(arr, mid + 1, hight,tmp);
        merge(arr, low, mid, hight,tmp);
    }
}
//只分配一次内存,避免内存操作开销
void mergesort_drive(int *arr, int len)
{
    int *tmp = (int *)malloc(len * sizeof(int));
    if(!tmp)
    {
        printf("out of memory\n");
        exit(0);
    }

    mergesort(arr, 0, len - 1, tmp);

    free(tmp);
}

int main()
{
    int data[10]={8,7,2,6,9,10,3,4,5,1};

    int len = sizeof(data)/sizeof(data[0]);
    mergesort_drive(data, len);
    print_arr(data,len);

    return 0;
}

链表代码实现

/*
当我们需要对链表进行排序时,由于不能对它的元素进行随机访问,
所以更适合使用归并排序,大名鼎鼎的快速排序用到链表上,效率也很低,
原因还是在于不能对链表中的元素进行随机访问,同理,采用堆排序更是不可能的事情。
*/

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
typedef int Item;

typedef struct Node
{
    Item data;
    struct Node *next;
}Node,*ptrNode;

ptrNode CreatListHead(int len);
ptrNode CreatListTail(int len);
void print_List(ptrNode List);
void Mergesort_List(ptrNode *List);
void Split_List(ptrNode List, ptrNode *List_A, ptrNode *List_B);
ptrNode Merge_List(ptrNode List_A, ptrNode List_B);


ptrNode CreatListHead(int len)
{
    int i;
    ptrNode p;

    ptrNode List = (ptrNode)malloc(sizeof(struct Node));
    List->next   = NULL;

    for(i = 0; i < len; i ++)
    {
        p = (ptrNode)malloc(sizeof(struct Node));
        p->data = i + 1;
        p->next = List->next;
        List->next = p;
    }

    return List;
}

ptrNode CreatListTail(int len)
{
    int i;
    ptrNode p;
    srand(time(0));
    ptrNode List = (ptrNode)malloc(sizeof(struct Node));

    ptrNode Tail = List;
    for(i = 0; i < len; i ++)
    {
        p = (ptrNode)malloc(sizeof(struct Node));
        p->data = rand() % len + 1;
        Tail->next = p;
        Tail  = p;
    }
    Tail->next = NULL;
    return List;
}

void print_List(ptrNode List)
{

    while(List != NULL)
    {
        printf("%d ",List->data);
        List = List->next;
    }
    printf("\n");
}

void Mergesort_List(ptrNode *List)
{
    ptrNode Head = *List;
    ptrNode List_A;
    ptrNode List_B;

    if(Head == NULL || Head->next == NULL)
        return;

    Split_List(Head, &List_A, &List_B);

    Mergesort_List(&List_A);
    Mergesort_List(&List_B);

    *List = Merge_List(List_A,List_B);
}

void Split_List(ptrNode List, ptrNode *List_A, ptrNode *List_B)
{
    ptrNode fast_list;
    ptrNode low_list;

    if(List == NULL || List->next == NULL)
    {
        *List_A = List;
        *List_B = NULL;
    }

    else
    {
        low_list  = List;
        fast_list = List->next;

        while(fast_list != NULL)
        {
            fast_list = fast_list->next;
            if(fast_list != NULL)
            {
                low_list  = low_list->next;
                fast_list = fast_list->next;
            }
        }

        *List_A = List;
        *List_B = low_list->next;
        low_list->next = NULL;
    }
}


ptrNode Merge_List(ptrNode List_A, ptrNode List_B)
{
    ptrNode List_Result = NULL;
    if(List_A == NULL)
        return List_B;
    if(List_B == NULL)
        return List_A;

    if(List_A->data <= List_B->data)
    {
        List_Result = List_A;
        List_A = List_A->next;
    }

    else
    {
        List_Result = List_B;
        List_B = List_B->next;
    }

    List_Result->next = Merge_List(List_A,List_B);

    return List_Result;
}


int main()
{
    ptrNode Head;
    ptrNode List;

    Head = CreatListTail(10);
    List = Head -> next;
    print_List(List);

    Mergesort_List(&List);

    print_List(List);

    return 0;
}

适用场景

归并排序在数据量比较大的时候也有较为出色的表现(效率上),但是,其空间复杂度O(n)使得在数据量特别大的时候(例如,1千万数据)几乎不可接受。而且,考虑到有的机器内存本身就比较小,因此,采用归并排序一定要注意。

还有其他两种归并排序的优化算法(插入归并,原地归并)参考此博文http://www.ahathinking.com/archives/103.html

版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

用数组实现的单链表[C语言]

#include #include #define MAXSIZE 10 // 存储空间最大存储10个元素 #define SUCCESS 1 #define ERROR 0 typed...

C语言链表的创建,排序和合并

先创建两个乱序的链表,再依次排序。然后将两个有序链表合并。 自己闲来练手的程序,不足之处望指出。 #include #include typedef struct node { int ...
  • dk_zhe
  • dk_zhe
  • 2012年06月29日 15:05
  • 1121

数据结构_两个有序单链表归并C语言源代码

#include #include typedef struct LNode {   int data;   struct LNode *next;; }LNode;      ...

Delphi7高级应用开发随书源码

  • 2003年04月30日 00:00
  • 676KB
  • 下载

单链表归并排序

数组排序常见的有十几种排序算法,然而对于单链表来说,链表缺乏随机访问特点,导致一些排序算法在时间和空间复杂度上都比较负责,一般的冒泡排序与插入排序,其时间复杂度都是O(N^2)。链表中最优的排序算法应...

高效链表排序-归并算法

排序算法应该是最基础的了,快速、归并、选择、堆排序等等对于数组而言可以随机访问,那么对于链表呢,比如快排,两个指针分别网后往前走,而没有前驱指针的单向链表,无法完成这样的操作,当然了可以采用快慢指针的...
  • wejoncy
  • wejoncy
  • 2016年05月03日 11:45
  • 1410

opencv 学习之 液晶数字识别

算法采用纵向及横向扫描方式,对清晰图片进行了实验,效果较好。 算法未检测小数点,感兴趣的同学可以Y方向腐蚀检测小数点,按照X坐标排序即可。 当然,数字及字符识别,SVM、K近邻、神经网络等等这些才...

const常量与define宏定义的区别

转载自http://blog.csdn.net/love_gaohz/article/details/7567856 (1) 编译器处理方式不同   define宏是在预处理阶段展开。 ...
  • zwhlxl
  • zwhlxl
  • 2015年03月04日 10:29
  • 447

归并排序算法C语言版

  • 2016年12月10日 18:57
  • 3KB
  • 下载

c语言经典排序算法归并排序

  • 2012年04月15日 00:21
  • 114KB
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:数组和链表的归并排序算法实现(C语言)
举报原因:
原因补充:

(最多只允许输入30个字)