【排序算法】插入排序&归并排序&快速排序&堆排序

针对随机序列的排序算法

随机生成序列

void init(){
	arr.clear();
	for(int i = 0; i < n; ++i){
		int num = (int)(round(1.0 * rand() / RAND_MAX * n));//生成0~n内的随机数 
		arr.push_back(num);
	}
	origin = arr;
}

插入排序

• 时间复杂度为O(N²)
• 具有稳定性

//插排 
void insertSort(){
	for(int i = 0; i < arr.size(); ++i){
		int temp = arr[i];
		int j = i;
		while(j > 0 && temp < arr[j - 1]){//此处可以改为降序 
			arr[j] = arr[j - 1];
			j--;
		}
		arr[j] = temp;
	}
}

归并排序

• 时间复杂度为O(nlogn)
• 具有稳定性

//归并 
void merge(int L1, int R1, int L2, int R2){
	int i = L1, j = L2;
	vector<int> temp;
	int index = 0;
	while(i <= R1 && j <= R2){
		if(arr[i] <= arr[j]){//此处可以改为降序 
			temp.push_back(arr[i++]);
			
		}else{
			temp.push_back(arr[j++]);
		}
	}
	while(i <= R1){
		temp.push_back(arr[i++]);
	}
	while(j <= R2){
		temp.push_back(arr[j++]);
	}
	for(int i = 0; i < temp.size(); ++i){
		arr[L1 + i] = temp[i];
	}
}
void mergeSort(int left, int right){
	if(left < right){
		int mid = (left + right) / 2;
		mergeSort(left, mid);
		mergeSort(mid + 1, right);
		merge(left, mid, mid + 1, right);
	}
}

快速排序

• 时间复杂度为O(nlogn)
• 不稳定性

int randPartition(int left, int right){
	int p = (int)round(1.0 * rand() / RAND_MAX * (right - left) + left);
	swap(arr[p], arr[left]);
	int temp = arr[left];
	while(left < right){
		while(left < right && arr[right] > temp){//此处可以改为降序 
			right--;
		}
		arr[left] = arr[right];
		while(left < right && arr[left] <= temp){//此处可以改为降序 
			left++;
		}
		arr[right] = arr[left];
	}
	arr[left] = temp;
	return left;
}
void quickSort(int left, int right){
	if(left < right){
		int pos = randPartition(left, right);
		quickSort(left, pos - 1);
		quickSort(pos + 1, right);
	}
}

堆排序

• 时间复杂度为O(nlogn)
• 不稳定性

//堆排序
//downAdjust，向下调整建立大顶堆
vector<int> heap;
void initHeapArray(){
	heap.push_back(-1);//完全二叉树的数组形式要从下标为1开始 
	for(int i = 0; i < n; ++i){
		int num = origin[i];
		heap.push_back(num);
	}
}
void downAdjust(int left, int right){
	int i = left, j = i * 2;//i为预调整点，j为i的左孩子 
	while(j <= right){
		if(j + 1 <= right && heap[j + 1] > heap[j]){
			j = j + 1;
		}
		if(heap[j] > heap[i]){//此处可以改为降序 
			swap(heap[j], heap[i]);
			i = j;
			j = i * 2;//i为预调整点，j为i的左孩子
		}else{
			break;
		}
	}
}
//建堆 
void createHeap(){
	for(int i = n / 2; i >= 1; --i){
		downAdjust(i, n);
	}
} 
void heapSort(){
	createHeap();
	for(int i = n; i > 1; --i){
		swap(heap[i], heap[1]);
		downAdjust(1, i - 1);
	}
}

完整代码

#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> origin;//原始序列 
vector<int> arr;//排序序列 
//初始化 
void init(){
	arr.clear();
	for(int i = 0; i < n; ++i){
		int num = (int)(round(1.0 * rand() / RAND_MAX * n));//生成0~n内的随机数 
		arr.push_back(num);
	}
	origin = arr;
}
//插排 
void insertSort(){
	for(int i = 0; i < arr.size(); ++i){
		int temp = arr[i];
		int j = i;
		while(j > 0 && temp < arr[j - 1]){//此处可以改为降序 
			arr[j] = arr[j - 1];
			j--;
		}
		arr[j] = temp;
	}
}
//归并 
void merge(int L1, int R1, int L2, int R2){
	int i = L1, j = L2;
	vector<int> temp;
	int index = 0;
	while(i <= R1 && j <= R2){
		if(arr[i] <= arr[j]){//此处可以改为降序 
			temp.push_back(arr[i++]);
			
		}else{
			temp.push_back(arr[j++]);
		}
	}
	while(i <= R1){
		temp.push_back(arr[i++]);
	}
	while(j <= R2){
		temp.push_back(arr[j++]);
	}
	for(int i = 0; i < temp.size(); ++i){
		arr[L1 + i] = temp[i];
	}
}
void mergeSort(int left, int right){
	if(left < right){
		int mid = (left + right) / 2;
		mergeSort(left, mid);
		mergeSort(mid + 1, right);
		merge(left, mid, mid + 1, right);
	}
}
//快排 
int randPartition(int left, int right){
	int p = (int)round(1.0 * rand() / RAND_MAX * (right - left) + left);
	swap(arr[p], arr[left]);
	int temp = arr[left];
	while(left < right){
		while(left < right && arr[right] > temp){//此处可以改为降序 
			right--;
		}
		arr[left] = arr[right];
		while(left < right && arr[left] <= temp){//此处可以改为降序 
			left++;
		}
		arr[right] = arr[left];
	}
	arr[left] = temp;
	return left;
}
void quickSort(int left, int right){
	if(left < right){
		int pos = randPartition(left, right);
		quickSort(left, pos - 1);
		quickSort(pos + 1, right);
	}
}
//堆排序
//downAdjust，向下调整建立大顶堆
vector<int> heap;
void initHeapArray(){
	heap.push_back(-1);//完全二叉树的数组形式要从下标为1开始 
	for(int i = 0; i < n; ++i){
		int num = origin[i];
		heap.push_back(num);
	}
}
void downAdjust(int left, int right){
	int i = left, j = i * 2;//i为预调整点，j为i的左孩子 
	while(j <= right){
		if(j + 1 <= right && heap[j + 1] > heap[j]){
			j = j + 1;
		}
		if(heap[j] > heap[i]){//此处可以改为降序 
			swap(heap[j], heap[i]);
			i = j;
			j = i * 2;//i为预调整点，j为i的左孩子
		}else{
			break;
		}
	}
}
//建堆 
void createHeap(){
	for(int i = n / 2; i >= 1; --i){
		downAdjust(i, n);
	}
} 
void heapSort(){
	createHeap();
	for(int i = n; i > 1; --i){
		swap(heap[i], heap[1]);
		downAdjust(1, i - 1);
	}
}
void display(vector<int> v){
	if(v.size() == n){
		for(int i = 0; i < v.size(); ++i){
			printf("%d ", v[i]);
		}
	}else{
		for(int i = 1; i < v.size(); ++i){
			printf("%d ", v[i]);
		}
	}
	printf("\n");
}
int main(int argc, char *argv[]) {
	srand((unsigned)time(NULL)); //随机种子 
	printf("input size:");
	scanf("%d", &n);
	init();
	clock_t start,end;
	//快速排序
	arr = origin;
	start = clock();
	quickSort(0, arr.size() - 1);
	end = clock();
	double Time = (double)(end - start);
	cout << "quickSortTime:" << Time/CLOCKS_PER_SEC << " ms" << endl;
	//归并排序
	arr = origin; 
	start = clock();
	mergeSort(0, arr.size() - 1);
	end = clock();
	Time = (double)(end - start);
	cout << "mergeSortTime:" << Time/CLOCKS_PER_SEC << " ms" << endl;
	//堆排序
	arr = origin;
	initHeapArray();
	start = clock();
	//display(origin);
	heapSort();
	//display(heap);
	end = clock();
	Time = (double)(end - start);
	cout << "heapSortTime:" << Time/CLOCKS_PER_SEC << " ms" << endl;
	//插排 
	start = clock();
	//display(origin);
	insertSort();
	end = clock();
	//display(arr);
	Time = (double)(end - start);
	cout << "insertTime:" << Time/CLOCKS_PER_SEC << " ms" << endl;
	return 0;
}