C语言七大排序算法实现

一、冒泡排序

void Swap(int arr[], int i, int j){
	int tmp = arr[i];
	arr[i] = arr[j];
	arr[j] = tmp;
	return;
}

/* 冒泡排序 时间复杂度：O(n*n) 空间复杂度：O(1) 稳定排序 原地排序*/
void BubbleSort(int arr[], int length){
	bool flag = false;
	for(int i = 0; i < length && !flag; i++){
		flag = true;
		for(int j = 0; j < length - i - 1; j++){
			if(arr[j] > arr[j + 1]){
				Swap(arr, j, j + 1);
				flag = false;
			}
		}
	}
	return;
}

二、选择排序

/* 选择排序 时间复杂度：O(n*n) 空间复杂度：O(1) 非稳定排序 原地排序*/
void SelectSort(int arr[], int length){
	for(int i = 0; i < length; i++){
		int min = i;
		for(int j = i + 1; j < length; j++){
			if(arr[j] < arr[min]){
				min = j;
			}
		}
		Swap(arr, i, min);
	}
	return;
}

三、插入排序

/* 插入排序 时间复杂度：O(n*n) 空间复杂度：O(1) 稳定排序 原地排序*/
void InsertSort(int arr[], int length){
	for(int i = 0; i < length; i++){
		if(arr[i] < arr[i - 1]){
			int tmp = arr[i];
			for(int j = i - 1; arr[j] > tmp; j--){
				arr[j + 1] = arr[j];	
			}	
			arr[j + 1] = tmp;
		}
	}
	return;
}

四、希尔排序

/* 希尔排序(插入排序升级) 时间复杂度：O(n的1.5方) 空间复杂度：O(1) 非稳定排序 原地排序*/
void ShellSort(int arr[], int length){
	int increment = length;
	do{
		increment = increment / 3 + 1;
		for(int i = increment; i < length; i++){
			if(arr[i] < arr[i - increment]){
				int tmp = arr[i];
				for(int j = i - increment; arr[j] > tmp; j = j - increment){
					arr[j + increment] = arr[j];
				}
				arr[j + increment] = tmp;
			}	
		}
	}while(increment > 1)
	return;
}

五、堆排序

/* 堆排序(选择排序升级) 时间复杂度：O(nlogn) 空间复杂度：O(1) 非稳定排序 原地排序*/
void HeapAdjust(int tree[], int length, int i){
	if(i >= length)	return;
	int left = i * 2 + 1;
	int right = i * 2 + 2;
	int max = i;
	if(left < length && tree[left] > tree[max]){
		max = left;	
	}
	if(right < length && tree[right] > tree[max]){
		max = right;	
	}
	if(max != i){
		Swap(tree, max, i);
		HeapAdjust(tree, length, max);
	}
	return;
}

void HeapSort(int arr[], int length){
	for(int i = length / 2 - 1; i >= 0; i--){
		HeapAdjust(arr, length, i);
	}
	for(int j = length - 1; j >= 0; j--){
		Swap(arr, j, 0);
		HeapAdjust(arr, j - 1, 0);
	}
	return;
}

六、归并排序

/* 归并排序 时间复杂度：O(nlogn) 空间复杂度：O(n) 稳定排序 非原地排序*/
void Merge(int arr[], int left, int middle, int right){
	int leftSize = middle - left + 1;
	int rightSize = right - middle;
	int *leftArr = new int[leftSize];
	int *rightArr = new int[rightSize];
	int leftInd = 0;
	int rightInd = 0;
	for(int i = left; i <= right; i++){
		if(i <= middle){
			leftArr[leftInd++] = arr[i];	
		}else{
			rightArr[rightInd++] = arr[i];	
		}
	}
	
	int ind = left;
	leftInd = 0;
	rightInd = 0;
	while(leftInd < leftSize && rightInd < rightSize){
		if(leftArr[leftInd] < rightArr[rightInd]){
			arr[index++] = leftArr[leftInd++];
		}else{
			arr[index++] = rightArr[rightInd++];
		}
	}
	while(leftInd < leftSize){
		arr[index++] = leftArr[leftInd++]	
	}
	while(rightInd < rightSize){
		arr[index++] = rightArr[rightInd++];
	}
	
	delete[]leftArr;
	delete[]rightArr;
	return;
}

void MergeSort(int arr[], int left, int right){
	if(left == right)	return;
	int middle = (left + right) / 2;
	MergeSort(arr, left, middle);
	MergeSort(arr, middle + 1, right);
	Merge(arr, left, middle, right);
	return;
}

七、快速排序

/* 快速排序(冒泡排序升级) 时间复杂度：O(nlogn) 空间复杂度：O(logn) 非稳定排序 原地排序*/
int Partition(int arr[], int left, int right){
	int key = arr[left];	// left作为关键值 下面的while要先判断right
	while(left < right){
		while(left < right && arr[right] >= key){
			right--;	
		}
		Swap(arr, left, right);
		while(left < right && arr[left] <= key){
			left++;	
		}
		Swap(arr, left, right);		
	}
	return right;
}

void QuickSort(int arr[], int left, int right){
	if(left >= right)	return;
	int pivotInd = Partition(arr, left, right);
	QuickSort(arr, left, pivotInd - 1);
	QuickSort(arr, pivotInd + 1, right);
	return;
}