基本内排序算法基本原理

/*内排序算法*/
#include <stdio.h>
#include <stdlib.h>
//#include <intrins.h>

#define  MAXE 20
#define  PARENT(i) i / 2   //i/2
#define  LEFT(i)  i * 2   //i*2
#define  RIGHT(i) i * 2 + 1  //i*2+1

typedef  int  KeyType;   //key word be used in sort
typedef  char InfoType;  //other data in the Item
typedef struct
{
 KeyType key;
 InfoType data;
}RecType;

//void InsertSort(RecType *r, int n);
//void ShellSort(RecType *r, int n);
//void BubbleSort(RecType *r, int n);
//void QuickSort(RecType *r,int s,int t);
//void SelectSort(RecType *r, int n);
//void HeapSort(RecType *R, int n);
//void MergeSort(RecType *r, int n);

int main()
{
 //int  i;
 KeyType userdata[10] = {12,3,3079,778,210,521,34,3,120,100};
 RecType rec[10];
 for(int i=0;i<10;i++)
  rec[i].key = userdata[i];
 MergeSort(rec, 10);
 printf("the sorted sequence is:/n");
 for(int i=0;i<10;i++)
 {
  printf("%d ", rec[i].key);
 }
 return  0;
}

/*//进行一次归并，将两个有序表归并为一个有序表
void Merge(RecType *r,int low,int mid,int high)
{
 int i, j, k;
 RecType *tmp;
 i = low;
 j = mid+1;
 k = 0;
 tmp = (RecType *)malloc((high-low+1)*sizeof(RecType));
 while(i<=mid && j<=high)
 {
  if(r[i].key<=r[j].key)
  {
   tmp[k] = r[i];
   i++;
  }
  else
  {
   tmp[k] = r[j];
   j++;
  }
  k++;
 }
 if(i<=mid)
 {
  for(;i<=mid;i++)
  {
   tmp[k] = r[i];
   k++;
  }
 }
 if(j<=high)
 {
  for(;j<=high;j++)
  {
   tmp[k] = r[j];
   k++;
  }
 }
 for(i=low;i<=high;i++)
  r[i] = tmp[i-low];
 free(tmp);  
}
//将多个有序表中相邻两个表归并
void MergPass(RecType *r, int len, int n)
{
 int i;
 for(i=0;(i+2)*len-1<n;i=i+2)
  Merge(r, i*len, (i+1)*len-1, (i+2)*len-1);
 if((i+1)*len<n)
  Merge(r, i*len, (i+1)*len-1, n-1);
}
void MergeSort(RecType *r, int n)
{
 int len;
 for(len=1; len<n; len=2*len)
  MergPass(r, len, n);
}

//堆排序在这包含3个函数
//建立单元堆，且不影响其他元素的排序
void max_heapify(RecType *R, int i, int n)
{
 int l, r, largest;
 RecType tmp;
 l = LEFT(i);  //i的做孩子节点
 r = RIGHT(i);  //i的右孩子结点
 largest = i;   //后续语句进行的是当前节点与孩子结点的比较
 if(l<n && R[l].key>R[i].key)
  largest = l;
 if(r<n && R[r].key>R[largest].key)
  largest = r;
 if(largest!=i)
 {
  tmp = R[i];
  R[i] = R[largest];
  R[largest] = tmp;
  max_heapify(R, largest, n);
  //如果当前节点与孩子结点进行了交换，则会影响孩子结点的后续
  //结点，因此需继续比较孩子结点与孙子结点的关系，知道超范围
 }  
}
//建立整个大堆
void build_max_heap(RecType *R, int n)
{ //从A[n/2+1]到A[n]均为叶子结点，因此需要从A[n/2]开始
  //依次做单元堆排序，直到根节点结束。
 int i;
 for(i=n/2-1;i>=0;i--)
  max_heapify(R, i, n);
}
void HeapSort(RecType *R, int n)
{
 int i;
 RecType tmp;
 int heap_size = n;
 build_max_heap(R, n);
 for(i=n-1;i>=1;i--)
 {
  tmp = R[i];
  R[i] = R[0];
  R[0] = tmp;
  heap_size--;
  build_max_heap(R, heap_size);
 }
}
//课本答案上的直接选择排序算法
void SelectSort(RecType *r, int n)
{
 int i,j,k;
 RecType temp;
 for(i=0;i<n-1;i++)
 {
        k = i; 
  for(j=i+1;j<n;j++)  //在当前无序区r[i]~r[n-1]中找key最小的r[k]，放在有序区末端
   if(r[j].key<r[k].key)
    k = j;      //这种直接选择排序，不影响无序区的数列顺序
  if(k != i)
  {
   temp = r[i];
   r[i] = r[k];
   r[k] = temp;
  }
 }
}

//自己写的直接选择排序
void SelectSort(RecType *r, int n)
{
 RecType tmp;
 int i = 0, j = 0;
 while(i<n)   //这个其实就是个冒泡排序，不是真正的直接选择排序
 {
  for(j=n-1;j>i;j--)
   if(r[j].key<r[j-1].key)
   {
    tmp = r[j];
    r[j] = r[j-1];
    r[j-1] = tmp;
   }
  i++;
 }
}

//课本答案上的快速排序算法
void QuickSort(RecType *r,int s,int t)
{
 int i, j;
 RecType tmp;
 i = s, j = t;
 if(s<t)
 {
  tmp = r[i];
  while(i!=j)
  {
   while(r[j].key>tmp.key && j>i)
    j--;
   if(j > i)
   {
    r[i] = r[j];
    i++;
   }
   while(r[i].key<tmp.key && i<j)
    i++;   
   if(i < j)
   {
    r[j] = r[i];
    j--;
   }
  }
  r[i] = tmp;
  QuickSort(r, s, i-1);
  QuickSort(r, i+1, t);
 }
}

//课本答案上的冒泡排序算法
void BubbleSort(RecType *r,int n)
{
 int i,j,k;
 RecType temp;
 for(i=0;i<n-1;i++)
 {
  for(j=n-1;j>i;j--)
  {
   if(r[j].key<r[j-1].key)
   {
    temp = r[j];
    r[j] = r[j-1];
    r[j-1] = temp;
   }
  }
 }
}

//根据理解自己编写的冒泡排序算法,
void BubbleSort(RecType *r, int n)
{
 int i,j;
 RecType tmp;
 for(i=0;i<n-1;i++)
 {
  for(j=n-1;j>i;j--)
  {
   if(r[j].key<r[j-1].key)
   {
    tmp = r[j];
    r[j] = r[j-1];
    r[j-1] = tmp;
   }
  }
 }
}

//课本答案上的希尔排序算法
void ShellSort(RecType *r, int n)
{
 int i,j,d;
 RecType temp;
 d = n / 2;
 while(d>0)
 {
  for(i=d;i<n;i++)
  {
   j = i - d;
   while(j>=0 && r[j].key>r[j+d].key)
   {
    temp = r[j];
    r[j] = r[j+d];
    r[j+d] = temp;
    j = j - d;
   }
  }
  d = d / 2;
 }
}
//根据理解自己编写的希尔排序算法,
void ShellSort(RecType *r, int n)
{
 RecType tmp;
 int i,j,k,d;
 d = n / 2;
 while (d>0)
 {
  for(i=0;i<d;i++)
  {
   for(j=i+d;j<n;j+=d)
   {
    k = j - d;
    tmp = r[j];
    while(k>=0 && tmp.key<r[k].key)
    {
     r[k+d].key =  r[k].key;
     k -= d;
    }
    r[k+d] = tmp;
   }
  }
  d = d / 2;
 }
}

//课本答案上的直接插入式算法
void InsertSort(RecType *r, int n)
{
 int i,j,k;
 RecType temp;
 for(i=1;i<n;i++)
 {
  temp = r[i];
  j = i-1;
  while(j>=0 && temp.key<r[j].key)
  {
   r[j+1] = r[j];
   j--;
  }
  r[j+1] = temp;
 }
}
 //根据理解自己编写的直接插入式算法
void InsertSort(RecType *r, int n)
{
 int i,j;
 RecType tmp;
 for(i=1;i<n;i++)
 {
  if(r[i].key<r[i-1].key)
  {
   j = i;
   while(r[j].key<r[j-1].key && j>0)
   {
    tmp.key = r[j].key;
    r[j].key = r[j-1].key;
    r[j-1].key = tmp.key;
    j--;
   }
  }
 }
} 

*/