实现排序（二分、插入、堆排

#include <iostream>
#include <stdio.h>
#include <time.h>
#include "head.h"
using namespace std;
//realize headSort
const int maxn=1000;
typedef int KeyType;
typedef int DataType;
typedef struct {
    KeyType key;
    DataType info;
}RecordNode;
typedef struct {
    int n;//n for num of recornode
    RecordNode * record;
}SortObject;
void printStruct(SortObject * pvector);
void sift(SortObject * pvector, int size, int p);
void headSort(SortObject *pvector);
void insertSort (SortObject *pvector);
void binSort(SortObject *sortObject);

int main() {
    SortObject *sortObject = (SortObject *)malloc(sizeof( SortObject));
    srand((unsigned )time(NULL));
    RecordNode r[maxn];

    sortObject->record=r;

    sortObject->n=0;

    for (int i = 0; i < maxn; ++i) {
        r[i].key=rand();
        sortObject->n++;
    }
    clock_t start,end;

    printf("befort Sort
");
    printStruct(sortObject);
    printf("***************************************************************************************************************************************************************************
");
    start=clock();
   // headSort(sortObject);
  // insertSort(sortObject);
    binSort(sortObject);
    end = clock();
    printf("binSort 1000 num using time = %f ms
",(double)end-start/CLK_TCK);
    printf("after Sort
");
    printStruct(sortObject);
    return 0;

}
void headSort(SortObject *pvector)
{
    int i,n;
    RecordNode temp;
    n=pvector->n;
    for ( i = n/2-1; i >= 0 ; --i) {
        sift(pvector,n,i);
    }

    for( i = n - 1; i > 0; i--)
    {
        temp = pvector->record[0];
        pvector->record[0] = pvector->record[i];
        pvector->record[i] = temp;
        sift(pvector, i, 0);
    }
}

void sift(SortObject * pvector, int size, int p)
{
    RecordNode  temp = pvector ->record[p];
    int child = 2 * p  + 1;
    while (child < size)
    {
        if ((child < size - 1 ) &&
        (pvector->record[child].key < pvector->record[child + 1].key) )
        {
            child++;
        }
        if (temp.key < pvector->record[child].key) {
            pvector->record[p] = pvector->record[child];

            p = child;
            child = 2 * p + 1;
        }else break;
    }
pvector->record[p]= temp;
}
void printStruct(SortObject * pvector)
{
    RecordNode *temp=pvector->record;
    int cnt=0;
    while(cnt<maxn)
    {
        printf("%d ",temp[cnt].key);
        cnt++;
    }
}
void insertSort (SortObject *pvector)
{
    int i,j;
    RecordNode tmp;
    RecordNode *data = pvector->record;
    for(i = 1; i < pvector->n; i++)
    {
        tmp = data[i];
        for(j= i-1; tmp.key < data[j].key && j >= 0 ; j--)
        {
            data[j + 1] = data[j];
        }
            if (j != i-1)
            {
                data[j + 1] = tmp;
            }
    }
}
void binSort(SortObject *sortObject)
{
    int i, j, left, mid, right;
    RecordNode temp;
    RecordNode *data = sortObject->record;
    for(i = 1; i < sortObject->n; i++)
    {
        temp = data[i];
        left = 0;
        right = i-1;

        while (left <= right)
        {
            mid = (left + right)/2;
            if(temp.key < data[mid].key)
            {
                right = mid - 1;
            }else{
                left = mid + 1;
            }
        }
            for(j = i -1;  j>= left ;j--)
            {
                data[j+1]=data[j];
            }
            if(left != i)
            {
                data[left] = temp;
            }

    }
}