快速排序/堆排序

hsort.h

/*************************************************************************
        > File Name: heapsort.h
        > Author: zhoulin
        > Mail: [email protected]
        > Created Time: Wed Apr 13 12:52:15 2016
 ************************************************************************/

#ifndef _HEAPSORT_H
#define _HEAPSORT_H
typedef struct _heap{
    int *array;
    int  heapsize; //heap size
    int  len; //array len
}heap;
//swap a and b
void swap(int *a,int *b);
void adjust(heap *p,int i);
void heap_sort(heap *p);

//-------------split--------------
int parttion(int *arr,int left,int right);
void quit_sort(int *arr,int start,int end);
#endif

hsort.c:

/*************************************************************************
        > File Name: heapsort.c
        > Author: zhoulin
        > Mail: [email protected]
        > Created Time: Wed Apr 13 12:55:18 2016
 ************************************************************************/

#include "hsort.h"
#include <stdio.h>
void swap(int *a,int *b)
{
    *a = *a^*b;
    *b = *a^*b;
    *a = *a^*b;
}
void adjust(heap *p,int i)
{
    if(p == NULL)
        return;
    int *array = p->array;
    int largest;
    int left = (i+1)<<1-1;
    int right = (i+1)<<1;
    int curmax = p->heapsize;
    if(left < curmax &&  array[left] > array[i])
    {
        largest = left;
    }else{
        largest = i;
    }
    if(right < curmax && array[right] > array[largest])
    {
        largest = right;
    }
    if(largest != i)
    {
        swap(&array[largest],&array[i]);
        adjust(p,largest);
    }
}
void heap_sort(heap *p)
{
    int *array = p->array;
    int i,len = p->len;
    for(i=(len>>1)-1;i>=0;i--)
    {
        fprintf(stdout,"build %d\n",i);
        adjust(p,i);
    }
    while(p->heapsize >0)
    {
        swap(&array[0],&array[p->heapsize]);
        p->heapsize--;
        adjust(p,0);
    }
}
int parttion(int *arr,int left,int right)
{
    int cur = arr[left];
    while(left < right && arr[right] >= cur)
    {
        right--;
    }
    if(left < right)
    {
        arr[left++] = arr[right];
    }
    while(left < right && arr[left] <= cur)
    {
        left++;
    }
    if(left < right)
    {
        arr[right--] = arr[left];
    }
    arr[left] = cur;
    return left;
}

void quit_sort(int *arr,int start,int end)
{
    int pos;
    if(start <= end)
    {
        pos = parttion(arr,start,end);
        quit_sort(arr,0,pos-1);
        quit_sort(arr,pos+1,end);
    }
}
int main(void)
{
    heap p;
    int i;
    int arr[9]={100,1,300,56,34,45,67,21,89};
    /*
    p.array = (int *)&arr;
    */
    int len = 9;
    for(i = 0;i< len;i++)
    {
        fprintf(stdout,"arr[%d] = %d\n",i,arr[i]);
    }
    fprintf(stdout,"-----------------------------------------\n\n");
    quit_sort(arr,0,len-1);
    /*
    p.len = len;
    p.heapsize = p.len -1;
    heap_sort(&p);
    */
    for(i = 0;i< len;i++)
    {
        fprintf(stdout,"arr[%d] = %d\n",i,arr[i]);
    }
    return 0;
}

运行结果:

[email protected]:~/code/cwork/demo:./hsort
arr[0] = 100
arr[1] = 1
arr[2] = 300
arr[3] = 56
arr[4] = 34
arr[5] = 45
arr[6] = 67
arr[7] = 21
arr[8] = 89
-----------------------------------------

arr[0] = 1
arr[1] = 21
arr[2] = 34
arr[3] = 45
arr[4] = 56
arr[5] = 67
arr[6] = 89
arr[7] = 100
arr[8] = 300
时间: 2024-11-08 09:54:28

快速排序/堆排序的相关文章

C# 插入排序 冒泡排序 选择排序 快速排序 堆排序 归并排序 基数排序 希尔排序

下面列出了数据结构与算法的八种基本排序:插入排序 冒泡排序 选择排序 快速排序 堆排序 归并排序 基数排序 希尔排序,然后是测试的例子.代码位置:http://download.csdn.net/detail/luozuolincool/8040027 排序类: public class Sortings { //插入排序 public void insertSort(int[] array) { int temp = 0; int index = 0; for (int i = 0; i <

8大排序算法---我熟知3(归并排序/快速排序/堆排序)

排序算法: 快排: o(nlogn) o(1)不稳定 归并:o(nlogn) o(n) 稳定 基数: 冒泡 睡眠 面条 烙饼 1.quicksort: 返回条件:start >=end private = a[start]+a[end]/2 while(left <= right) while(left <= right && a[left] < privot) while(left <= right && a[right] > priv

常见排序算法的实现(归并排序、快速排序、堆排序、选择排序、插入排序、希尔排序)

这篇博客主要实现一些常见的排序算法.例如: //冒泡排序 //选择排序 //简单插入排序 //折半插入排序 //希尔排序 //归并排序 //双向的快速排序 //单向的快速排序 //堆排序 对于各个算法的实现原理,这里不再多说了,代码中注释较多,结合注释应该都能理解算法的原理,读者也可自己google一下.另外,注释中有很多点,比如边界条件.应用场景等已经用 * 标记,* 越多,越应该多注意. 下面是实现: //冒泡排序 void BubbleSort(int *arr, int n) { if(

排序算法总结

各种排序算法总结  排序算法  插入排序 冒泡排序  选择排序  归并排序  快速排序 堆排序  计数排序  基数排序  桶排序  思想  构建有序序列 两两交换 每次找一个最小值 分治法思想 分治法思想 最小堆.最大堆 数字本身的属性  对数据选择多种基数  函数的映射关系.Hash  数据结构  数组  数组  数组  数组 不定   数组 数组 数组  数组  最差时间复杂度 O(n^2)   O(n^2)   O(n^2)   O(n*lgn)  O(n^2).改进O(n*lgn)  O

数据结构——各排序算法的比较

1.从时间复杂度比较  从平均时间复杂度来考虑,直接插入排序.冒泡排序.直接选择排序是三种简单的排序方法,时间复杂度都为O(n2),而快速排序.堆排序.二路归并排序的时间复杂度都为O(nlog2n),希尔排序的复杂度介于这两者之间.若从最好的时间复杂度考虑,则直接插入排序和冒泡排序的时间复杂度最好,为O(n),其它的最好情形同平均情形相同.若从最坏的时间复杂度考虑,则快速排序的为O(n2),直接插入排序.冒泡排序.希尔排序同平均情形相同,但系数大约增加一倍,所以运行速度将降低一半,最坏情形对直接

阿里巴巴2015研发工程师笔试题,带答案

欢迎对本文提出补充建议,可以在以下平台上我留言. 个人博客站点:www.anycodex.com/blog/ Csdn博客站点:http://my.csdn.net/?ref=toolbar 微博:http://weibo.com/1958069172/profile?topnav=1&wvr=5&user=1 1.int main(){ fork()||fork(); }共创建几个进程? 答:3个. [知识点] ? 一个现有进程可以调用fork函数创建一个新进程.由fork创建的新进程被

Java算法

我们常见的排序分为以下几类: 插入排序(直接插入排序,希尔排序) 交换排序(冒泡排序,快速排序) 选择排序(直接选择排序,堆排序) 归并排序 分配排序(箱排序,基数排序) 对于以上的排序有什么不同呢? 需要的辅助空间组多的:归并排序, 需要的辅助空间最小的:堆排序,平均速度最快的:快速排序 时间复杂度: O(nlogn): 快速排序, 堆排序, 归并排序 O(n2): 直接插入排序, 冒泡排序, 直接选择排序 O(n): 基数排序 空间复杂度: O(1): 直接插入排序, 冒泡排序, 直接选择排

数据排序(二)

归并排序 归并排序(MERGE SORT)是又一类不同的排序方法,归并的含义就是将两个或两个以上的有序数据序列合并成一个新的有序数据序列,因此它又叫归并算法. 例如,有两个有序表,(7,10,13,15)和(4,8,19,20),归并后得到的有序表为(4,7,8,10,13,15,19,20) . 归并过程:比较a[i]和b[j]的大小,若a[i]<=b[j],则将第一个有序序列中的元素a[i]复制到r[k]中,并令i和k分别加1,分别指向后一个单元,否则将第二个有序序列的元素b[j]复制到r[

[Node.js] 闭包和高阶函数

原文地址:http://www.moye.me/2014/12/29/closure_higher-order-function/ 引子 最近发现一个问题:一部分写JS的人,其实对于函数式编程的概念并不是太了解.如下的代码片断,常常让他们觉得不可思议: OAuth2Server.prototype.authCodeGrant = function (check) { var self = this; return function (req, res, next) { new AuthCodeG