排序算法

#include<stdio.h>
#include<malloc.h>
#define  SIZE  10
void printArray(int A[SIZE]);
void PopSort( int A[SIZE]);
void InsertSort( int A[SIZE] );
void ChooseSort( int A[SIZE] );
void ShellSort( int A[SIZE] );
void ShellSortPro(int A[SIZE],int add);
void Insertsort3(int A[], int n);
void MergeSort(int A[SIZE],int b,int e);
void Merge(int A[SIZE], int b,int m,int e);

void QuickSort(int A[SIZE],int left,int right);

void main()
{
 int A[10] = {0,1,6,3,9,5,6,7,8,4};
 int i = 1,j=1;
    ChooseSort(A);
 PopSort(A);
 InsertSort(A);
 ShellSort(A);
 MergeSort(A,0,9);
 printArray(A);
 
 
 
}
/************************************************************打印数组信息****************************************************/
void printArray(int A[SIZE])
{
 int counter;//计数器
 for( counter = 0; counter < SIZE ; counter++ )
 {
  printf("%d ",A[counter]);
 }
 printf("\n");
}

/****************************************冒泡排序算法*******************************************/
void PopSort( int A[SIZE])
{
 int ControlTimes=0;//控制外层循环次数
 int Current=0;//当前数字序号
 int flag = 0; //当一次没有任何交换也可让循环停止
 
    for(ControlTimes = 0; ControlTimes < SIZE-1; ControlTimes++)
 {
  for(Current = 0; Current < SIZE- ControlTimes -1;Current++)
  {
   if(A[Current]>A[Current+1])
   {
    A[Current]^=A[Current+1];
    A[Current+1]^=A[Current];
                A[Current]^=A[Current+1];
    flag += 1;
   }
  }
  if(flag==0) 
   break;
  else
   flag = 0;
 }
}

/*******************************************************插入排序算法***************************************************/

//插入排序思想:第2到n个元素分别作为key值,每个值作为key值之前，它前面的元素是有序的，只需要将key值插入到合适位置
void InsertSort( int A[SIZE] )
{
 
 int count = 0;//当前已经循环到的关键字序号
    int key = 0;//存当前关键字
 int compare = 0;//之前元素的迭代比较
 
 for( count = 1; count < SIZE ; count ++ )
 {
  
  key = A[count];
  compare = count-1;
  while(compare>=0)
  {
   if(key < compare)
   {
    A[compare]^=A[compare+1];
    A[compare+1]^=A[compare];
    A[compare]^=A[compare+1];
    compare--;
   }else
    break;
  }
  
  A[compare+1] = key;
  
 }
 
 
}

/******************************************************选择排序算法(不稳定)******************************************************/

//选择排序思想:每次选出最小元素按顺序与当前未排序的第一个元素交换。

void ChooseSort( int A[SIZE] )
{
 int min = 0; //最小值的序号
 int sorted = 0;//控制循环
 int iterator = 0;//遍历当前位之后的元素
 
 for( sorted = 0; sorted < SIZE-1 ; sorted++ )
 {
  min = sorted ;
  iterator = sorted;
  while(iterator < SIZE )
  {
   if(A[min]>A[iterator])
   {
    min = iterator; 
   }
   iterator++;
   
  }
  if(min != sorted )
  {
   A[min] = A[min] + A[sorted];
   A[sorted] = A[min] - A[sorted];
   A[min] = A[min] - A[sorted];
   
  }
  
 }
 
}

/**********************************************希尔排序算法********************************************************************/

//算法思想:据逆序数原理(排序后的逆序数为0),希尔排序是简单插入排序的变形,设有增量，每一组的相应位置进行插入排序

//              希尔排序的增量:增量大小可自定,但最后增量必须减小为1.两个比较好的建议:增量减少为原来2/3较好，增量不为倍数.d=d/3+1;

void ShellSort( int A[SIZE] )
{
 int dataAdd[] = {4,2,1};
    int i = 0;
 for( i = 0; i < 3; i++ )
  ShellSortPro(A,dataAdd[i]);
 
}

void  ShellSortPro(int A[SIZE],int add)
{
 int key = 0;//关键字
 int iterator;//遍历后面元素
 int count = 0; //控制循环
    int innerCount = 0;//内部处理排序
 for(count=0;count < add; count++)
 {
  for(innerCount = count ; innerCount < SIZE;innerCount+=add )
  {
   key = A[innerCount];
   iterator = innerCount - add;
   while(iterator>=0)
   {
    if(key < A[iterator])
    {
     A[iterator] = A[iterator] + A[iterator+add];
     A[iterator+add] = A[iterator] - A[iterator+add];
     A[iterator] = A[iterator] - A[iterator+add];
     iterator -= add;
    }else
     break;
   }
   A[iterator+add] = key;
  }
 }
 
}

 

 

/**************************************归并排序算法****************************************************************************/

归并排序思想:将序列分为两份，每份同样递归下去，之后对每份排好序的数进行合并

void MergeSort(int A[10], int p,int r)
{
 
 int q=(p+r)/2;
 if(p<r)
 {
  
  MergeSort(A,p,q);
  MergeSort(A,q+1,r);
 }
 
 Merge(A,p,q,r);
}

void Merge(int A[10],int p,int q, int r)
{
 int i= 0;
 int count = p;
 int count1 = 0;
 int count2 = 0;
 
 int Size1 = q-p+1;
 int Size2 = r - q ;
 int  B[50];
 int C[50];
 
 for(i=0; i < Size1; i++)
 {
  B[i] = A[i+p]; 
 }
 for( i = 0; i < Size2;i++)
 {
  
  C[i] = A[i+q+1];
 }
 
 
 while(count1 < Size1 && count2<Size2)
 {
  if(B[count1]<C[count2])
  {
   A[count] = B[count1];
   count++;
   count1++;
  }
  else
  {
   A[count] = C[count2];
   count++;
   count2++;
  }
 }
 
 
 while(count1 < Size1)
  
 {
  A[count] = B[count1];
  count++;
  count1++;
 }
 
 
 while(count2 <  Size2)
 {
  A[count] = C[count2];
  count++;
  count2++;
 }
 
 
 
}

 

 /****************************************************************快速排序******************************************************/

void quickSort(int Data[10],int left,int right)
{
 int Temp = Data[(left + right)>>1];
 int preLeft = left;
 int preRight = right;

 while(left < right)
 { while(Data[left] < Temp)
 {
      left++;
 }

 while(Data[right] > Temp)
 {

  right--;
 }
   int temp = Data[left];
   Data[left] = Data[right];
 Data[right] = temp;
 left++;
 right--;
 

 }
 if(preLeft < right) quickSort(Data,preLeft,right);
 if(preRight>left)  quickSort(Data,left,preRight);
}