经典排序算法代码

总结以前学数据结构的排序算法，都亲自测试通过：

/* 本文件列出了各种排序方法：
1.插入排序
1.1 一般插入排序 InsertSort(int* array, int length)
1.2 折半插入排序 BinInsertSort(int* array, int length)
1.3 希尔排序     ShellSort(int* array, int length)

2.交换排序
2.1 冒泡排序     BubbleSort(int* array, int length)
2.2 快速排序 QuickSort(int* array, int length)

3.选择排序
3.1 一般选择排序 SelectSort(int* array, int length)
3.2 堆排序       StackSort(int* array, int length)
*/

#include "sort.h"
//排序算法的测试程序
void TestSort()
{
       int i;
       int array[10] ={3,5,2,1,8,10,4,7,6,9};

        HeapSort(array,10);  // 后续换成其它各种排序方法
printf("\n The result :\n");
for (i = 0; i < Len; i++)
{
printf("%d ",array[i]);
}
}


//插入排序：
void InsertSort(int *array, int length)
{
int i,j,k;
int temp;
for (i = 1; i < length; i++)
{
  
  for(j = 0; j < i  && array[j] < array[i]; j++);   

  temp = array[i];
          for(k = i ;  k > j ; k--) 
  {
 array[k] = array[k-1];
  }    
  array[j] = temp;
}
}

//折半插入排序
void BinInsertSort(int *array, int length)
{
int i,j,k;
int temp;
int low,high,mid;
for (i = 1; i < length; i++)
{   
low = 0 ;
high = i-1;
//一定要注意low==high这个条件
while(low < high || low == high)
{
mid = (low + high)/2;
if(array[mid] > array[i])
high = mid-1;
else
low = mid+1;
}
j = low ;

  temp = array[i];
          for(k = i ;  k > j ; k--) 
  {
 array[k] = array[k-1];
  }
   
  array[j] = temp;
}
}

//冒泡排序：
void BubbleSort(int *array, int length)
{
int i,j;
int temp;

for(i = 0 ; i < length - 1; i++)
for(j = 1; j < length - i; j++)
{
if(array[j] < array[j-1])
{
temp = array[j];
array[j] = array[j-1];
array[j-1] = temp;
}
}
}


//快速排序
void QuickSort(int *array, int start, int end)
{
   int div;   


   if(start < end)
   {
     div = partition(array, start, end);
     QuickSort(array, start, div-1);
     QuickSort(array, div+1, end);
   }
}


//快速排序分区
int partition(int *array, int start, int end)
{
int target;
int low,high;

target = array[start];
low = start;
high = end;

while(low < high)
{
while((array[high] > target || array[high] == target) && (low < high) )
{
high--;
}
array[low] = array[high]; //此处low不能加1。


while((array[low] < target || array[high] == target) && ( low < high ) )
{
low++;
}
array[high] = array[low]; //此处high不能减1。
}


array[low] = target;
return low;


}

//堆排序（将堆看成是一棵完全二叉树，存放在一维数组中）
//adjust()函数:假设初始堆已经有序，现将最小的元素取出，并用最后一个元素至于小堆的堆顶，
//重新调整堆，使其重新调整成为一个小堆。
void adjust(int *array, int start, int end)
{
   int j;
   int location = start;
   int temp = array[start];


   for(j = start; 2 * (j + 1) - 1 < end + 1; )
   {

if(2 * (j + 1) < end + 1 && array[2 * (j + 1) - 1] > array[2 * (j + 1)]) 
{
j = 2 * (j + 1);//右边元素偏小的话，指向右边元素。
}
else
{ 
j = 2 * (j + 1) - 1;
}


if( temp > array[j]) //注意此处为temp，而不是array[location]
{
  array[location] = array[j];
  location = j;
}
   }
   array[location] = temp;
}


//完整的堆排序过程：

void HeapSort(int *array, int length)
{
int i,temp;
//创建初始堆：
for( i = (length-1-1)/2; i > 0 || i == 0; i--)
{
adjust(array, i, length-1);
}


//不断调整堆来排序：
for( i = length - 1; i > 0 ; i--)
{
        temp = array[i];
array[i] = array[0];
array[0] = temp;


adjust(array, 0, i-1);
}
}