排序算法1

冒泡排序  选择排序  堆排序  插入排序

直接上代码：

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<string.h>
#include<unistd.h>
#define Maxarr 32

void print(int arr[],size_t size)
{
    size_t i;

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

void swap(int* a, int* b)
{
     int tmp;
     tmp=*a;
     *a=*b;
     *b=tmp;
}

//上升序列
void bubble_sort(int arr[], int size)
{
    int i;
    int j;
    int count=0;

    for(i=0;i<size;i++)
    {

        for(j=0;j<size-i-1;j++)
        {
           if(arr[j] > arr[j+1])
           {
               swap(&arr[j],&arr[j+1]);
               count=1;
           }

        }

        if(count==0)
        {
          break;
        }
    }

}


void selection_sort(int arr[], int  size)
{
      int max;
      int i;
      int j;
 
      for(i=0;i<size-1;i++)
      {
         max=i;

        for(j=i+1; j<size;j++)
        {
            if(arr[j]>arr[max])
           {
              max=j;
           }

        }

        swap(&arr[i],&arr[max]);
      }
}


// 大堆

// 小堆
//
#define HeapMaxsize 1000
typedef int HeapType;

typedef int (*Compre)(HeapType a,HeapType b);

typedef struct Heap
{
    HeapType elem[HeapMaxsize];
    size_t size;
    Compre cmp;
}Heap;

int Greater(HeapType a, HeapType b)
{
    return a>b? 1:0;
}

int Less(HeapType a, HeapType b)
{
    return a<b? 1:0;
}


void Adjust_up(Heap* hp)
{
    int child=hp->size-1;
    int parent=(child-1)/2 ;
    
    while(1)
    {
      if(parent<0)
      {
         return;
      }

      if(hp->cmp(hp->elem[child], hp->elem[parent]))
      {
          swap(&hp->elem[child],&hp->elem[parent]);
      }
      else
      {
          return;
      }
      
      child=parent;
      parent=(child-1)/2;

    }
    
}

void heap_insert(Heap* hp, int elem)
{
     if(hp==NULL)
    {
        return;
    }
    
     if(hp->size>=HeapMaxsize)
    {
         return;
    }
    
    hp->elem[hp->size]=elem;
    ++hp->size;
    Adjust_up(hp);
}


void Adjust_down(Heap* hp)
{
     size_t parent=0;
     size_t lchild=parent*2+1;
     size_t rchild=(parent+1)*2;
     size_t child;
      
     while(1)
     {

       // greater child choose
         if(lchild>hp->size-1)
         {
             return;
         }

         if(rchild>hp->size-1)
         {
             child=lchild;
         }
         else if(hp->cmp(hp->elem[lchild], hp->elem[rchild]))
         {
             child=lchild;
         }
         else
         {
              child=rchild;
         }

       // to dujust down
         if(hp->cmp(hp->elem[child], hp->elem[parent]))
         {
            swap(&hp->elem[parent],&hp->elem[child]);
         }
         else
         {
             return;
         }
       // change parent and child
      
         parent=child;
         lchild=parent*2+1;
         rchild=(parent+1)*2;
     }
      
}

void heap_erase_all(Heap* hp)
{

    while(hp->size>1)
    {
     swap(&hp->elem[hp->size-1],&hp->elem[0]);
     --hp->size;
     
     Adjust_down(hp);

    }

    if(hp->size==1)
    {
        --hp->size;
        return;
    }

}
void heap_sort(int arr[],int size)
{
     Heap hp;
     
     hp.size=0;
     hp.cmp=Greater;
     int i=0;
    
     while(i<size)
     {
         heap_insert(&hp, arr[i]);
         i++;
     }
     printf("insert:");
     print(hp.elem, hp.size);
     
     heap_erase_all(&hp);
    
     memmove(arr,&hp.elem, size*sizeof(int) );


}




void insert_elemt(int *begin, int*end)
{

     int tmp=*end;
     
     int* cur=end-1;
    
     int i;
    
     int size=end-begin;
    
     for(i=size;i>=0;i--)
     {
        *(cur+1)=*cur;
         cur-=1 ;
     }
     
     *begin=tmp;
    

}
void insertion_sort(int arr[], int size)
{
       int i;
       int cur;

       for(i=1;i<size;i++)
       {
          for(cur=0;cur<i;cur++)
          {
              if(arr[i]<arr[cur])
              {
                  insert_elemt(&arr[cur], &arr[i]);
              }
          }
              
       }



}


int main()
{
    int arr[Maxarr];
    size_t i;
    struct timespec tm;
    for(i=0;i<Maxarr;i++)
    {
        clock_gettime(CLOCK_REALTIME,&tm);
        srand(tm.tv_nsec);
        arr[i]=rand()%100;
    }
    printf("arr:");
    print(arr,Maxarr);
    printf("\n=========TEST BUBBLE=============\n");
    bubble_sort(arr,Maxarr);
    printf("sort:");
    print(arr,Maxarr);
    printf("\n=========TEST SELECTION=============\n");
    selection_sort(arr,Maxarr);
    printf("sort:");
    print(arr,Maxarr);
    printf("\n=========TEST INSERTION=============\n");
    insertion_sort(arr, Maxarr);
    printf("sort:");
    print(arr,Maxarr);
    printf("\n=========TEST HEAPSORT=============\n");
    heap_sort(arr, Maxarr);
    printf("sort:");
    print(arr,Maxarr);
    return 0;
}

运行结果：（qq截图最近好像出了点问题。。效果很差）