各种排序

各种排序实现，无聊写出来，留个念像。

 

#include <stdio.h>
#include <stdlib.h>

#define SORT_ARRAY_SIZE 40
#define SWAP(a, b, temp) (temp) = (a); (a) = (b); (b) = (temp);

void heapSort(int *array, int size);
void adjustHeap(int *array, int root, int size);
void quickSort(int *array, int begin, int end);
void mergeSort(int *array, int begin, int end);
void merge(int *array, int begin, int end);
void insertSort( int *array, int size );
void swapSort( int *array, int size );
void pickSort(int *array, int size);
void mkRandomArray(int *array, int size);
void printArray(int *array, int size);
void printArrayOneLine(int *array, int begin, int end);
int verifySort(int *old, int *sorted, int size);

int main()
{
  int *array, *arrayVerify;

  array = (int *)calloc(SORT_ARRAY_SIZE, sizeof(int));
  arrayVerify = (int *)calloc(SORT_ARRAY_SIZE, sizeof(int));
  mkRandomArray(array, SORT_ARRAY_SIZE);
  array[0] = 0;
  memcpy(arrayVerify, array, SORT_ARRAY_SIZE*sizeof(int));

  heapSort(array, SORT_ARRAY_SIZE - 1);
 
  printArray(array, SORT_ARRAY_SIZE);

  verifySort(arrayVerify, array, SORT_ARRAY_SIZE);

  free(array);
  free(arrayVerify);
  return 0;
}


void heapSort(int *array, int size)
{
  int loopi;
  int temp;

  for( loopi = size/2; loopi > 0; loopi-- )
    adjustHeap(array, loopi, size);

  for( loopi = size - 1; loopi > 0; loopi-- )
  {
    SWAP( *(array + loopi + 1), *(array + 1), temp );
    adjustHeap(array, 1, loopi);
  }

}
void adjustHeap(int *array, int root, int size)
{
  int child;
  int temp;

  child = root*2;
 
  while( child <= size )
  {
    if( child < size && *(array + child) < *(array + child + 1) )
      child++;

    if( *(array + child/2) >= *(array + child) )
      break;
    else
    {
      SWAP(*(array + child/2), *(array + child), temp);
      child = 2*(child);
    }
  }
}


void quickSort(int *array, int begin, int end)
{
  int seed;
  int pre, fol, tmpval;

  if( begin >= end )
    return;

  seed = *(array + begin);
  pre = begin;
  fol = end;

  while( pre < fol )
  {
    while( *(array + pre) < seed )
      pre++;

    while( *(array + fol) >= seed )
      fol--;

    if( pre < fol )
    {
      tmpval = *(array + pre);
      *(array + pre) = *(array + fol);
      *(array + fol) = tmpval;
    }
  }

  quickSort(array, begin, pre - 1);
  if( *(array + pre) == seed )
    quickSort(array, pre + 1, end);
  else
    quickSort(array, pre, end);
}


void mergeSort(int *array, int begin, int end)
{
  if( begin >= end )
    return;

  int mid;
  mid = (begin + end)/2;

  mergeSort(array, begin, mid);
  mergeSort(array, mid + 1, end);
  merge(array, begin, end);
}


void merge(int *array, int begin, int end)
{
  int *tmpArray;
  int mid, pos1, pos2, posTmpArray;

  tmpArray = (int *)calloc(end - begin + 1, sizeof(int));
  mid = (end + begin)/2;
  pos1 = begin;
  pos2 = mid + 1;
  posTmpArray = 0;

  while( pos1 <= mid && pos2 <= end )
  {
    if( *(array + pos1) > *(array + pos2) )
    {
      *(tmpArray + posTmpArray) = *(array + pos2);
      pos2++;
    }
    else
    {
      *(tmpArray + posTmpArray) = *(array + pos1);
      pos1++;
    }
    posTmpArray++;
  }

  if( pos1 > mid )
    memcpy(tmpArray + posTmpArray, array + pos2, sizeof(int)*(end - pos2 + 1));
  else
    memcpy(tmpArray + posTmpArray, array + pos1, sizeof(int)*(mid - pos1 + 1));
 
  memcpy(array + begin, tmpArray, (end - begin + 1)*sizeof(int));

  free(tmpArray);
}


void insertSort( int *array, int size )
{
  int loopi, loopj;
  int pos, tmpval;

  for( loopi = 1; loopi < size ; loopi++ )
  {
    tmpval = *(array + loopi);
    pos = loopi;
   
    for( loopj = 0; loopj < loopi; loopj++ )
    {
      if( *(array + loopj) > *(array + loopi) )
      {
        pos = loopj;
        break;
      }
    }
     
   
    for( loopj = loopi; loopj > pos; loopj-- )
      *(array + loopj) = *(array + loopj - 1);
   
    *(array + pos) = tmpval;
  }
}


void swapSort( int *array, int size )
{
  int loopi, loopj;
  int tmpval;

  for( loopi = size; loopi > 0; loopi-- )
  {
    for( loopj = 1; loopj < loopi; loopj++ )
    {
      if( array[loopj] < array[loopj-1])
      {
        tmpval = array[loopj - 1];
        array[loopj - 1] = array[loopj];
        array[loopj] = tmpval;
      }
    }
  }
}


void pickSort(int *array, int size)
{
  int maxpos;
  int tmpval;
  int loopi, loopj;

  for( loopi = size; loopi > 0; loopi-- )
  {
    maxpos = 0;
    for( loopj = 1 ; loopj < loopi ; loopj++ )
      maxpos = array[maxpos] < array[loopj] ? loopj : maxpos;

    tmpval = array[loopi - 1];
    array[loopi - 1] = array[maxpos];
    array[maxpos] = tmpval;
  }

}


void mkRandomArray(int *array, int size)
{
  int loopi;  
  srand(time(0));
 
  loopi = -1;
  while( ++loopi < size )
    array[loopi] = rand()000;
}



void printArray(int *array, int size)
{
  int loopi;  

  loopi = -1;
  while( ++loopi < size )
    printf("%d: %d\n", loopi, array[loopi]);

}


void printArrayOneLine(int *array, int begin, int end)
{
  int loopi;  

  loopi = begin - 1;
  while( ++loopi <= end)
    printf("%d ", array[loopi]);
  printf("\n");

}


int verifySort(int *old, int *sorted, int size)
{
  int loopi, loopj;

  loopi = 0;
  while(++loopi < size)
    if(*(sorted + loopi) < *(sorted + loopi - 1))
    {
      printf("Order Verify Failed!!!!");
      return 0;
    }

 
  for( loopi = 0; loopi < size; loopi++ )
  {
    for( loopj = 0; loopj <= size; loopj++ )
    {
      if( loopj == size )
      {
        printf("Memebers Verify Failed!!!!");
        return 0;
      }

      if(*(sorted + loopj) == *(old + loopi))
      {
        *(sorted + loopj) = -1;
        break;
      }
    }
  }
  printf("Sort Verify passed!!");
  return 1;
}

 

 

 

 青春就应该这样绽放  游戏测试：三国时期谁是你最好的兄弟！！  你不得不信的星座秘密