各种排序算法总结

/* Created by vencent on 2008.8.29 */

/* 本文件列出了各种排序方法：

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};
/*
int * array;
int i;
array = (int*)malloc(sizeof(int) * Len);
for (i = 0; i < Len; i++)
{
array[i] = Len - i;
}

  */

    HeapSort(array,10);
printf("\nThe 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);
}

}