对于各种数据类型的多钟排序算法的统一实现——冒泡排序、插入排序、选择排序、基于hibbard序列的希尔排序、堆排序、快速排序、归并排序共7种排序实现...

最新推荐文章于 2024-02-29 06:42:18 发布
最新推荐文章于 2024-02-29 06:42:18 发布
阅读量128 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/zjuhaotong/p/9626296.html
版权

　　函数接口为 

void MyXxxxSort(void * base, int num, int width, int (*cmp)(void *, void *));
//base为数组第一个元素的地址
//num为数组元素数量
//width为数组元素的大小
//cmp为元素的比较函数

　　这个函数库实现了对各种数据类型的多种比较常见的排序算法的实现，其中各种排序算法的实现可以供大家一块学习探讨。

　　下面附上各种排序算法的时间复杂度、空间复杂度、以及稳定性。

排序法

最差时间分析平均时间复杂度稳定性空间复杂度
冒泡排序O(n2)O(n2)稳定O(1)
快速排序O(n2)O(n*log2n)不稳定O(log2n)~O(n)
选择排序O(n2)O(n2)稳定O(1)
二叉树排序O(n2)O(n*log2n)不一顶O(n)

插入排序

O(n2)O(n2)稳定O(1)
堆排序O(n*log2n)O(n*log2n)不稳定O(1)
希尔排序OO不稳定O(1)

　　以下为源代码：

#ifndef _M_SORT_H
#define _M_SORT_H

#include"m_sort.h"
#include<stdlib.h>
#include<math.h>
#include<stdio.h>
#include<string.h>
/*
typedef struct HeapStruct *MaxHeap;
struct HeapStruct{
    void *elements;
    int size;
    int maxsize;
};
*/

/*
 * 这些函数是实现某些复杂排序算法所需要调用的
 * 
 */
void Swap(void *a, void *b, int width);
int Hibbard(int num);
void ModifyDown(void *base, int begin, int end, int width, int cmp(const void *, const void *));
void MergeS(void *base,void *tmpBase, int num, int length, int width, int cmp(const void *, const void *));
void *Median(void *base, int left, int right, int width, int cmp(const void *, const void *));
void QuickSort(void *base, int cutoff, int left, int right, int width, int cmp(const void *, const void *));
/*MaxHeap HeapCreate(int maxsize);
void HeapInsert(MaxHeap H, void * item, int width, int (*cmp)(void *, void *));
void *HeapDelete(MaxHeap H);*/

/*
 * 这些函数是较为简单的排序算法
 */
void MySelectionSort(void *base, int num, int width, int cmp(const void *, const void *));
void MyInsertionSort(void *base, int num, int width, int cmp(const void *, const void *));
void MyBubbleSort(void *base, int num, int width, int cmp(const void *, const void *));

/*
 *这些函数是较为高级的排序算法
 */
void MyShellSort(void *base, int num, int width, int cmp(const void *, const void *));
void MyHeapSort(void *base, int num, int width, int cmp(const void *, const void *));
void MyMergeSort(void *base, int num, int width, int cmp(const void *, const void *));
void MyQuickSort(void *base, int num, int width, int cmp(const void *, const void *));


#endif
#include "m_sort.h"

void ModifyDown(void *base, int begin, int end, int width, int cmp(const void *, const void *))
{
    int parent, child;
    void *temp = (void *)malloc(width);
    memcpy(temp, base + (begin)*width,width);
    for (parent = begin; parent * 2 + 1 < end; parent = child) {
        child = 2 * parent + 1;
        if (child != (end -1) && cmp(base + child * width, base + (child + 1) * width) < 0) {
            child++;
        }
        if (cmp(temp , base + child * width) >= 0) 
            break;
        else
            memcpy(base + parent * width, base + child * width, width);
    }
    memcpy(base + parent * width, temp, width);
    free(temp);
}


void MergeS(void *base,void *tmpBase, int num, int length, int width, int cmp(const void *, const void *))
{
    int i, l, r, tmp;
    for (i = 0; i <= num - 2 * length; i += 2 * length ) {
        l = i; r = i + length; tmp = l;
        while (l < i + length && r < i + 2 * length) {
            if(cmp(base + l * width, base + r * width) > 0)
                memcpy(tmpBase + (tmp++) * width, base + (r++) * width, width);
            else
                memcpy(tmpBase + (tmp++) * width, base + (l++) * width, width);
        }
        while (l < i + length)
            memcpy(tmpBase + (tmp++) * width, base + (l++) * width, width);
        while (r < i + 2*length)
            memcpy(tmpBase + (tmp++) * width, base + (r++) * width, width);
    }

    if (i + length >= num) {
        tmp = i;
        while (i < num)
            memcpy(tmpBase + (tmp++) * width, base + (i++) * width, width);
    }
    else {
        l = i; r = i + length; tmp = l;
        while (l < i + length && r < num) {
            if(cmp(base + l * width, base + r * width) > 0)
                memcpy(tmpBase + (tmp++) * width, base + (r++) * width, width);
            else
                memcpy(tmpBase + (tmp++) * width, base + (l++) * width, width);
        }
        while (l < i + length)
            memcpy(tmpBase + (tmp++) * width, base + (l++) * width, width);
        while (r < num)
            memcpy(tmpBase + (tmp++) * width, base + (r++) * width, width);

    }

}

void *Median(void *base, int left, int right, int width, int cmp(const void *, const void *))
{
    int middle = (left + right) / 2;
    if (cmp(base + left * width, base + middle * width) > 0)
        Swap(base + left * width, base + middle * width, width);
    if (cmp(base + middle * width, base + right * width) > 0)
        Swap(base + right * width, base + middle * width, width);
    if (cmp(base + left * width, base + middle * width) > 0)
        Swap(base + left * width, base + middle * width, width);
    Swap(base + middle * width, base + (right-1) * width, width);
    return base + (right-1)*width;
}

void QuickSort(void *base, int cutoff, int left, int right, int width, int cmp(const void *, const void *))
{
    int i, j;
    void *pivot;
    pivot = (void *)malloc(width);
    if (right - left < cutoff) {
        MyInsertionSort(base + left * width, right - left + 1, width, cmp);
    }
    else {
        memcpy(pivot, Median(base, left, right, width, cmp), width);
        i = left;
        j = right - 1;
        while (1) {     
            while( cmp(base + (++i) * width, pivot) < 0);
            while( cmp(base + (--j) * width, pivot) > 0);
            if ( i < j) {
                Swap(base + i * width, base + j * width, width);
            }
            else
                break;
        }
        Swap(base + i * width, base + (right-1) * width, width);
        QuickSort(base, cutoff, left, i-1, width, cmp);
        QuickSort(base, cutoff, i+1, right, width, cmp);
    }
}

/*
 *if we choose to create a new heap, we can use these code.
 *however, we choose to modify the existing array to a maxheap.
 *
MaxHeap Create(int maxsize, int width)
{
    MaxHeap H = (MaxHeap)malloc(sizeof(struct HeapStruct));
    H->elements = (void *)malloc((maxsize + 1) * width);
    H->size = 0;
    H->maxsize = maxsize;
    
    return H;
}

void Insert(MaxHeap H, void * item, int width, int (*cmp)(void *, void *))
{
    int i;
    if (H->maxsize == H->size)) {
        printf("The heap is full!\n");
        return;
    }

    for (i = ++(H->size);i>1 && cmp(H->elements + i/2 * width, item) < 0; i /=2 )
        memcpy(H->elements + i * width, H->elements + i/2 * width);
    memcpy(H->elements + i * width, item, width);
}

void *HeapDelete(MaxHeap H, int width, int (*cmp)(void *, void *))
{
    int parent, child;
    void *maxitem, *tmp;
    if (H->size == 0) {
        printf("The heap is empty!\n");
        return;
    }
    maxitem = H->elements + width;
    H->size--;
    tmp = H->elements + H->size * width;
    for(parent = 1; parent*2 <= H->size; parent = child) {
        child = parent * 2;
        if ( child != H->size && cmp(H->elements + child * width, H->elements + (child + 1) * width) < 0)
            child++;
        if (cmp(tmp, H->elements + child * width) >= 0) 
            break;
        else
            memcpy(H->elements + parent * width, H->elements + child * width, width);
    }
    memcpy(H->elements + parent * width, tmp)
}

*/

void Swap(void *a, void *b, int width)
{
    void *tmp;
    tmp = (void *)malloc(width);
    memcpy(tmp, a, width);
    memcpy(a, b, width);
    memcpy(b, tmp, width);
    free(tmp);
}

int Hibbard(int num)
{
    int result, i;
    for (i = 0; pow(2, i) - 1 <= num; i++);
    result = pow(2, i - 1) - 1;
    return result;
}

void MyBubbleSort(void *base, int num, int width, int (*cmp)(const void *, const void *))
{
    int i, j, flag;
    for(i = num -1; i > 0; i--){
        flag = 0;
        for(j = 0; j < i; j++){
            if (cmp(base + j * width, base + (j+1)*width) > 0) {
                Swap(base + j * width, base + (j+1)*width, width);
                flag = 1;
            }
        }
        if (flag == 0)
            break;        
    }  
}

void MySelectionSort(void *base, int num, int width, int cmp(const void *, const void *))
{
    int i, j, tmp;
    for(i = num - 1; i > 0; i--){
        tmp = i;
        for(j = i - 1; j >= 0; j--){
            if(cmp(base + j * width, base + tmp * width) > 0){
                tmp = j;
            }
        }
        Swap(base + i * width, base + tmp * width, width);
    }
}

void MyInsertionSort(void *base, int num, int width, int cmp(const void *, const void *))
{
    int i, j, tmp;
    void *temp;
    temp = (void *)malloc(width);
    for (i = 1; i < num; i++) {
        memcpy(temp, base + i * width, width);
        for(j = i; j > 0 && cmp(base + (j - 1)*width, temp) > 0; j--)
            memcpy(base + j * width, base + (j - 1) * width, width);
        memcpy(base + j * width, temp, width);
    }
    free(temp);
}

void MyShellSort(void *base, int num, int width, int cmp(const void *, const void *))
{
    int i, j, k, tmp;
    void *temp;
    temp = (void *)malloc(width);
    for (i = Hibbard(num); i > 0; i /= 2) {
        for (j = i; j < num; j++) {
            memcpy(temp, base + j * width, width);
            for(k = j; k >= i && cmp(base + (k - i) * width, temp) > 0; k -= i)
                memcpy(base + k * width, base + (k - i) * width, width);
            memcpy(base + k * width, temp, width);
        }
    }
    
}

void MyHeapSort(void *base, int num, int width, int cmp(const void *, const void *))
{
    int i, j, k;
    for (i = num/2; i >= 0; i--) {
        ModifyDown(base, i, num, width, cmp);
    }
    for (i = num - 1; i > 0; i--) {
        Swap(base + 0 * width, base + i * width, width);
        ModifyDown(base, 0, i, width, cmp);
    }
}

void MyMergeSort(void *base, int num, int width, int cmp(const void *, const void *))
{
    int length = 1;
    void *tmpBase;
    tmpBase = (void *)malloc(num * width);
    if (tmpBase != NULL ) {
        while (length < num) {
            MergeS(base, tmpBase, num, length, width, cmp);
            length *= 2;
            MergeS(tmpBase, base, num, length, width, cmp);
            length *= 2;
        }
        free(tmpBase);
    }
    else{
        printf("ERROR! The memory is out of use!\n");
        return;
    }
}

void MyQuickSort(void *base, int num, int width, int cmp(const void *, const void *))
{
    int cutoff = 100;//cutoff must be bigger than 2
    QuickSort(base, cutoff, 0, num - 1, width, cmp);    
}

 

转载于:https://www.cnblogs.com/zjuhaotong/p/9626296.html

weixin_34115824
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
希尔排序（二）
车子（chezi）
05-19 336
另一种写法 上一篇博文希尔排序（一）中的代码是基于希尔排序的原理，“直译”过来的。还有一种更简单的写法： void shellsort_2(int a[], int n) { int j, gap; for (gap = n / 2; gap &amp;gt; 0; gap /= 2) { #ifdef PRINT_PROCEDURE ...
希尔排序-Hibbard增量序列（C语言）
Mz_yuner的博客
09-08 139
【代码】希尔排序-Hibbard增量序列（C语言）
希尔排序（带你原理到实践）
2303_79387663的博客
02-29 1081
除了上述两种常用的增量序列外，还可以根据具体的应用场景和需求来自定义增量序列。例如，可以根据数据的特性或分布来选择合适的增量，或者通过实验来找到最优的增量序列。需要注意的是，选择合适的增量序列并没有固定的规则或标准。通常需要根据具体的数据集、排序要求（如稳定性、时间复杂度等）以及实验结果来做出决策。因此，在实际应用中，可能需要尝试不同的增量序列来找到最适合特定场景的解决方案。希尔排序是一种基于插入排序的改进算法，通过引入增量序列来提高排序效率。
希尔排序（Shell Sort）
林景的博客
08-08 1861
希尔排序的原理分析与算法实现
希尔排序的增量因子的选择
qq_22313643的博客
05-30 2954
希尔排序的增量序列 使用 Hibbard 增量 也就是 2^k -1 ，使用hibbard 增量序列可以使希尔排序的时间复杂度 在最坏的情况下为O(n^(3/2)) 也就是 n的3除2次方
Python3实现希尔排序（源代码）
最新发布
05-06
希尔排序（Shell Sort）是一种基于插入排序的改进算法，通过比较距离一定间隔的元素来工作，以加快排序速度。该算法首先将待排序的数组分割成若干个子序列，并对这些子序列进行插入排序。然后，通过逐渐缩小这些子...
leetcode数组中元素出现次数-DataStructureAndAlgorithm:数据结构/算法/LeetCode/剑指Offer
06-30
基于数组的实现 队列 名称 描述 出队操作为O(1) 堆 名称 描述 通过增加索引数组，避免直接对数据进行交换操作 同上 树 二分搜索树 名称 描述 深度优先（前中后序遍历）、广度优先(层序遍历) Hibbard Deletion avl树 ...
matlab分时代码-Bivis:遇见
05-21
–从双目图像集中生成ICA分量，拟合Gabor函数并保存数据。 可能需要用户输入以指定目录。 computeRandomICAcomponents.m –从双目图像集生成ICA分量，左右对混杂在一起以破坏左右图像之间的任何链接。 fillInNaNs.m ...
Vue.js_ 11 Practical Projects.pdf
08-16
1. Build a Basic CRUD App with Vue.js, Node and MongoDB by James Hibbard 2. Creating Beautiful Charts Using Vue.js Wrappers for Chart.js by Yomi Eluwande 3. Build a Real-time Chat App with Pusher and ...
SitePoint.Vue.js.11.Practical.Projects
06-11
Build a Basic CRUD App with Vue.js, Node and MongoDB by James Hibbard Creating Beautiful Charts Using Vue.js Wrappers for Chart.js by Yomi Eluwande Build a Real-time Chat App with Pusher and Vue.js...
c++实现多种线性表排序的算法（插入排序，希尔，冒泡，快速，堆排序，归并排序）
07-05
c++实现的线性表排序算法 插入排序，希尔排序，冒泡排序，快速排序，堆排序，归并排序等
希尔排序增量序列简介
热门推荐
Foliciatarier的博客
12-27 1万+
希尔排序可谓是时间复杂度较难分析的一类排序算法之一，其原因在于其增量序列的多样性和构造的复杂性。下面笔者将对几种流传较广的希尔排序的增量序列进行简单的介绍并给出它们的实现代码。
如何证明Hibbard增量的希尔排序的减枝条件
灯抓黄粱零夜起
11-21 2911
在要排序的M个元素的数组aa中 对于Hibbard增量来说，其增量序列为{1,3,7……hn−1,hn}\{1,3,7……h_{n-1},h_n\}，并且hi+1=2hi+1 h_{i+1}=2h_i+1 。当希尔排序运行到hih_i 时对子数组{……a[λ−2hi],a[λ−hi],a[λ]}\{……a[\lambda-2h_i],a[\lambda-h_i],a[\lambda]\}进行插入排
数据结构----希尔排序（最小增量排序）
s646575997的博客
05-20 4128
1.基本思想：算法现将要排序的一组数按某个增量d（n/2，n为要排序数的个数） 分成若干组，每组中记录的下标相差d。对每组中全部元素进行直接插入排序，然后再用一个较小的增量（d/2）对它进行分组，在每组中在进行直接插入排序。当增量减到1时，进行直接插入排序，排序完成。 2.实例： 3.代码实现：public static void shellSort(int[] a){ for(int
稳定性定义： 各算法稳定性 一、直接插入排序   二、折半插入排序  六、简单选择排序  三、希尔排序   四、冒泡排序  五、快速排序  七、堆排序   八、归并排序 
ZJQ的博客
08-28 630
稳定性定义：排序前后两个相等的数相对位置不变，则算法稳定。 稳定性得好处：从一个键上排序，然后再从另一个键上排序， 举个例子： 在数据库操作中，如下简单表格： 2(1) 4 3 8 2(2) 5 1 2 4 9 上表格第一个列，如果需要第一列排序，且使用稳定排序算法可得到 1 22(1) 4 2(2) 5 3...
希尔排序
大佬请赐教
03-27 288
一、概述 希尔排序是希尔（Donald Shell）于1959年提出的一种不稳定排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序。 首先我们知道直接插入排序的时间复杂度最低的时候应该是序列基本有序，待排序的记录个数较少时，效率较高。 基于这个基础理论，希尔排序的基本思想如下： 先将整个待排记录序列分割成若干子序列，分别进行直接插入排序，待整个序...
排序算法之希尔排序（C语言实现）
Jacky_Cmd
08-25 1596
希尔排序也叫缩小增量排序，它其实是直接插入排序的一种改进版本，实质是一种分组插入方法 基本思想： 算法先将要排序的一组数按某个增量d（d减到1时，整个要排序的数被分成一组，排序完成。 一般的初次取序列的一半为增量，以后每次减半，直到增量为1。 基本步骤： 以如下8个记录为例，来看一下排序的过程： 40，32，28，45，28，55，12，24 增量序列依次为：4，2，1
排序之希尔排序
starexplode的博客
01-01 225
希尔排序希尔排序是直接插入排序的升级，希尔排序的出现冲破了O(n2)O(n^2)时间的屏障， 它的思想是将待排序的序列分割成若干子序列，分割的方式是隔几个元素（相隔“增量”）取一个元素，然后依次进行直接插入排序，然后减小增量，循环进行上述的过程，直到增量为1。当增量为1是也就是对待排序的序列进行直接插入排序，那么排序之后的序列就肯定是有序的了。 随着增量的缩小会使整个序列达到基本有序，而直接插入排序
数据结构希尔排序算法
08-21
希尔排序是一种基于插入排序的排序算法，也被称为缩小增量排序。它通过将待排序的元素分成多个子序列进行排序，最后将整个序列排序。具体步骤如下： 1. 首先选择一个增量（间隔）序列，通常为初始序列长度的一半，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值