C++实现排序算法：桶排\选择\冒泡\插入\快速\归并

目录

桶排序/计数排序

选择排序

冒泡排序

插入排序

快速排序

归并排序

方法封装：Bubble\Select\Insert\Quick\Merge

---

桶排序/计数排序

划分多个范围相同的区间，每个子区间自排序，最后合并。

其中有一种特殊情况就是，每个区间之间的差异为最小单位1时，其实就是记录每个数据出现的次数，按数据大小输出的同时对每种数据次数做减法，直到次数为0 ，才进行下一个数据的输出。

#include<iostream>
using namespace std;
//BucketSort
int main() {
	int arr[10] = {3,4,5,6,1,2,7,8,9,0};
	int cmp[10] = {0};	//记录次数 
	for(int i=0; i<10; i++) {
		cmp[arr[i]]++;
	}

	for(int i=0; i<10; i++) {
		while(cmp[i]!=0) {
			arr[i]=i;
			cmp[i]--;
		}
	}
	
	for(int i=0; i<10; i++) {
		cout<<arr[i]<<" ";
	}
	return 0;
}

选择排序

每一次从待排序的数据元素中选出最小(或最大)的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

#include<iostream>
using namespace std;
// SelectSort 
int main(){
	int arr[10] = {3,4,5,6,1,2,7,8,9,0};
	for(int i=0; i<10; i++){
		int max = i;
		for(int j=i+1; j<10; j++){
			//从大到小排序 
			if(arr[max] < arr[j]){
				max = j;
			}
		}
		if(max != i){
			int temp =arr[max];
			arr[max] = arr[i];
			arr[i] = temp;
		}
	}
	
	for(int i=0; i<10; i++){
		cout<<arr[i]<<" ";
	}
	return 0;
}

冒泡排序

它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

冒泡排序算法的运作如下：（从后往前）

1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。

2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

3.针对所有的元素重复以上的步骤，除了最后一个。

4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

#include<iostream>
using namespace std;
// BubbleSort
int main() {
	int arr[10] = {3,4,5,6,1,2,7,8,9,0}; 
	for(int i=9; i>=0; i--) {
		for(int j=i-1; j>=0; j--) {
			//从小到大排序
			if(arr[j] > arr[j+1]) {
				int temp =arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = temp;
			}
		}
	}

	for(int i=0; i<10; i++) {
		cout<<arr[i]<<" ";
	}
	return 0;
}

插入排序

每步将一个待排序的纪录，按其关键码值的大小插入前面已经排序的文件中适当位置上，直到全部插入完为止。

一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：

⒈ 从第一个元素开始，该元素可以认为已经被排序

⒉ 取出下一个元素，在已经排序的元素序列中从后向前扫描

⒊ 如果该元素（已排序）大于新元素，将该元素移到下一位置

⒋ 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置

⒌ 将新元素插入到下一位置中

⒍ 重复步骤2

#include<iostream>
using namespace std;
// InsertionSort
int main() {
	int arr[10] = {3,4,5,6,1,2,7,8,9,0};
	for(int i=1; i<10; i++) {
		int j = i;
		//从小到大排序
		while(j>0 && arr[j-1]>arr[j]) {
			int temp =arr[j];
			arr[j] = arr[j-1];
			arr[j-1] = temp;
			j--;
		}
	}

	for(int i=0; i<10; i++) {
		cout<<arr[i]<<" ";
	}
	return 0;
}

快速排序

速排序是C.R.A.Hoare于1962年提出的一种划分交换排序。

它采用了一种分治的策略，通常称其为分治法(Divide-and-ConquerMethod)。

该方法的基本思想是：

1．先从数列中取出一个数作为基准数。

2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。

3．再对左右区间重复第二步，直到各区间只有一个数。  

归并排序

归并排序(MERGE-SORT)是建立在归并操作上的一种有效的排序算法。

该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。

将已有序的子序列合并，得到完全有序的序列；

即先使每个子序列有序，再使子序列段间有序。

若将两个有序表合并成一个有序表，称为二路归并。归并排序是一种稳定的排序方法。

方法封装：Bubble\Select\Insert\Quick\Merge

#include<iostream>
using namespace std;

const int N=1e6+10;
int a[N], temp[N], n;

//冒泡排序：最大的冒泡到最后 
void BubbleSort(int arr[], int l, int r){
    for(int i=r; i>=l; i--){
        for(int j=l; j<i; j++){
            if(a[j]>a[j+1]) {
                int temp=a[j];
                a[j]=a[j+1];
                a[j+1]=temp;
            }
        }
    } 
}

//选择排序：每次选择最大的放在最后 
void SelectSort(int a[], int l, int r){
    for(int i=r; i>=l; i--){
        int maxi=i;
        for(int j=l; j<i; j++){
            if(a[maxi]<a[j]) maxi=j;
        } 
        if(maxi!=i){
            int temp=a[maxi];
            a[maxi]=a[i];
            a[i]=temp;
        }
    } 
}

//插入排序：向左边有序序列中插入一个元素 
void InsertSort(int a[], int l, int r){
    for(int i=l; i<=r; i++){
        int k=i;
        for(int j=i; j>=l; j--){
            if(a[k]<a[j]){
                int temp=a[k];
                a[k]=a[j];
                a[j]=temp; 
                k=j; //记录现在插入元素的位置 
            }
        }
    } 
}

//快速排序：取一个基准值，大的放右边，小的放左边 
void QuickSort(int a[], int l, int r){
    if(l>=r) return;
    int i=l, j=r, mid=a[l];
    while(i<j){
        while(i<j && a[j]>mid) j--;//从左向右找到第一个小于基准值的下标
        a[i]=a[j]; 
        while(i<j && a[i]<=mid) i++;//从右向左找到第一个大于基准值的下标
        a[j]=a[i]; 
    }
    a[i]=mid;
    QuickSort(a, l, i-1);
    QuickSort(a, i+1, r);
} 

//归并排序：分治思想，将数据递归均分成两部分，直到数据元素个数为1，在回溯合并
void merge(int a[], int l, int mid, int r);
void MergeSort(int a[], int l, int r){
    if(l>=r) return;
    int mid=(l+r)/2;
    MergeSort(a, l, mid);
    MergeSort(a, mid+1, r);
    merge(a, l, mid, r);
} 
//合并：两个有序序列合并，需要开一个临时空间 temp[]
void merge(int a[], int l, int mid, int r){
    int i=l, j=mid+1, cnt=0;
    while(i<=mid && j<=r){
        if(a[i]<a[j]) temp[++cnt]=a[i++];
        else temp[++cnt]=a[j++];
    } 
    while(i<=mid) temp[++cnt]=a[i++];
    while(j<=r)   temp[++cnt]=a[j++];
    for(int i=1; i<=cnt; i++) a[l++]=temp[i];
}


int main(){
    freopen("data.in", "r", stdin);
//    freopen("data.out", "w", stdout);
    
    cin>>n;
    for(int i=1; i<=n; i++) cin>>a[i];
    for(int i=1; i<=n; i++) cout<<a[i]<<" "; cout<<endl;
    //1. bubble sort
//    BubbleSort(a, 1, n);
    
    //2. select sort
//    SelectSort(a, 1, n);
    
    //3. insert sort
//    InsertSort(a, 1, n);
    
    //4. quick sort
//    QuickSort(a, 1, n); 

    //5. merge sort
    MergeSort(a, 1, n);

    for(int i=1; i<=n; i++) cout<<a[i]<<" "; cout<<endl;
    return 0;
}