常见排序算法

常见排序算法及其复杂度、稳定性

以下为常见排序算法的实现代码，仅供参考。

/****************************************************************
* 程序说明：排序算法
* 主要包含：
*			1. 直接插入排序		dirInsertSort()
*			2. 折半插入排序		binInsertSort()
*			3. 希尔排序			shlInsertSort()
*			4. 冒泡排序			bubbleSort()
*			   改进的冒泡排序	impBubbleSort()
*			5. 快速排序			quickSort()
*			6. 简单选择排序		simpleSelectSort()
*			7. (大顶)堆排序		heapSort()
*			8. (二路)归并排序	mergeSort()	
*			9. 基数排序			radixSort()
****************************************************************/

#include<iostream>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<vector>
#include<algorithm>
using namespace std;

void dirInsertSorta(int* array, int arrayLen) {
	for (int i = 1; i < arrayLen; i++) {
		int key = array[i];
		int j = i - 1;
		while (j >= 0 && array[j] > key) {
			array[j + 1] = array[j]; 
			j--;
		}
		array[j + 1] = key;
	}
}

void binInsertSort(int* array, int arrayLen) {
	for (int i = 1; i < arrayLen; i++) {
		int key = array[i];
		int low = 0, high = i - 1;
		while( high >= low) {
			int mid = (low + high) / 2;
			if (key < array[mid])high = mid - 1;
			else low = mid + 1;
		}
		for (int j = i - 1; j >= low; j--)
			array[j + 1] = array[j];
		array[low] = key;
	}
}

void shlInsertSort(int* array, int arrayLen) {
	vector<int>delta;
	for (int i = arrayLen / 2; i >= 1; i /= 2)
		delta.push_back(i);
	for (int i = 0; i < delta.size(); i++) {
		int w = delta.at(i);
		for (int j = w; j < arrayLen; j++) {
			int key = array[j];
			int f = j - w;
			while (f >= 0 && array[f] > key) {
				array[f + w] = array[f];
				f -= w;
			}
			array[f + w] = key;
		} 
	}
}

void bubbleSort(int* array, int arrayLen){
	for (int i = 1; i < arrayLen; i++) {
		for (int j = 0; j < arrayLen - i; j++) {
			if (array[j] > array[j + 1]) {
				int tmp = array[j + 1];
				array[j + 1] = array[j];
				array[j] = tmp;
			}
		}
	}
}

void impBubbleSort(int* array, int arrayLen) {
	int flag = 1;
	for (int i = 1; i < arrayLen&&flag; i++) {
		flag = 0;
		for (int j = 0; j < arrayLen - i; j++) {
			if (array[j] > array[j + 1]) {
				int tmp = array[j + 1];
				array[j + 1] = array[j];
				array[j] = tmp;
				flag = 1;
			}
		}
	}
}

/*
* 在主函数里调用快速排序函数，格式应为:
* quickSort(array, 0, arrayLen-1)
*/
void quickSort(int* array, int low, int high) {
	if (low < high) {
		int i = low;
		int j = high;
		int pivot = array[i];
		while (i < j) {
			while (i<j&&array[j]>pivot) {
				j--;
			}
			if (i < j) {
				array[i] = array[j];
				i++;
			}
			while (i < j&&array[i] < pivot) {
				i++;
			}
			if (i < j) {
				array[j] = array[i];
				j--;
			}
		}
		array[i] = pivot;
		quickSort(array, low, i - 1);
		quickSort(array, i + 1, high);
	}
}

void simpleSelectSort(int* array, int arrayLen) {
	for (int i = 0; i < arrayLen-1; i++) {
		int k = i;
		for (int j = i + 1; j < arrayLen; j++) {
			if (array[j] < array[k])
				k = j;
		}
		if(i!=k)swap(array[i], array[k]);
	}
}

void adjustHeap(int* array, int s, int m) {//调整array[s...m]，使其成为一个大顶堆
	int tmp = array[s];
	for (int j = 2 * s + 1; j <= m; j *= 2 + 1) {
		if (j < m&&array[j] < array[j + 1]) j++;//s的左右儿子中，最大的标记
		if (tmp > array[j])break;//如果s本身就大于其左右儿子，直接跳出，不用再往下做
		array[s] = array[j];//否则交换s与其最大的儿子
		s = j;//然后对以j为根的堆进行判断，看是否其为大顶堆，重复上述类似过程
	}
	array[s] = tmp;
}

void createHeap(int* array, int arrayLen) {
	for (int i = arrayLen / 2 - 1; i >= 0; i--)
		adjustHeap(array, i, arrayLen - 1);
}

void heapSort(int* array, int arrayLen) {
	createHeap(array, arrayLen);//创建一个大顶堆
	for (int i = arrayLen - 1; i > 0; i--) {
		swap(array[0], array[i]);//交换堆顶与最后一个元素
		adjustHeap(array, 0, i - 1);//重新调整堆
	}
}

void merge(int* array, int left, int right) {
	int len = right - left + 1;
	int* tmpArray = (int*)malloc(len * sizeof(int));
	int aCount = 0;
	int mid = (left + right) / 2;
	int begin1 = left, begin2 = mid + 1;
	while (begin1 <= mid&&begin2 <= right) {
		if (array[begin1] <= array[begin2])
			tmpArray[aCount++] = array[begin1++];
		else 
			tmpArray[aCount++] = array[begin2++];
	}
	while (begin1 <= mid)
		tmpArray[aCount++] = array[begin1++];
	while (begin2 <= right)
		tmpArray[aCount++] = array[begin2++];
	for (int i = 0, j = left; i < len; i++)
		array[j++] = tmpArray[i];
	free(tmpArray);
}

/*
* 在主函数里调用快速排序函数，格式应为:
* qkSort(array, 0, arrayLen-1)
*/
void mergeSort(int* array, int left, int right) {
	if (left < right) {
		int mid = (left + right) / 2;
		mergeSort(array, left, mid);
		mergeSort(array, mid + 1, right);
		merge(array, left, right);
	}

}

int getNumInPos(int num, int pos) {//找到num的从低到高的第pos位的数据
	int tmp = (int)pow(10.0, (double)pos-1);
	return (num / tmp) % 10;
}

int getMaxBitNum(int* array, int arrayLen) {
	int maxNum = array[0];
	for (int i = 1; i < arrayLen; i++)
		if (maxNum < array[i])
			maxNum = array[i];
	char str[100];
	itoa(maxNum, str, 10);
	return strlen(str);
}

void radixSort(int* array, int arrayLen) {
	int RADIX_BASE = 10;//整形排序
	int KEYBIT_NUM = getMaxBitNum(array,arrayLen);//关键字个数，即待排序的数组中的最大数的位数
	int* radixArrays[10];//分配为0~9的序列空间
	for (int i = 0; i < 10; i++) {
		radixArrays[i] = (int*)malloc(sizeof(int)*(arrayLen + 1));
		radixArrays[i][0] = 0;//index为0处记录这组数据的个数
	}
	for (int pos = 1; pos <= KEYBIT_NUM; pos++) {
		for (int i = 0; i < arrayLen; i++) {//分配过程
			int num = getNumInPos(array[i], pos);
			int index = ++radixArrays[num][0];
			radixArrays[num][index] = array[i];
		}
		for (int i = 0, j = 0; i < RADIX_BASE; i++) {//收集过程
			for (int k = 1; k <= radixArrays[i][0]; k++)
				array[j++] = radixArrays[i][k];
			radixArrays[i][0] = 0;//复位
		}
	}
}

int main() {

	int array[] = { 2,101,4,3,5 };
	int arrayLen = sizeof(array) / sizeof(array[0]);
	int array2[10];
	//bubbleSort(array2, arrayLen);
	//impBubbleSort(array, arrayLen);
	//quickSort(array, arrayLen);
	//heapSort(array, arrayLen);
	//radixSort(array, arrayLen);
	for (int i = 0; i < 10; i++)
		cout << array[i] << " ";
	cout << endl;
	system("pause");
	return 0;
}