排序算法实现

#include <iostream>
#include <stdio.h>

using namespace std;

#define MAX 6
#define MAXLEN 100  //哨兵 
// 3 9 6 1 7 4
int a[MAX];
int b[MAX];

//0: print the array
void printArray(  )
{
    //打印数组
    for ( int i = 0; i< MAX; i++ )
    {
        cout << b[i] << ends;
    }
    cout << endl;
}

//1. 冒泡排序
void BubbleSortArray ( )
{
      for( int i = 1;i < MAX; i++ )
      {
        int flag = false;//交换标志
        for( int j = 0; j < MAX - i; j++ )
         {
              if( b[j] > b[j+1] )//比较交换相邻元素
               {
                   int temp;
                   temp = b[j];
                   b[j] = b[j+1];
                   b[j+1] = temp;
                   flag = true;
               }
         }
        if( !flag )
            break;
      }

	  //打印结果
	  cout << "冒泡排序后：" << endl;
	  printArray( );
}



//2. 选择排序
void SelectSortArray() 
{ 
    int min_index; 
    for( int i = 0; i< MAX-1; i++ ) 
    { 
         min_index = i; 
         for( int j = i+1; j < MAX; j++ )//每次扫描选择最小项 
            if( b[j] < b[min_index])  min_index=j; 
         if( min_index != i )//找到最小项交换，即将这一项移到列表中的正确位置 
         { 
             int temp; 
             temp = b[i];
			 b[i]= b[min_index];
			 b[min_index] = temp; 
         } 
    } 

	 //打印结果
	  cout << "选择排序后：" << endl;
	  printArray( );
} 



// 3. 插入排序
void InsertSortArray() 
{ 
   int n = MAX;
   //循环从第二个数组元素开始，因为arr[0]作为最初已排序部分 i，j分别为有序区和无序区指针
   for( int i = 1; i < n; i++ )
  { 
    int temp = b[i];//temp标记为未排序第一个元素 
    int j = i-1; 
    while ( j >= 0 && b[j] > temp )/*将temp与已排序元素从小到大比较，寻找temp应插入的位置*/ 
      { 
        b[j+1] = b[j]; 
         j--; 
      } 
     b[j+1] = temp; 
   } 


    //打印结果
	  cout << "插入排序后：" << endl;
	  printArray( );
} 


//4. 快速排序
int partition( int p, int r )
{  
    int x = b[r];  
    int i = p-1;  
    for( int j = p;j < r; j++ )
	{  
        if( b[j] < x )
		{  
            i++;  
            int temp = b[i];
			b[i] = b[j];
			b[j] = temp;  
        }  
    }  

    int temp1 = b[i+1];
	b[i+1] = b[r];
	b[r] = temp1;   

    return i+1;  
}  
  
void quick_sort( int p, int r )
{  
    if(p<r)
	{  
        int q=partition( p, r );  
        quick_sort( p, q-1 );  
        quick_sort( q+1, r );  
    }  
  	
}  



// 5.堆排序
template<class T>    
void Sift( T* heap, int start, int end )    //start和end标示无序区    
{    
    T temp = heap[start];   //记录    
    int parent = start;    
    int child = 2*start + 1;    
    while ( child <= end )    
    {    
        if( child < end && heap[child] < heap[child+1] )
		{
				child++; 
		}
        if( heap[child] > temp )    
        {    
            heap[parent] = heap[child];    
            parent = child;    
            child = 2*child + 1;    
            continue;    
        }    
        else    
            break;    
    }    
    heap[parent] = temp;    
}    
    
template <class T>    
void MakeHeap( T* heap, int Size )    
{    
    int end;    
//由于所有树叶无需进行下滤（没有孩子）， 所以只对0 - size/2的结点进行下滤即可  
    for( int start = Size/2-1; start>=0; start-- )  
	{
        Sift( heap, start, Size-1 );    
	}
}    
    
template <class T>    
void HeapSort( T* heap )    
{    
	int Size = MAX;
    MakeHeap( heap, Size );    
    T temp;    
    for (int i = Size-1;i >= 0;i--)    
    {    
        temp = heap[i];    
        heap[i] = heap[0];    
        heap[0] = temp;    
        Sift(heap,0,i-1);    
    }   

	// print sortResult
    for ( int i = 0; i < Size; i++ )    
    {    
        cout << heap[i] << ends;    
    }    
	cout << endl;
}    


/*
6. 合并排序：merge sort
  a.分解Divide：将n个元素分成各含n/2个元素的子序列
  b.解决Conquer：递归 用合并排序法对2个子序列递归的排序
  c.合并Combine:合并2个已排序的子序列以得到排序结果
*/


 
 void merge( int p, int q, int r )
 {
         int n1 = q-p+1;
         int n2 = r-q;
		 
         int L[MAX],R[MAX];
         for( int i = 0; i < n1; i++ )
             L[i] = b[p+i];
         for( int i = 0; i < n2; i++ )
             R[i] = b[q+i+1];
         L[n1] = MAXLEN;
         R[n2] = MAXLEN;
         int i = 0;
         int j = 0;
         for( int k = p; k <= r; k++ )
		 {
              if( L[i] <= R[j] )
			  {
                   b[k] = L[i];
                   i++;               
              }
			  else
			  {
                     b[k] = R[j];
                     j++;
              }
                      
         }
 } 
 
void merge_sort( int p, int r )
{
     if( p < r )
	 {
        int q = ( p + r)/2;
        merge_sort( p, q );
        merge_sort( q+1, r );
        merge( p, q, r );        
     }
}



//7. 希尔排序
/********************************************************
*函数名称：ShellInsert
*参数说明：b 无序数组；
*          d          增量大小
*		   MAX为无序数据个数
*说明：    希尔按增量d的插入排序
*********************************************************/
void ShellInsert( int d )
{
	for ( int i = d; i < MAX; i += 1 )    //从第2个数据开始插入
	{
		int j = i - d;
		int temp = b[i];    //记录要插入的数据
		while ( j >= 0 && b[j] > temp )    //从后向前，找到比其小的数的位置
		{
			b[j+d] = b[j];    //向后挪动
			j -= d;
		}

		if ( j != i - d )    //存在比其小的数
			b[j+d] = temp;
	}
}

/********************************************************
*函数名称：ShellSort
*参数说明：b 无序数组；
*		   MAX为无序数据个数
*说明：    希尔排序
*********************************************************/
void ShellSort( )
{
	int d = MAX / 2;    //初始增量设为数组长度的一半
	while( d >= 1 )
	{
		ShellInsert( d );
		d = d / 2;    //每次增量变为上次的二分之一
	}
}



/******************************************************** 
*函数名称：GetNumInPos 
*参数说明：num 一个整形数据 
*          pos 表示要获得的整形的第pos位数据 
*说明：    找到num的从低到高的第pos位的数据 
*********************************************************/  
int GetNumInPos( int num,int pos )  
{  
    int temp = 1;  
    for (int i = 0; i < pos - 1; i++)  
        temp *= 10;  
  
    return (num / temp) % 10;  
}  
  
/******************************************************** 
*函数名称：RadixSort 
*参数说明：b 无序数组； 
*          MAX为无序数据个数 
*说明：    基数排序 
*********************************************************/  
#define RADIX_10 10    //整形排序  
#define KEYNUM_31 10     //关键字个数，这里为整形位数  
void RadixSort()  
{  
    int *radixArrays[RADIX_10];    //分别为0~9的序列空间  
    for (int i = 0; i < 10; i++)  
    {  
        radixArrays[i] = (int *)malloc(sizeof(int) * ( MAX + 1 ));  
        radixArrays[i][0] = 0;    //index为0处记录这组数据的个数  
    }  
      
    for (int pos = 1; pos <= KEYNUM_31; pos++)    //从个位开始到31位  
    {  
        for (int i = 0; i < MAX; i++)    //分配过程  
        {  
            int num = GetNumInPos(b[i], pos);    

            int index = ++radixArrays[num][0];  
            radixArrays[num][index] = b[i];  
        }  
        for (int i = 0, j =0; i < RADIX_10; i++)    //收集  
        {  
            for (int k = 1; k <= radixArrays[i][0]; k++)  
                b[j++] = radixArrays[i][k];  
            radixArrays[i][0] = 0;    //复位  
        }  
    }  

	//打印结果
	              cout << "基数排序后：" << endl;
	              printArray( );
}  


int main()
{
    cout << "input Array a, size= " << ends << MAX <<endl;
    for( int i = 0; i < MAX; i++)
    {
        scanf( "%d", &a[i]);
    }

    while(1)
    {
        cout << " Please choose action ( digital: 0~8 ) " << endl;
        cout << " \t\t 0: 程序结束" << endl;
		cout << " \t\t 1: 冒泡排序" << endl;
	    cout << " \t\t 2: 选择排序" << endl;
		cout << " \t\t 3: 插入排序" << endl;
		cout << " \t\t 4: 快速排序" << endl;
		cout << " \t\t 5: 堆排序" << endl;
		cout << " \t\t 6: 合并排序" << endl;
		cout << " \t\t 7: 希尔排序" << endl;
		cout << " \t\t 8: 基数排序" << endl;
        int t;
        cin >> t;

		if ( t == 0 )
		{
			cout << "action ends! " << endl;
               break;
		}
	
		//每个操作是针对数组b进行排序的，保证每次输入都是首次的无序数组
		for ( int i = 0; i < MAX; i++ )
		{
			b[i] = a[i];
		}


        switch ( t )
        {

         case 1: BubbleSortArray(); break; //冒泡排序

         case 2: SelectSortArray(); break; //选择排序

		 case 3: InsertSortArray(); break; //插入排序

		 case 4:                           //快速排序
			 {
				 quick_sort( 0, MAX-1 ); 
				  //打印结果
	              cout << "快速排序后：" << endl;
	              printArray( );
				  break;
			 }

		 case 5: HeapSort<int>( b ); break; //插入排序

		 case 6:                           //合并排序
			 {
				 merge_sort( 0, MAX-1 ); 
				  //打印结果
	              cout << "合并排序后：" << endl;
	              printArray( );
				  break;
			 }

		 case 7:                           //希尔排序
			 {
				 ShellSort(  ); 
				  //打印结果
	              cout << "希尔排序后：" << endl;
	              printArray( );
				  break;
			 }

		 case 8: RadixSort(); break;

		 default: break;
        }

        
    }

    return 0;
}

参考： http://blog.csdn.net/cjf_iceking/article/details/7943609