排序算法

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

#include "sort.h"

/*插入排序*/
void insert_sort(int data[], int len)
{
 int i   = 0;
 int j   = 0;
 int key = 0;

 for (i = 1; i < len; i ++)
 {
  key = data[i];
  j   = i - 1;

  while (j >= 0 && data[j] > key)
  {
   data[j + 1] = data[j];
   j --;
  }

  data[j + 1] = key;
 }
}

/*shell排序*/
void shell_sort(int data[], int len)
{
 int temp = 0;
 int i, j;

 for (int increment = len / 2; increment > 0; increment /= 2)
  for (i = increment; i < len; ++ i)
  {
   temp = data[i];

   for (j = i; j >= increment; j -= increment)
    if (temp < data[j - increment])
     data[j] = data[j - increment];
    else
     break;

   data[j] = temp;
  }
}

/*冒泡排序*/
void bubble_sort(int data[], int len)
{
 int i, j;
 int exchange = 0;
 int tmp;

 for (i = 0; (i < len) && (!exchange); ++ i)
 {
  exchange = 1;

  for (j = i + 1; j < len; ++ j)
  {
   if (data[j] < data[i])
   {
    tmp         = data[j];
    data[j]     = data[i];
    data[i]     = tmp;

    exchange = 0;
   }
  }

 }
}

void swap_data(int &a, int &b)
{
 a  = a + b;
 b  = a - b;
 a  = a - b;
}

int partition_data(int data[], int low, int high)
{
 int pivot = data[low];

 while (low < high)
 {
  while(low < high && data[high] >= pivot)
   -- high;

  swap_data(data[low], data[high]);

  while(low < high && data[low] <= pivot)
   ++ low;

  swap_data(data[low], data[high]);
 }

 return low;
}

/*快速排序*/
void quick_sort(int data[], int p, int r)
{
 if (p < r)
 {
  int n = partition_data(data, p, r);
  quick_sort(data, p, n);
  quick_sort(data, n + 1, r);
 }
}

void merge_data(int data[], int p, int q, int r)
{
 int  i, j, k;
 int  n = q - p + 1;
 int  m = r - q;
 int  *pDataL = (int *)malloc(sizeof(int) * n);
 int  *pDataR = (int *)malloc(sizeof(int) * m);

 for (i = 0; i < n; ++ i)
  pDataL[i] = data[p + i];

 for (i = 0; i < m; ++ i)
  pDataR[i] = data[q + i + 1];

 for (k = p, i = 0, j = 0; k <= r && i < n && j < m; ++ k)
  if (pDataL[i] <= pDataR[j])
   data[k] = pDataL[i ++];
  else
   data[k] = pDataR[j ++];                                       

 while (i < n)
  data[k ++] = pDataL[i ++];

 while (j < m)
  data[k ++] = pDataR[j ++];

 free(pDataL);
 free(pDataR);
}

/*归并排序*/
void merge_sort(int data[], int p, int r)
{
 int q;

 if (p < r)
 {
  q = (p + r) / 2;
  merge_sort(data, p, q);
  merge_sort(data, q + 1, r);
  merge_data(data, p, q, r);
 }
}

/*简单选择排序*/
void select_sort(int data[], int len)
{
 int i, j, m;
 int tmp = 0;

 for(i = 0; i < len - 1; i ++)
 {
  m = i;

  for (j = i + 1; j < len; j ++)
   if (data[j] < data[m])
    m = j;

  if (i != m)
  {
   tmp     = data[i];
   data[i] = data[m];
   data[m] = tmp;
  }
 }
}

/*记数排序*/
void count_sort(int data[], int len)
{
 int i, min, max;

 min = max = data[0];

 for (i = 1; i < len; ++ i)
 {
  if (data[i] < min)
   min = data[i];
  else if(data[i] > max)
   max = data[i];
 }

 int range = max - min + 1;
 int *count = (int *)malloc(range * sizeof(int));

 for(i = 0; i < range; i++)
  count[i] = 0;

 for(i = 0; i < len; i++)
  count[data[i] - min ]++;

 int j, z = 0;
 for(i = min; i <= max; i++)
  for(j = 0; j < count[ i - min ]; j++)
   data[z++] = i;

 free(count);
}

/*鸡尾酒排序*/
void cocktail_sort(int data[], int len)
{
 int  bottom = 0;
 int  top = len - 1;
 bool swapped = 1;
 
 while (swapped == 1)
 {
  swapped = 0;

  for (int i = bottom; i < top; i ++)
  {
   if (data[i] > data[i + 1])
   {
    swap_data(data[i], data[i + 1]);
    swapped = 1;
   }
  }

  top --;
  for (int i = top; i > bottom; i --)
  {
   if (data[i] < data[i - 1])
   {
    swap_data(data[i], data[i - 1]);
    swapped = 1;
   }
  }

  bottom ++;
 }
}

/*奇偶排序*/
void oddevent_sort(int data[], int len)
{
 bool sorted = 0;

 while (!sorted)
 {
  sorted = 1;

  for (int i = 1; i < len - 1 ; i += 2)
  {
   if (data[i] > data[i + 1])
   {
    swap_data(data[i] ,data[i + 1]);
    sorted = 0;
   }
  }

  for (int j = 0; j < len - 1; j += 2)
  {
   if (data[j] > data[j + 1])
   {
    swap_data(data[j] ,data[j + 1]);
    sorted = 0;
   }
  }
 }
}

void sift(int data[], int startIndex, int Length)
{
 while(2 * startIndex + 1 < Length)
 {
  int childIndex = 2 * startIndex + 1;

  if(2 * startIndex + 2 < Length)
  {
   if(data[2 * startIndex + 1]<data[2 * startIndex + 2])
    childIndex = 2 * startIndex + 2;
  }
  if(data[startIndex] < data[childIndex])
  {
   swap_data(data[startIndex],data[childIndex]);
   startIndex = childIndex ;
  }
  else
   break;
 }

 return;
}

/*堆排序*/
void heap_sort(int data[], int Length)
{
 int i = 0;

 for (i = Length / 2 - 1; i >= 0; i --)
  sift(data, i, Length);

 for (i = Length - 1; i > 0; i --)
 {
  swap_data(data[0],data[i]);
  sift(data, 0, i);
 }
}

int radix_count_sort(int* npIndex, int nMax, int* npData, int nLen)
{
 int* pnCount  = (int*)malloc(sizeof(int)* nMax);     
 int * pnSort  = (int*)malloc(sizeof(int) * nLen);  

 for (int i = 0; i < nMax; ++i)
  pnCount[i] = 0;

 for (int i = 0; i < nLen; ++i)   
  ++pnCount[npIndex[i]];

 for (int i = 1; i < 10; ++i) 
  pnCount[i] += pnCount[i - 1];

 for (int i = nLen - 1; i >= 0; --i)
 {
  --pnCount[npIndex[i]];       
  pnSort[pnCount[npIndex[i]]] = npData[i];
 }

 for (int i = 0; i < nLen; ++i)      
  npData[i] = pnSort[i];

 free(pnSort);                     
 free(pnCount);

 return 1;
}

/*基数排序*/
int radix_count(int data[], int nLen)
{
 int* nDataRadix  = (int*)malloc(sizeof(int) * nLen);

 int nRadixBase = 1;     
 bool nIsOk     = false; 

 while (!nIsOk)
 {
  nIsOk = true;
  nRadixBase *= 10;

  for (int i = 0; i < nLen; ++i)
  {
   nDataRadix[i] = data[i] % nRadixBase;
   nDataRadix[i] /= nRadixBase / 10;

   if (nDataRadix[i] > 0)
    nIsOk = false;
  }
  if (nIsOk)       
   break;

  radix_count_sort(nDataRadix, 10, data, nLen);
 }

 free(nDataRadix);

 return 1;
}