常见的几种排序(C++)

1、冒泡排序

        依次比较相邻元素，如果顺序不符合要求，就交换位置。重复进行直到没有相邻元素需要交换。代码如下：

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

class MySort
{
public:
	MySort() {

	}
	void BubbleSort(vector<int>& v);
	void SelectSort(vector<int>& v);
	void InsertSort(vector<int>& v);
	void ShellSort(vector<int>& v);
	void HeapSort(vector<int>& v);
	void FastSort(vector<int>& v);
	void MergeSort(vector<int>& v);
	
};
void MySort::BubbleSort(vector<int>& v) {
	int n = v.size();
	for (int i = 0; i < n; ++i) {
		for (int j = 0; j < n - i-1 ; ++j) {
			if (v[j] > v[j+1]) {
				int temp = v[j];
				v[j] = v[j+1];
				v[j+1] = temp;
				//swap(v[j], v[j + 1]);
				
			}
		}
	}
}

2、选择排序

每次从待排序的元素中选出最大或最小的元素，存放在序列起始位置，直到全部完成。代码如下：

void MySort::SelectSort(vector<int>& v) {
	int n = v.size();
	int minVal = 0, minIndex = 0;//记录当前最小值和下标
	for (int i = 0; i < n-1; ++i) {/只需要n-1次
		minVal = v[i], minIndex = i;
		for (int j = i+1; j < n; j++) {//从i+1开始比较，因为前i个位置已经固定
			if (v[j] < minVal) {
				minVal = v[j];
				minIndex = j;
			}
		}
		swap(v[i], v[minIndex]);//放入固定的大小位置
	}
}

3、插入排序

当插入第i个元素时，前i个元素已经完成排序，此时只需将第i个元素完成插入，找到相应的位置。原来的元素向后移动，直到完成最后排序，复杂度稳定，代码如下;

void MySort::InsertSort(vector<int>& v)
{
	int n = v.size();
	for (int i = 1; i < n; ++i) {//从第二个元素开始插入，第一个元素已排序(只有一个元素自然不需要排序)
		int temp = v[i];//记录第i个值
		int j = 0;
		for ( j = i-1; j >=0; --j) {//从后往前比较
			if (v[j] > temp) {
				v[j + 1] = v[j];//比v[i]大的后移
				
			}
			else {
				
				break;
			}
		}
		v[j+1] = temp;//找到位置交换
	}
}

4、希尔排序

希尔排序又称缩小增量法，基本思想：选定一个整数，把待排序的序列分成多个组，距离为n的分在同一组，并对每一组进行排序，复杂度不稳定，代码如下：

void MySort::ShellSort(vector<int>& v)
{
	int n = v.size();
	int Ad = 3;//组的元素数目
	for (; Ad > 0; Ad--) {
		for (int i = 0; i < n - Ad; i += Ad) {
				int k = i + Ad;
				int temp = v[k];
				while (k > 0 && temp < v[k - Ad]) {
					v[k] = v[k - Ad];
					k = k - Ad;
				}
				v[k] = temp;
			}
	}
	
}

5、堆排序

堆排序是指利用堆积树这种数据结构所设计的一种排序算法，是选择排序的一种，它是通过堆来选择数据。排升序要建大堆，降序建小堆。代码如下：

void max_heapify(int arr[], int start, int end) {
    //建立父节点指标和子节点指标
    int dad = start;
    int son = dad * 2 + 1;
    while (son <= end) { //若子节点指标在范围内才做比较
        if (son + 1 <= end && arr[son] < arr[son + 1]) //先比较两个子节点大小，选择最大的
            son++;
        if (arr[dad] > arr[son]) //如果父节点大于子节点代表调整完毕，直接跳出函数
            return;
        else { //否则交换父子内容再继续子节点和孙节点比较
            swap(arr[dad], arr[son]);
            dad = son;
            son = dad * 2 + 1;
        }
    }
}
void heap_sort(int arr[], int len) {
    //初始化，i从最后一个父节点开始调整
    for (int i = len / 2 - 1; i >= 0; i--)
        max_heapify(arr, i, len - 1);
    //先将第一个元素和已经排好的元素前一位做交换，再从新调整(刚调整的元素之前的元素)，直到排序完毕
    for (int i = len - 1; i > 0; i--) {
        swap(arr[0], arr[i]);
        max_heapify(arr, 0, i - 1);
    }
}

6、快速排序

基本思想：任取待排序的某个元素作为基准值，按照该值分割为两个子序列，左子序列小于基准值，右边子序列大于基准值，然后左右子序列重复该过程，直至完成，代码如下：

int partition(vector<int>& v, int start, int end) {
	//选择最左测的数为基准元素,我们要做的是让大于或小于该基准分开
	int pivoValue = v[start];
	int pivoPosition = start;
	for (int pos = start + 1; pos <= end; pos++)
	{
		if (v[pos] < pivoValue)
		{
			//当前arr【pos】于基准元素右测的元素交换
			swap(v[pivoPosition + 1], v[pos]);
			//当前元素与基准元素交换
			swap(v[pivoPosition], v[pivoPosition + 1]);
			//调整基准元素位置，使基准元素项目保持不变
			pivoPosition++;
			
		}
	}
	return pivoPosition;
}
void MySort::FastSort(vector<int>& v, int start, int end)
{
	if (start < end)
	{
		//找到分界点
		int p = partition(v, start, end);
		//分段递归
		FastSort(v, p+1, end);
		FastSort(v, start, p - 1);
		
	}
}

如有错误欢迎指正，如果对您有帮助请点个赞！