常见排序算法C++

1.选择排序

算法描述：初始时，在序列中找到最小元素，放到序列的起始位置作为已排序序列；然后，再从剩余未排序元素中寻找最小元素，放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

template<typename T>
void selectionSort(T arr[] , int n ){

	for (int i = 0; i < n - 1; i++){

		int minIndex = i;
		for(int j = i + 1; j < n; j++)
			if(arr[j]<arr[minIndex])
				minIndex = j;

		swap(arr[i], arr[minIndex]);
	}
}

总结：时间复杂度为O(n^2)

2.插入排序

算法描述：插入即表示将一个新的数据插入到一个有序数组中，并继续保持有序。例如有一个长度为N的无序数组，进行N-1次的插入即能完成排序；第一次，数组第1个数认为是有序的数组，将数组第二个元素插入仅有1个有序的数组中；第二次，数组前两个元素组成有序的数组，将数组第三个元素插入由两个元素构成的有序数组中......第N-1次，数组前N-1个元素组成有序的数组，将数组的第N个元素插入由N-1个元素构成的有序数组中，则完成了整个插入排序。

template<typename T>
void insertionSort(T arr[], int n){

	for (int i = 1; i < n; i++){

		for (int j = i; j>0 ; j--){
			if (arr[j] < arr[j - 1])
				swap(arr[j], arr[j - 1]);
			else
				break;
		}
	}
}

改进：不再用swap函数（此函数一次会经过三次赋值语句）。将待插入元素，拷贝出来，依次向前比较。直到插入到合适位置。

template<typename T>
void insertionSortImprove(T arr[], int n){

	for (int i = 1; i < n; i++){

		T e = arr[i];
		int j;
		for (j = i; j>0 && e<arr[j-1]; j--){
			arr[j] = arr[j - 1];
		}
		arr[j] = e;
	}
}

总结：时间复杂度为O(n^2);但当序列为近乎有序的时候，插入排序的速度会很快。

3.冒泡排序

算法描述：比较相邻的元素。如果第一个比第二个大，就交换他们两个；对每一对相邻元素做相同的操作，从开始第一对到结尾的最后一对，这时最后的元素应该会是最大的数；对除了最后一个的所有元素重复以上步骤。 持续对剩下的元素重复上面的步骤，直到没有任何一对数字需要比较。

template<typename T>
void bubbleSort(T arr[], int n){

	for (int i = 0; i < n; i++){

		for (int j = 0; j < n - i - 1; j++){
			if (arr[j]>arr[j + 1])
				swap(arr[j], arr[j + 1]);
		}
	}
}

总结：时间复杂度O(n^2)

4.希尔排序

算法描述：先取一个小于n的整数d1作为第一个增量，把文件的全部记录分组。所有距离为d1的倍数的记录放在同一个组中。先在各组内进行直接插入排序；然后，取第二个增量d2<d1重复上述的分组和排序，直至所取的增量dt=1(dt<dt-l<…<d2<d1)，即所有记录放在同一组中进行直接插入排序为止。

template<typename T>
void shellSort(T arr[], int n){

	T insertNum;
	int gap = n / 2;
	while (gap){
		for (int i = gap; i < n; i = i + gap){
			insertNum = arr[i];
			int j;
			for (j = i; j>=gap && insertNum < arr[j - gap]; j = j - gap){
				arr[j] = arr[j - gap];
			}
			arr[j] = insertNum;
		}
		gap = gap / 2;
	}
}

总结：中等大小规模数据表现良好，对规模非常大的数据排序不是最优选择。

5.归并排序

算法描述：略

//递归使用归并排序，对arr[l...r]的范围进行排序
template<typename T>
void __mergeSort(T arr[],int l, int r){

	if (l >= r)
		return;
	int mid = (l + r) / 2;
	__mergeSort(arr, l, mid);
	__mergeSort(arr, mid + 1, r);
		//if (arr[mid]>arr[mid + 1])
	__merge(arr, l, mid, r);

}

//将arr[r...mid]和arr[mid+1...r]两部分进行归并
template<typename T>
void __merge(T arr[], int l, int mid, int r){

	T *aux = new T[r-l+1];
	for (int i = l; i <= r; i++)
		aux[i - l] = arr[i];
	int i = l, j = mid + 1;
	for (int k = l; k <= r; k++){
		if (i > mid){
			arr[k] = aux[j - l];
			j++;
		}
		else if (j > r){
			arr[k] = aux[i - l];
				i++;
		}
		else if (aux[i - l] < aux[j - l]){
			arr[k] = aux[i-l];
			i++;
		}
		else{
			arr[k] = aux[j - l];
			j++;
		}
	}
	delete[] aux;
}

template<typename T>
void mergeSort(T arr[], int n){

	__mergeSort(arr, 0, n - 1);
}

6.快速排序

算法描述：略

//对arr[l...r]部分进行partition 操作
//返回p，使得arr[l...p-1]<arr[p];arr[p+1...r]>arr[p]
template<typename T>
int __partition(T arr[], int l, int r){

	T v = arr[l];

	//arr[l+1...j]<v;arr[j+1...i]>v
	int j = l;
	for (int i = l + 1; i <= r; i++){
		if (arr[i] < v){
			swap(arr[j+1], arr[i]);
			j++;
		}
	}
	swap(arr[l], arr[j]);

	return j;
}

//对arr[l...r]部分进行快速排序
template<typename T>
void __quickSort(T arr[], int l, int r){

	if (l >= r)
		return;
	int p = __partition(arr, l, r);
	__quickSort(arr, l, p - 1);
	__quickSort(arr, p + 1, r);
}

template<typename T>
void quickSort(T arr[], int n){

	__quickSort(arr, 0, n - 1);
}