常用排序算法简单实现

//
//常用的排序算法，简单实现 
//
/


#include <stdio.h>
#include <stdlib.h>
void InsertSort(int * data,int length);
void print_array(int * data,int length);
void bubble_sort(int * data,int length);
void shell_sort(int * data,int length,int *dk,int t);
void quick_sort(int * data,int length);
void select_sort(int * data,int length);
void merge_sort(int *source,int *dest,int s,int t);
void heap_sort(int * data,int length);
/
int main(void)
{
    
    int arr[10]={1,8,6,9,7,2,4,3,0,5};
    int dest[10];
  //  InsertSort(arr,10);
      int dk[1]={1};
   //  shell_sort(arr,10,dk,1);
  // bubble_sort(arr,10);
 // quick_sort(arr,10);
 //select_sort(arr,10);
 //heap_sort(arr,10);
      merge_sort(arr,dest,1,10);
      print_array(arr,10);
    
}
//
//归并排序 
//
/

void merge(int *source,int *dest,int i,int m,int n)
{
     int j=m+1,k=i;
     for(;j<=n && i<=m;++k)
     {
        if(source[i-1]<source[j-1]) 
        {
            dest[k-1]=source[i-1];
            i++;
        }
        else
        {
            dest[k-1]=source[j-1];
            j++;
        }
        
     }
     while(i<=m)
     {
          dest[k-1]=source[i-1];
          k++;
          i++;
          
     }
     while(j<=n)
     {
          dest[k-1]=source[j-1];
           k++;
          j++;
     }
     
}
void merge_sort(int *source,int *dest,int s,int t)
{
     if(s==t) dest[s-1]=source[s-1];
     else
     {
         int mid=(s+t)/2;
         merge_sort(source,dest,s,mid);
         merge_sort(source,dest,mid+1,t);
         merge(source,dest,s,mid,t);
     }
}
//
//堆排序 
//
/


void heap_adjust(int * data,int s,int m)
{
   int temp=data[s-1];
   for(int j=2*s;j<=m;j*=2)
   {
       if(j<m && data[j-1]<data[j]) ++j; 
       if(data[s-1]>data[j-1]) break;
       data[s-1]=data[j-1];
       s=j;
   }
   
   data[s-1]=temp;
}

void heap_sort(int * data,int length)
{
     int i;
     for( i=length/2;i>0;i--)
     {
             heap_adjust(data,i,length);
     }
     for(i=length;i>1;i--)
     {
        int temp=data[i-1];
        data[i-1]=data[0];
        data[0]=temp;
        heap_adjust(data,1,i-1);
     }
}

//
//选择排序 
//
/
void select_sort(int * data,int length)
{
     int index;
     for(int i=0;i<length;i++)
     {
             index =i;
             for(int j=i+1;j<length;j++)
             {
                if(data[j]<data[index]) index=j;                   
            
             }
             
               int temp=data[index];
               data[index]=data[i];
               data[i]=temp;
     }
}

//
//快速排序 
//
/
int partition(int * data,int low,int high)
{
     int middle=data[low];
     while(low<high)
     {
          while(low<high &&  data[high]>=middle) high--; 
          data[low]=data[high];   
          while(low<high &&  data[low]<=middle) low++;                  
          data[high]=data[low];   
     }
     data[low]=middle;
     return low;
}
void qsort(int * data,int low,int high)
{
    if(low<high)
    {
        int mid=partition(data,low,high);
        qsort(data,low,mid-1);
        qsort(data,mid+1,high);        
    }
}

void quick_sort(int * data,int length)
{
     qsort(data,0,length-1);
}
//
//冒泡排序 
//
/
void bubble_sort(int * data,int length)
{
     bool ischange=true;
     for(int i=length-1;i>0 && ischange ;i--)
     {
         ischange=false;
         for(int j=0;j<i;j++)
         {
                 
            if(data[j+1]<data[j])
            {
               ischange=true;
                int temp=data[j+1];
                data[j+1]=data[j];
                data[j]=temp;             
            }
         }
     }
}


//
//插入排序 
//
/
void InsertSort(int * data,int length)
{
     if(length>0)
     {
            for(int i=1;i<length;i++)
            {
                    for(int j=i;j>0;j--)
                    {
                            if(data[j]<data[j-1])
                            {
                               int temp=data[j-1];
                               data[j-1]=data[j];
                               data[j]=temp;
                            }
                            
                    }
                 
            }
     }
}

//
//希尔排序 
//
/ 
void shell_insert(int * data,int length,int dk)
{
     /*
     for(int i=0;i<dk;i++)
     {
          int position=((length-i-1)/dk)*dk+i;
          for(int j=i+dk;j<=position;j+=dk)
          {
              for(int t=j;t>i;t-=dk)
              {
                   if(data[t]<data[t-dk])
                   {
                     int temp=data[t-dk];
                     data[t-dk]=data[t];
                     data[t]=temp;
                   }                  
              }
              
          }
         
     }
     */
     
     for(int i=dk;i<length;i++)
     {
             for(int j=i;j>=0;j-=dk)
             {
                   
                   if(data[j+dk]<data[j])
                   {
                     int temp=data[j+dk];
                     data[j+dk]=data[j];
                     data[j]=temp;
                   }        
             }
     }
     
     
} 

void shell_sort(int * data,int length,int *dk,int t)
{
     for(int i=0;i<t;i++)
     {
             shell_insert(data,length,dk[i]);
     }
}
//
//打印数组 
//
/ 
void print_array(int * data,int length)
{
     int *pBegin=data,*pEnd=data+10;
     
     for(;pBegin!=pEnd;) printf("%d\n",*pBegin++);
     system("pause");
}