七种基本排序实现源码

1.【插入排序】

void InsertSort(int* p ,int size)
{
	for(int i=1;i<size;i++)
	{
		int j	=	i;
		int t	= p[i];
		for(; j > 0 && p[j-1] > t; j--)
			p[j] = p[j-1];
		p[j] = t;
	}	
}

2.【选择排序】

void SelectSort(int* arr,int size)
{
	for(int i=0;i<size;i++)
	{
		int psn=i;
		for(int j=i;j<size;j++)
		{
			if(arr[j]<arr[psn])
				psn = j;
		}	
		swap(arr[psn],arr[i]);
	}	
}

3.【冒泡排序】

void BubbleSort(int* arr,int size)
{
	bool cg = true;		
	int  n	= 0;
	do
	{
		cg = false;	
		for (int i=0;i<size-1-n;i++)
		{
			if (arr[i]>arr[i+1])
			{
				cg = true;
				swap(arr[i],arr[i+1]);		
			}
		}	
		n++;
	} while (cg);
}

4.【快速排序】

void QuickSort(int* arr,int size)
{
    int *L,*R;
    if(size <= 1) return;
    if(2 == size)
    {
       if(arr[0] > arr[1])
         swap(arr[0],arr[1]);
       return;
    } 
    L = &arr[1];
    R = &arr[size -1];
    while(L < R)
   {
      while(L<R && *L < *arr) ++L;
      while(R>arr && !(*R < *arr)) --R;
     if(L<R) swap(*R,*L);
   }
   swap(*R,*arr);
   QuickSort(arr, R-arr);
   QuickSort(R+1,size -1 -(R-arr));
}

5.【堆排序】

void Shift(int* heap, int start, int end)
{
       int tmp = heap[start]; 
       int parent = start;
       int child = parent * 2 + 1; 
       while(child <= end)
     {
       if(child < end && 
	         heap[child] < heap[child+1])
                child++;

         if(tmp < heap[child])
        {
             heap[parent] = heap[child];
             parent = child;
             child = 2 * parent +1;
        } else  break;
     }
    heap[parent] = tmp;
}

void BuildHeap(int* heap,int size)
{
      for(int i=size/2-1; i >=0; i--)
         Shift(heap,i,size-1);

}

void HeapSort(int* heap,int size)
{
    BuildHeap(heap,size);
    for(int i = size-1; i>0; i--)
    {
          swap(heap[0],heap[i]);
          Shift(heap,0,i-1);
    }
}

6.【归并排序】

void Merge(int* arr,int first,int mid,int last)
{
     int size = last -first + 1;
     int* tmp = new int[size];
     int   b1 = first;
     int   e1 = mid;
     int   b2 = mid + 1;
     int   e2 = last;
     int    k = 0;
     while(b1<=e1 && b2<=e2)
       if(arr[b1]<arr[b2])
          tmp[k++] = arr[b1++];
       else tmp[k++] = arr[b2++];
    
     while(b1<=e1)   tmp[k++]=arr[b1++];
     while(b2<=e2)   tmp[k++]=arr[b2++];
     for(int i=0; i<size; i++)
        arr[first + i] = tmp[i];
     delete tmp;   
}

void MergeSort(int* arr,int first,int last)
{
    if(first < last)
    {
       int  mid = (first +last) / 2;
       MergeSort(arr,first,mid);
       MergeSort(arr,mid+1,last);
       Merge(arr,first,mid,last);
    }
}

7.【希尔排序】

void ShellSort(int *p, int size)
{
   int iTemp;
   for( int iStep = size/2; iStep > 0; iStep = iStep/2 ) {
     for( int i = iStep; i < size; ++i ) {
	iTemp = p[i];
	int j = i;
	for( ; j >= iStep; j -= iStep ) {   
	  if( iTemp < p[j-iStep] ) {
	    p[j] = p[j-iStep];
	  } else {
            break;
          }
	}
	p[j] = iTemp;
      }
    }
}

【代码测试】

#include<iostream>
#include<string>
using namespace std;

typedef void(*SortFunc)(int*, int, int*, int*);

// 插入排序
void InsertSort(int* p ,int size, int* move_cnt, int* compare_cnt)  
{  
    for(int i=1;i<size;i++)  
    {  
        int j   =   i;  
        int t   = p[i]; 
        ++*move_cnt; 
        ++*compare_cnt;
        for(; j > 0 && p[j-1] > t; j--) { 
            ++*compare_cnt;
            p[j] = p[j-1];  
            ++*move_cnt; 
        }
        p[j] = t;  
        ++*move_cnt; 
    }     
}  

// 希尔排序
void ShellSort(int *p, int size, int* move_cnt, int* compare_cnt)
{
	int iTemp;

	for( int iStep = size/2; iStep > 0; iStep = iStep/2 )
	{
		for( int i = iStep; i < size; ++i )
		{
             
			iTemp = p[i];
            ++*move_cnt;
			int j = i;
			for( ; j >= iStep; j -= iStep )
			{   
                ++*compare_cnt;
				if( iTemp < p[j-iStep] )
				{
					p[j] = p[j-iStep];
					++*move_cnt;
				}
				else
				{
					break;
				}
			}
			p[j] = iTemp;
			++*move_cnt;
		}
	}
}

// 冒泡排序
void BubbleSort(int* arr,int size, int* move_cnt, int* compare_cnt)  
{  
    bool cg = true;       
    int  n  = 0;  
    do  
    {  
        cg = false;   
        for (int i=0;i<size-1-n;i++)  
        {   
            ++*compare_cnt;
            if (arr[i]>arr[i+1])  
            {  
                cg = true;  
                swap(arr[i],arr[i+1]);     
                *move_cnt += 3;   
            }  
        }     
        n++;  
    } while (cg);  
}  

// 快速排序
void QuickSort(int* arr,int size, int* move_cnt, int* compare_cnt)  
{  
    int *L,*R;  
    if(size <= 1) return;  
    if(2 == size)  
    {  
       ++*compare_cnt;
       if(arr[0] > arr[1]) { 
         swap(arr[0],arr[1]);
         *move_cnt += 3; 
       }  
       return;  
    }   
    L = &arr[1];  
    R = &arr[size -1];  
    while(L < R)  
   {  
      ++*compare_cnt;
      while(L<R && *L < *arr) {
        ++*compare_cnt;
        ++L;
      }  
      ++*compare_cnt;
      while(R>arr && !(*R < *arr)) {
         ++*compare_cnt;
         --R; 
      } 
     ++*compare_cnt;
     if(L<R){
       swap(*R,*L);
       *move_cnt += 3; 
     }  
   }  
   swap(*R,*arr);  
   *move_cnt += 3; 
   QuickSort(arr, R-arr, move_cnt, compare_cnt);  
   QuickSort(R+1,size -1 -(R-arr), move_cnt, compare_cnt);  
}  

// 简单选择排序
void SelectSort(int* arr,int size, int* move_cnt, int* compare_cnt)  
{  
    for(int i=0;i<size;i++)  
    {  
        int psn=i;  
        for(int j=i;j<size;j++)  
        {    
            ++*compare_cnt;
            if(arr[j]<arr[psn]) {  
               psn = j;  
            }
        }     
        swap(arr[psn],arr[i]);  
        *move_cnt += 3; 
    }     
}  

void Shift(int* heap, int start, int end, int* move_cnt, int* compare_cnt)  
{  
       int tmp = heap[start];   
       ++*move_cnt;
       int parent = start;  
       int child = parent * 2 + 1;   
       while(child <= end)  
     {  
       ++*compare_cnt;
       if(child < end && heap[child] < heap[child+1]) { 
         ++child;  
       }
       ++*compare_cnt;
       if(tmp < heap[child])  
       {  
             heap[parent] = heap[child];  
             ++*move_cnt;
             parent = child;  
             child = 2 * parent +1;  
       } else  break;  
     }  
    heap[parent] = tmp;  
    ++*move_cnt;
}  
  
void BuildHeap(int* heap,int size, int* move_cnt, int* compare_cnt)  
{  
      for(int i=size/2-1; i >=0; i--)  
         Shift(heap,i,size-1, move_cnt, compare_cnt);  
  
}  
  
void HeapSort(int* heap, int size, int* move_cnt, int* compare_cnt)  
{  
    BuildHeap(heap, size, move_cnt, compare_cnt);  
    for(int i = size-1; i>0; i--)  
    {  
          swap(heap[0],heap[i]);  
          Shift(heap,0,i-1, move_cnt, compare_cnt);  
    }  
}  

void Merge(int* arr,int first,int mid,int last, int* move_cnt, int* compare_cnt)  
{  
     int size = last -first + 1;  
     int* tmp = new int[size];  
     int   b1 = first;  
     int   e1 = mid;  
     int   b2 = mid + 1;  
     int   e2 = last;  
     int    k = 0;  

     while(b1<=e1 && b2<=e2) { 
       ++*compare_cnt;
       if(arr[b1]<arr[b2])  
          tmp[k++] = arr[b1++];  
       else tmp[k++] = arr[b2++];  
       ++*move_cnt;
     }
     while(b1<=e1) {  
       tmp[k++]=arr[b1++];
       ++*move_cnt;  
       ++*compare_cnt;
     }
     while(b2<=e2) { 
       tmp[k++]=arr[b2++];
       ++*move_cnt;
       ++*compare_cnt;
     }  
     for(int i=0; i<size; i++)  { 
        arr[first + i] = tmp[i]; 
        ++*move_cnt;
     } 
     delete tmp;     
}  
  
void MergeSort(int* arr,int size, int* move_cnt, int* compare_cnt)  
{  
    if(size > 1)  
    {  
       int  mid = size / 2;  
       MergeSort(arr, mid, move_cnt, compare_cnt);  
       MergeSort(arr + mid, size - mid, move_cnt, compare_cnt);
       Merge(arr, 0, mid - 1, size -1, move_cnt, compare_cnt);  
    }  
}  

// 输出数组
void ShowArray(int * p, int size)
{
	for(int i = 0; i < size; i++)
	{
		cout<< p[i];
		if(i < size-1)
		{
			cout<< ", ";
		}
	}
	cout<< endl;
}

void CopyToTmp(int* arr, int* temp, int length) {
   	for( int i = 0; i < length; ++i )
	{
		temp[i] = arr[i];
		
	} 
}

int main()
{
	int arr[4][20] = { {-20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100},
	               	   {100, 99, 96, 93,89, 87, 82, 79, 75, 65, 62, 51, 41, 24, 18, 10, 0, -10, -15, -20},
		               {99, 75, -10, 87, 41,100, 89, 65, 18, 93, 0, 51, 62, 10, -20, 82, 24, 96, -15, 79},
	                   {0} };
    const string arr_name[3] = {"顺序的数组" ,"逆序的数组", "随机的数组"};
    
    SortFunc sort_functions[7] = {InsertSort, SelectSort, BubbleSort, QuickSort, ShellSort, HeapSort, MergeSort };
    const string sort_func_name[7] = {"插入排序", "选择排序", "冒泡排序", "快速排序", "希尔排序", "堆排序", "归并排序" };
    int compare_cnt = 0, move_cnt = 0;
    cout <<  "========================================================" << endl;
    for (int i = 0; i < 7; ++i) {
        cout << "         **** " << sort_func_name[i] << " ****" << "       测试结果如下：" << endl ;
        cout <<  "========================================================" << endl;
      for (int j = 0; j < 3; ++j) {
          compare_cnt = 0;
          move_cnt = 0;
          CopyToTmp(arr[j], arr[3], 20);
          cout << endl << arr_name[j] << "："; 
          ShowArray(arr[3], 20);
          sort_functions[i](arr[3], 20, &move_cnt, &compare_cnt);
          cout << sort_func_name[i] << "后: " ; 
          ShowArray(arr[3], 20);
          cout << sort_func_name[i] << "对" << arr_name[j] << "排序,共进行 " << compare_cnt << " 次比较 和 " << move_cnt << " 次移动" << endl; 
      }    
    cout << endl << "========================================================" << endl;
    } 
	system("pause");
	return 0;
}

【测试结果】

========================================================
         **** 插入排序 ****       测试结果如下：
========================================================


顺序的数组：-20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
插入排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
插入排序对顺序的数组排序,共进行 19 次比较 和 38 次移动


逆序的数组：100, 99, 96, 93, 89, 87, 82, 79, 75, 65, 62, 51, 41, 24, 18, 10, 0, -10, -15, -20
插入排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
插入排序对逆序的数组排序,共进行 209 次比较 和 228 次移动


随机的数组：99, 75, -10, 87, 41, 100, 89, 65, 18, 93, 0, 51, 62, 10, -20, 82, 24, 96, -15, 79
插入排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
插入排序对随机的数组排序,共进行 132 次比较 和 151 次移动


========================================================
         **** 选择排序 ****       测试结果如下：
========================================================


顺序的数组：-20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
选择排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
选择排序对顺序的数组排序,共进行 210 次比较 和 60 次移动


逆序的数组：100, 99, 96, 93, 89, 87, 82, 79, 75, 65, 62, 51, 41, 24, 18, 10, 0, -10, -15, -20
选择排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
选择排序对逆序的数组排序,共进行 210 次比较 和 60 次移动


随机的数组：99, 75, -10, 87, 41, 100, 89, 65, 18, 93, 0, 51, 62, 10, -20, 82, 24, 96, -15, 79
选择排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
选择排序对随机的数组排序,共进行 210 次比较 和 60 次移动


========================================================
         **** 冒泡排序 ****       测试结果如下：
========================================================


顺序的数组：-20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
冒泡排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
冒泡排序对顺序的数组排序,共进行 19 次比较 和 0 次移动


逆序的数组：100, 99, 96, 93, 89, 87, 82, 79, 75, 65, 62, 51, 41, 24, 18, 10, 0, -10, -15, -20
冒泡排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
冒泡排序对逆序的数组排序,共进行 190 次比较 和 570 次移动


随机的数组：99, 75, -10, 87, 41, 100, 89, 65, 18, 93, 0, 51, 62, 10, -20, 82, 24, 96, -15, 79
冒泡排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
冒泡排序对随机的数组排序,共进行 189 次比较 和 339 次移动


========================================================
         **** 快速排序 ****       测试结果如下：
========================================================


顺序的数组：-20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
快速排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
快速排序对顺序的数组排序,共进行 244 次比较 和 54 次移动


逆序的数组：100, 99, 96, 93, 89, 87, 82, 79, 75, 65, 62, 51, 41, 24, 18, 10, 0, -10, -15, -20
快速排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
快速排序对逆序的数组排序,共进行 235 次比较 和 57 次移动


随机的数组：99, 75, -10, 87, 41, 100, 89, 65, 18, 93, 0, 51, 62, 10, -20, 82, 24, 96, -15, 79
快速排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
快速排序对随机的数组排序,共进行 140 次比较 和 54 次移动


========================================================
         **** 希尔排序 ****       测试结果如下：
========================================================


顺序的数组：-20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
希尔排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
希尔排序对顺序的数组排序,共进行 62 次比较 和 124 次移动


逆序的数组：100, 99, 96, 93, 89, 87, 82, 79, 75, 65, 62, 51, 41, 24, 18, 10, 0, -10, -15, -20
希尔排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
希尔排序对逆序的数组排序,共进行 80 次比较 和 160 次移动


随机的数组：99, 75, -10, 87, 41, 100, 89, 65, 18, 93, 0, 51, 62, 10, -20, 82, 24, 96, -15, 79
希尔排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
希尔排序对随机的数组排序,共进行 88 次比较 和 163 次移动


========================================================
         **** 堆排序 ****       测试结果如下：
========================================================


顺序的数组：-20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
堆排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
堆排序对顺序的数组排序,共进行 126 次比较 和 119 次移动


逆序的数组：100, 99, 96, 93, 89, 87, 82, 79, 75, 65, 62, 51, 41, 24, 18, 10, 0, -10, -15, -20
堆排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
堆排序对逆序的数组排序,共进行 108 次比较 和 101 次移动


随机的数组：99, 75, -10, 87, 41, 100, 89, 65, 18, 93, 0, 51, 62, 10, -20, 82, 24, 96, -15, 79
堆排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
堆排序对随机的数组排序,共进行 118 次比较 和 108 次移动


========================================================
         **** 归并排序 ****       测试结果如下：
========================================================


顺序的数组：-20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
归并排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
归并排序对顺序的数组排序,共进行 88 次比较 和 176 次移动


逆序的数组：100, 99, 96, 93, 89, 87, 82, 79, 75, 65, 62, 51, 41, 24, 18, 10, 0, -10, -15, -20
归并排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
归并排序对逆序的数组排序,共进行 88 次比较 和 176 次移动


随机的数组：99, 75, -10, 87, 41, 100, 89, 65, 18, 93, 0, 51, 62, 10, -20, 82, 24, 96, -15, 79
归并排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100
归并排序对随机的数组排序,共进行 88 次比较 和 176 次移动

            原创文章，转载请注明： 转载自 IIcyZhao’s Road

          本文链接地址：http://blog.csdn.net/iicy266/article/details/11905851