详细排序原理可以参考：图文详解—十大经典排序算法

1 冒泡排序

//冒泡排序
void bubbleSort(vector<int> & vec) { 
	int len = vec.size();
	for (int i = 0; i < len; i++) { 
		//此处的i是为了界定遍历的长度
		for (int j = 0; j < len - i - 1; j++) { 
			if (vec[j] > vec[j + 1]) { 
				int temp = vec[j];
				vec[j] = vec[j + 1];
				vec[j + 1] = temp;
			}
		}
	}
}

2 选择排序

//选择排序
void selectSort(vector<int>& vec) { 
	int len = vec.size();
	for (int i = 0; i < len; i++) { 
		int maxIndex=0;
		for (int j = 1; j < len - i ; j++) { 
			if (vec[maxIndex] < vec[j]) maxIndex = j;
		}
		int temp = vec[maxIndex];
		vec[maxIndex] = vec[len - i - 1];
		vec[len - i - 1] = temp;
	}
}

3 插入排序

//插入排序
void insertSort(vector<int>& vec) { 
	int len = vec.size();
	for (int j = 1; j < len; j++) { 
		int i, key; 
		key = vec[j];
		for (i = j - 1; i >= 0 && key < vec[i]; i--) { 
			//此时第一个i+1等于j
			vec[i + 1] = vec[i];
		}
		vec[i + 1] = key;
	}
}

4 希尔排序

//希尔排序
void shellSort(vector<int>& vec) { 
	int len = vec.size();
	for (int gap = 5; gap > 0; gap /= 2) { 
		for (int j = gap; j < len; j++) { 
			int i, key = vec[j];
			for (i = j - gap; i >= 0 && key < vec[i]; i -= gap) { 
				vec[i + gap] = vec[i];
			}
			vec[i + gap] = key;
		}
	}
}

5 归并排序

//参考邓俊辉《数据结构》书中归并排序
void merge(int* arr, int lo, int mi, int hi) { 
	int* A = arr + lo;//A[0,hi-lo)=arr[lo,hi)
	//B[0,mi-lo)=arr[lo,mi)
	int lb = mi - lo;
	int* B = new int[lb];//分配lb个单位的连续整型空间
	for (int i = 0; i < lb; i++) { 
		B[i] = arr[lo + i];//B[i]=*(arr+lo+i);
	}
	//C[0,hi-mi)=arr[mi,hi)
	int lc = hi - mi;
	int* C = arr + mi;
	for (int i = 0, j = 0, k = 0; i < lb || j < lc;) { 
		if ((i < lb) && (!(j < lc) || B[i] < C[j])) A[k++] = B[i++];
		if ((j < lc) && (!(i < lb) || C[j] <= B[i])) A[k++] = C[j++];
	}
}

void mergeSort(int arr[], int lo, int hi) { 
	if (hi - lo < 2) return;
	int mi = (lo + hi) / 2;
	mergeSort(arr, lo, mi);
	mergeSort(arr, mi, hi);
	merge(arr, lo, mi, hi);
}

6 快速排序

//快速排序
void quickSort(int* arr,int left,int right) { 
	//此处必须要写为>=;若写为==则会出错
	if (left >= right) return;
	int l = left;
	int r = right;
	int pivot = arr[l];
	//标志为false时，表示改指针上的数据已被拿出
	//标志为true时，表示指针上的数据未被拿出
	bool fflag = false;
	bool rflag = true;
	while (l < r) { 
		if (rflag) { 
			if (!fflag && arr[r] < pivot) { 
				arr[l] = arr[r];
				fflag = true;
				rflag = false;
			}
			else r--;
		}
		if (fflag) { 
			if (!rflag && arr[l] >= pivot) { 
				arr[r] = arr[l];
				fflag = false;
				rflag = true;
			}
			else l++;
		}
	}
	arr[l] = pivot;
	quickSort(arr, left, l - 1);
	quickSort(arr, l + 1, right);
}

7 堆排序

堆排原理详细可以参考B站视频：https://www.bilibili.com/video/BV1Eb41147dK

void swap(int tree[], int a, int b) { 
	int temp=tree[a];
	tree[a] = tree[b];
	tree[b] = temp;
	
}

//此处的n为传入的数组的大小
void heapify(int tree[], int n, int i) { 
	if ((2 * i + 1) > n-1) return;
	int pare = (i - 1) / 2;
	int lchild = 2 * i + 1;
	int rchild = 2 * (i + 1);
	int maxIndex = i;
	if (tree[maxIndex] < tree[lchild]) maxIndex = lchild;
	if (tree[maxIndex] < tree[rchild]) maxIndex = rchild;
	if (maxIndex != i)
	{ 
		swap(tree, maxIndex, i);
		i = maxIndex;
		heapify(tree, n, i);
	}
}

//当数列完全无序时，生成堆序列
void generateHeap(int tree[], int n) { 
	int last = ((n - 1) - 1) / 2;
	for (int i = last; i >= 0; i--) { 
		heapify(tree, n, i);
	}
}

//堆排序
void heapSort(int tree[],int n) { 
	generateHeap(tree, n);
	for (int i = n - 1; i > 0; i-- ) { 
		swap(tree, i, 0);
		heapify(tree, i - 1, 0);
	}
}