各种常用的排序算法实现对数组的排序——整理总结（代码实现）

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/zm1_1zm/article/details/75047303

冒泡排序、插入排序、折半排序（二分插入排序）、快速排序、选择排序、归并排序、希尔排序、堆排序

#include <stdio.h> 
#include <algorithm>
#include <iostream>
using namespace std;
//冒泡排序 
void bubble_sort(int a[],int n) 
{ 
 int i,j; 
 for(i = 0;i < n-1; i++) 
 { 
  bool exchange = false; 
  for(j = n-1;j > i; j--) 
  { 
   if(a[j-1] > a[j]) 
   { 
    exchange = true; 
    swap(a[j-1], a[j]); 
   } 
  }  
  if(exchange == false) 
   break; 
 } 
} 

//直接插入排序
void insert_sort(int a[],int n) 
{ 
 int i,j; 
 for(i = 1;i < n; i++) 
 { 
  int t = a[i]; 
  for(j = i; j > 0 && a[j-1] > t; j--) 
   a[j] = a[j-1]; 
  a[j] = t; 
 } 
} 

//折半排序、二分插入排序 
	//实现1 
void Insert_sort(int *pArr, int len) {  // 定义二分法插入排序的函数
    int temp, low, up;    // temp用于存放插入值， low表示下界， up表示上界
    for (int i = 1; i < len; i++) {
        temp = pArr[i];    // 保存插入值
        low = 0;   // 下界肯定为0
        up = i - 1;   // 上界就是除去插入值剩余元素的最大下标
        while (low <= up) {  // 当up移动到low左侧时，结束循环。注意，此处一定要带有等号，否则排序会失败，可以举例说明
            if (temp > pArr[(low+up)/2])
                low = (low + up)/2 + 1;  // 当插入值大于中间值，将下界移动到中界＋1的位置
            else
                up = (low + up)/2 - 1; // 当插入值小于中间值，将上界移动到下界－1的位置
        } // 对low和up处理使得在决定好插入位置后up在low之前以跳出循环
        for (int j = i-1; j >= low; j--)   //  该循环起到将元素后移的作用
            pArr[j+1] = pArr[j];
        pArr[low] = temp;   // 将插入值插入
    }
    return;
}
void InsertSort_find(int X, int *pArr, int low, int up) {
    if (up < low){
        printf("Can't find X\n");
        return;
    }
    int mid = (up + low)/2;
    if (X == pArr[mid]) { 
        printf("The index is %d\n", mid);   
        return;
    } else if (X < pArr[mid]) {
        InsertSort_find(X, pArr, low, mid-1); 
    } else { 
        InsertSort_find(X, pArr, mid+1, up); 
    }
} 

	//实现2
void BinaryInsertSort(int *a, int n)     
{  
    int i,j,k,low,high,m;  
    for(i = 1; i < n; i++) {  
        low = 0;  
        high = i - 1;  
  
        while(low <= high) {  
            m = (low + high) / 2;  
            if(a[m] > a[i]) high = m - 1;  
            else low = m + 1;  
        }  
  
        if(j != i - 1) {  
            int temp = a[i];  
            for(k = i - 1; k >= high + 1; k--)  
                a[k + 1] = a[k];  
            a[k + 1] = temp;  
        }  
    }  
}   

//快速排序
void quick_sort(int a[],int l,int r) 
{ 
 if(l >= r) 
  return; 
 int i,j,p; 
 i = l-1, j = r; 
  
 p = l + rand()%(r-l); 
 swap(a[p],a[r]); 
 p = a[r]; 
 while(1) 
 { 
  do { i++; } while(a[i] < p && i < r); 
  do { j--; } while(a[j] > p && j > l); 
  if(i >= j) 
   break; 
  swap(a[i], a[j]); 
 } 
 swap(a[i], a[r]); 
 quick_sort(a, l, i-1); 
 quick_sort(a, i+1, r); 
} 

//选择排序
void select_sort(int a[],int n) 
{ 
	int i,j; 
	for(i = 0; i < n-1; i++) 
	{ 
	  	int min = i; 
	  	for(j = i+1; j < n; j++) 
	  	{ 
	   		if(a[j] < a[min]) 
	    	min = j; 
	  	} 
	  	if(min != i) 
	   		swap(a[i], a[min]); 
	} 
} 

//堆排序
void heap_siftdown(int a[],int n,int p) //调整算法 
{ 
	int i = p,j = i*2+1; 
	int tmp = a[i]; 
	while(j < n) 
	{ 
	  	if(j+1 < n && a[j] < a[j+1]) 
	  		j++; 
	  	if(a[j] <= tmp) 
	  		break; 
		else
	  	{ 
	   		a[i] = a[j]; 
	   		i = j;j = j*2+1; 
	  	} 
	} 
	a[i] = tmp; 
} 
void heap_sort(int a[],int n) 
{ 
 	int i; 
 	for(i = (n-1)/2; i >= 0;i--) 
  		heap_siftdown(a, n, i); 
 	for(i = n-1;i >= 0; i--) 
 	{ 
  		swap(a[i], a[0]); 
  		heap_siftdown(a, i, 0); 
	} 
} 

//希尔排序
void shell_pass(int a[],int n,int inc) //inc为1时，其实就是直接插入排序 
{ 
	int i,j; 
	for(i = inc; i < n; i++) 
	{ 
	    int t=a[i]; 
	    for(j = i;j >= inc && a[j-inc] > t; j-= inc) 
	    	a[j] = a[j-inc]; 
	  	a[j] = t; 
	 } 
} 

void shell_sort(int a[],int n) 
{ 
	int i = n; 
	do{ 
		i = i/3 + 1; 
		shell_pass(a, n, i); 
	}while(i > 1); 
} 


//归并排序
void merge(int a[],int b[],int l,int m,int r) 
{ 
 int i,j,k; 
 for(i = l; i <= r; i++) 
  b[i] = a[i]; 
 i = l; j = m+1; k = l; 
 while(i <= m && j <= r) 
 { 
  if(b[i] <= b[j]) a[k++] = b[i++]; 
  else a[k++] = b[j++]; 
 } 
 while(i <= m) a[k++] = b[i++]; 
 while(j <= r) a[k++] = b[j++]; 
}  

void merge_sort(int a[],int b[],int l,int r) 
{ 
 if(l >= r) 
  return; 
 int m = (l+r)/2; 
 merge_sort(a, b, l, m); 
 merge_sort(a, b, m+1, r); 
 merge(a, b, l, m, r); 
}