各种排序算法C++源代码

//////////////////////////////////////////////////////////////////////////

/************************************************************************/
/*                            排序算法                                  */
/************************************************************************/

/*
* 函数功能：冒泡排序，传入一个对话框编辑框控件输入的数组
* 参数描述:
*/
void CAlgorithm::BubbleSort(int* SortArray,int array_size,int choice)
{
 int i,j;
 int temp;
 BOOL flag=TRUE;
 
 if ( 0 == choice ) //如果是升序，则升序冒泡
 {
  for ( i=1; i<array_size; ++i )
  {
   flag=FALSE;
   for ( j=0; j<array_size-i; ++j )
   {
    if ( SortArray[j] > SortArray[j+1] ) //每次比都将最大的向后放，这样就相当于泡往上冒
    {
     temp = SortArray[j];
     SortArray[j] = SortArray[j+1];
     SortArray[j+1] = temp;
     flag=TRUE;
    }
   }
   if (!flag) break; ////设置一个标志，倘若上一趟都没有交换，说明已经排好序，则下一趟不用比较,跳出循环。
  }
 }
 else //降序排序
 {
  for ( i=1; i<array_size; ++i )
  {
   flag=FALSE;
   for ( j=0; j<array_size-i; ++j )
   {
    if ( SortArray[j] < SortArray[j+1] ) //每次比都将最小的向后放，这样就相当于泡往上冒
    {
     temp = SortArray[j];
     SortArray[j] = SortArray[j+1];
     SortArray[j+1] = temp;
     flag=TRUE;
    }
   }
   if (!flag) break;
  }
 }
}

/*
* 函数功能：简单选择排序算法，算法思想，找出最小的放在数组的最低位或最高位，依次类推
* 参数描述：
*/
void CAlgorithm::SelectSort(int* SortArray,int array_size,int choice)
{
 int i,j,k;
 int temp;
 
 if ( 0 == choice ) //升序
 {
  for ( i =0; i<array_size-1; ++i )
  {
   k=i;
   for ( j=i+1; j<array_size; ++j ) //找出最小的元素
   {
    if ( SortArray[j] < SortArray[k] ) //k为一个游动的下标，指向本次搜索的最小数的下标
    {
     k=j;
    }
   }
   if ( k != i) //倘若i不是最小的，则与最小的换过来
   {
    temp=SortArray[k];
    SortArray[k]=SortArray[i];
    SortArray[i]=temp;
   }
  }
 }
 else //降序
 {
  for ( i =0; i<array_size-1; ++i )
  {
   k=i;
   for ( j=i+1; j<array_size; ++j ) //找出最大的元素
   {
    if ( SortArray[j] > SortArray[k] )
    {
     k=j;
    }
   }
   if ( k != i)
   {
    temp=SortArray[k];
    SortArray[k]=SortArray[i];
    SortArray[i]=temp;
   }
  }
 }
}

/*
* 函数功能：插入排序，将后面的数插入到前面已经排好序的组中
* 参数描述：
*/
void CAlgorithm::InsertSort(int* SortArray,int array_size,int choice)
{
 int i,j;
 int x;
 if ( 0 == choice ) //升序
 {
  for ( i=1; i<array_size; ++i)
  {
   x=SortArray[i]; //当前要往前面已经排好序的数组中插得数
   j=i-1;
   while ( j>=0 && SortArray[j]>x ) //将要插入的数从以排好序的数组的后边往前边挨个比较
   {
    SortArray[j+1]=SortArray[j];
    --j;
   }
   SortArray[j+1]=x; //找到了合适的位置，则插入 
  }
 }
 else //降序
 {
  for ( i=1; i<array_size; ++i)
  {
   x=SortArray[i]; //当前要往前面已经排好序的数组中插得数
   j=i-1;
   while ( j>=0 && SortArray[j]<x ) //将要插入的数从以排好序的数组的后边往前边挨个比较
   {
    SortArray[j+1]=SortArray[j];
    --j;
   }
   SortArray[j+1]=x; //找到了合适的位置，则插入 
  }
 }
}

/*
* 函数功能：希尔排序，分组的插入排序，它的主要优点是，当最后的分组较少后，由于数组已经趋于排好序，在组里面的插入排序就比较快了
* 参数描述：
*/
void CAlgorithm::ShellSort(int* SortArray,int array_size,int choice)
{
 int i,j;
 int d;
 int x; //用于存储分组中要插入的数
 
 d=array_size/2;
 
 if ( 0 == choice) //升序
 {
  while (d>=1)  //先分组
  {
   for ( i=d; i<array_size; ++i) //在分组里面直接插入排序
   {
    j=i-d;
    x=SortArray[i];
    
    while ( j>=0 && SortArray[j] > x)
    {
     SortArray[j+d]=SortArray[j];
     j=j-d;
    }
    SortArray[j+d]=x;
   }
   d=d/2;
  }
 }
 else //降序
 {
  while (d>=1)
  {
   for ( i=d; i<array_size; ++i)
   {
    j=i-d;
    x=SortArray[i];
    
    while ( j>=0 && SortArray[j] < x)
    {
     SortArray[j+d]=SortArray[j];
     j=j-d;
    }
    SortArray[j+d]=x;
   }
   d=d/2;
  }
 }
}

/*
* 函数功能：将数组分成两部分
* 参数描述：
*/
int CAlgorithm::Separator(int* SearchArray, int i, int j, int choice)
{
 int temp;
 
 if ( 0 == choice ) //升序
 {
  temp=SearchArray[i]; //作为分割元素
  
  while ( i<j )
  {
   while (i<j&&SearchArray[j]>temp) j--; //从后面往前扫描，找到第一个比分割元素小的，换到前面
   
   if (i<j) SearchArray[i++]=SearchArray[j];

   while (i<j&&SearchArray[i]<temp) i++;

   if (i<j) SearchArray[j--]=SearchArray[i]; //从前面开始扫描，找到第一个比分割元素大的，换到后面
  }
  
  SearchArray[i]=temp;
 }
 else //降序
 {
  temp=SearchArray[i]; //作为分割元素
  
  while ( i<j )
  {
   while (i<j&&SearchArray[j]<temp) j--; //从后面往前扫描，找到第一个比分割元素大的，换到前面
   
   if (i<j) SearchArray[i++]=SearchArray[j];
   
   while (i<j&&SearchArray[i]>temp) i++;
   
   if (i<j) SearchArray[j--]=SearchArray[i]; //从前面开始扫描，找到第一个比分割元素小的，换到后面
  }
  
  SearchArray[i]=temp;
 }
 return i;
}

/*
* 函数功能：快速排序
* 参数描述：
*/
void CAlgorithm::QuiklySort(int* SortArray,int l,int h,int choice)
{
 int i,j;
 int splitpoint;
 
 i=l;
 j=h;
 
 if ( i<j )
 {
  splitpoint=Separator(SortArray,i,j,choice);
  QuiklySort(SortArray,i,splitpoint-1,choice);
  QuiklySort(SortArray,splitpoint+1,j,choice);
 }
}

/*
* 函数功能：获得节点的左孩子
*
*/
int CAlgorithm::LEFT(int i)
{
 return 2*i+1; //根节点从0开始
}

/*
* 函数功能：获得节点的右孩子
* 参数描述：
*/
int CAlgorithm::RIGHT(int i)
{
 return 2*(i+1);
}

/*
* 函数功能：重建为堆
* 参数描述：i,要重建的堆的根节点
*/
void CAlgorithm::HEAPIFY(int* SortArray,int heap_size,int i,int choice)
{
 int isfound,left,right;
 int temp;

 isfound=i;
 left=LEFT(i);
 right=RIGHT(i);

 if ( 0 == choice ) //重建最大堆
 {
  if ( left<= heap_size-1 && SortArray[left] > SortArray[isfound] ) //节点是否为堆中的节点
  {
   isfound=left; //倘若大于其父节点，置其为最大节点
  }
  if ( right<= heap_size-1 && SortArray[right] > SortArray[isfound] )
  {
   isfound=right; //倘若大于其父节点，置其为最大节点
  }
 }
 else //重建最小堆
 {
  if ( left<= heap_size-1 && SortArray[left] < SortArray[isfound] )
  {
   isfound=left; //倘若小于其父节点，置其为最小节点
  }
  if ( right<= heap_size-1 && SortArray[right] < SortArray[isfound] )
  {
   isfound=right; //倘若小于其父节点，置其为最小节点
  }
 }

 if ( isfound!=i) //倘若i不是最大或者最小的节点，将其与最小的交换
 {
  temp = SortArray[isfound];
  SortArray[isfound]=SortArray[i];
  SortArray[i] = temp;
  HEAPIFY(SortArray,heap_size,isfound,choice); //递归处理子树
 }
}

/*
* 函数功能：初始化数组为堆
* 参数描述：
*/
void CAlgorithm::BUILD_HEAP(int* SortArray,int heap_size,int choice)
{
 int i;
 for ( i=(heap_size-1)/2; i>=0; --i )
 {
  HEAPIFY(SortArray,heap_size,i,choice); //从有孩子的节点开始创建堆
 }
}

/*
* 函数功能：堆排序
* 参数描述：
*/
void CAlgorithm::HeapSort(int* SortArray,int heap_size,int choice)
{
 int i;
 int temp;

 BUILD_HEAP(SortArray,heap_size,choice); //首先将原数组创建成堆

 for ( i=heap_size-1; i>=1; --i ) //将根节点(此时为最大的)与最后一个元素交换
 {
  temp=SortArray[i];
  SortArray[i]=SortArray[0];
  SortArray[0]=temp;             //由于交换后，SortArray[0,...,i-1]可能违背了堆的性质
  HEAPIFY(SortArray,i,0,choice); //故将SortArray[0,...,i-1]重置为堆
 }
}

 

void Merge(int array[], int p, int q, int r)

{

　　int i,k;

　　int begin1,end1,begin2,end2;

　　int* temp = (int*)malloc((r-p+1)*sizeof(int));

　　begin1= p;

　　end1 = q;

　　begin2 = q+1;

　　end2 = r;

　　k = 0;

　　while((begin1 <= end1)&&( begin2 <= end2))

　　{

　　if(array[begin1] < array[begin2])

　　{ temp[k] = array[begin1];

　　begin1++;

　　}

　　else

　　{

　　temp[k] = array[begin2];

　　begin2++;

　　}

　　k++;

　　}

　　while(begin1<=end1)

　　{

　　temp[k++] = array[begin1++];

　　}

　　while(begin2<=end2)

　　{

　　temp[k++] = array[begin2++];

　　}

　　for (i = 0; i < (r - p + 1); i++)

　　array[p+i] = temp[i];

　　free(temp);

}

 

/*
* 函数功能：归并排序
* 参数描述：
*/

void MergeSort(int array[], int first, int last)

{

　　int mid = 0;

　　if(first<last)

　　{

　　mid = (first+last)/2;

　　MergeSort(array, first, mid);

　　MergeSort(array, mid+1,last);

　　Merge(array,first,mid,last);

　　}

}  

　　　
/*
* 函数功能：求元素的最大位
* 参数描述：
*/
int CAlgorithm::MAX_BIT(int* SortArray,int array_size)
{
 int bits=0;
 int p;
 int* tmp = new int[array_size];

 for ( int i=0; i<array_size; ++i) //将数组的值赋给临时数组
 {
  tmp[i]=SortArray[i];
 }

 for ( int j=0; j<array_size; ++j) //计算每一个元素的位数
 {
  p=0;
  while (tmp[j]/10>0) //开始计算位数
  {
   p++;
   tmp[j]=tmp[j]/10;
  }
  if (p+1>bits) bits=p+1; //将最大的位数赋给bits，用于返回
 }
 return bits;

}

/*
* 函数功能：基数排序
* 参数描述：
*/
void CAlgorithm::RadixSort(int* SortArray,int array_size,int choice)
{
 int i,j,k;
 int radix=1; //基数，从1开始

 int max_bits=MAX_BIT(SortArray,array_size);
 int* tmp=new int[array_size];
 int* count=new int[10]; //一共10个桶，用于存放每个桶中有几个元素

 if ( 0 == choice ) //升序
 {
  for ( i=0; i<max_bits; ++i) //进行max_bits趟排序
  {
   j=0;
   while (j<10) count[j++]=0; //每次排序前，都将桶中元素清空
   
   for ( j=0; j<array_size; ++j) //统计每个桶中存放的元素个数
   {
    k=(SortArray[j]/radix)%10; //个位数为k的存放到第k个桶中
    count[k]++;
   }
   
   for ( j=1; j<10; ++j)
   {
    count[j]=count[j-1]+count[j]; //从第1个桶开始，依次将tmp中的位置分配给每个桶
   }
   
   for ( j=array_size-1; j>=0; --j) //将桶中数据依次收集到tmp中
   {
    k=(SortArray[j]/radix)%10;
    tmp[--count[k]]=SortArray[j];
   }
   
   for ( j=0; j<array_size; ++j) SortArray[j]=tmp[j]; //将临时数组中的元素复制回SortArray数组中
   
   radix=radix*10; //下一趟排序基数，实际上为从个位，十位，百位等这样排下来排序的
  }
 }
 else //降序
 {
  for ( i=0; i<max_bits; ++i) //进行max_bits趟排序
  {
   j=0;
   while (j<10) count[j++]=0; //每次排序前，都将桶中元素清空
   
   for ( j=0; j<array_size; ++j) //统计每个桶中存放的元素个数
   {
    k=(SortArray[j]/radix)%10; //个位数为k的存放到第k个桶中
    count[k]++;
   }
   
   for ( j=9; j>=1; --j)
   {
    count[j-1]=count[j]+count[j-1]; //从第9个桶开始，依次将tmp中的位置分配给每个桶
   }
   
   for ( j=array_size-1; j>=0; --j) //将桶中数据依次收集到tmp中
   {
    k=(SortArray[j]/radix)%10;
    tmp[--count[k]]=SortArray[j];
   }
   
   for ( j=0; j<array_size; ++j) SortArray[j]=tmp[j]; //将临时数组中的元素复制回SortArray数组中
   
   radix=radix*10; //下一趟排序基数，实际上为从个位，十位，百位等这样排下来排序的
  }
 }
}