八大排序算法_C++实现及对比

（1）直接插入排序

void insertSort(int *data, int len) {
	for(int i = 1; i < len; ++i) {
		int tmp = data[i];
		for(int j = i; j > 0; --j) {
			if(data[j - 1] > data[j])
				swap(data[j - 1], data[j]);
			else
				break;
		}
	}
}

（2）冒泡排序

void bubbleSort(int *data, int len) {
	for(int i = 0; i < len; ++i) {
		for(int j = len - 1; j > i; --j) {
			if(data[j - 1] > data[j])
				swap(data[j - 1], data[j]);
		}
	}
}

（3）选择排序

void selectSort(int *data, int len) {
	for(int i = 0; i < len; ++i) {
		int max = i;
		for(int j = i + 1; j < len; ++j) {
			if(data[j] < data[max])
				max = j;
		}
		swap(data[i], data[max]);
	}
}

（4）希尔排序：将序列分成子序列，然后对子序列分别进行插入排序

void shellSort(int *data, int len) {
	int gap = len / 2;
	while(gap >= 1){
		for(int i = gap; i < len; ++i) {
			for(int j = i; j >= gap; j -= gap) {
				if(data[j - gap] > data[j])
					swap(data[j - gap], data[j]);
			}
		}
		gap /= 2;
	}
}

（5）快速排序

int partition(int *data, int low, int high) {
	int pivot = data[low];
	while(low < high) {
		while(low < high && data[high] >= pivot)
			--high;
		swap(data[low], data[high]);
		while(low < high && data[low] <= pivot)
			++low;
		swap(data[low], data[high]);
	}
	return low;
}

void quickSort(int *data, int low, int high) {
	if(low < high) {
		int mid = partition(data, low, high);
		quickSort(data, low, mid - 1);
		quickSort(data, mid + 1, high);
	}
}

（6）堆排序

//堆排序 ： 将要排序的n个数看作顺序存储的二叉树，
//首先将其建成大顶堆
//然后将堆顶元素和最后一个元素交换，将前n-1个元素调整为大顶堆
//再将堆顶元素和倒数第二个元素交换，将前n-2个元素调整为大顶堆
//如此循环。
void adjustHeap(int *data, int len, int k) {
	//第k个元素违背了大顶堆的定义，将其调整为大顶堆
	while(k < len / 2) {
		int max = k;
		if(2 * k + 1 < len && data[max] < data[2 * k + 1])
			max = 2 * k + 1;
		if(2 * k + 2 < len && data[max] < data[2 * k + 2])
			max = 2 * k + 2;
		if(max == k)
			break;
		else {
			swap(data[k], data[max]);
			k = max;
		}
	}
}

void buildHeap(int *data, int len) {
	for(int i = len / 2 - 1; i >= 0; --i) {
		adjustHeap(data, len, i);
	}
}

void heapSort(int *data, int len) {
	buildHeap(data, len);
	for(int i = len - 1; i > 0; --i) {
		swap(data[0], data[i]);
		adjustHeap(data, i, 0);
	}
}

（7）归并排序

void merge(int *data, int begin, int mid, int end) {
	int n = end - begin + 1;
	int *sortData = new int[n];
	int i = begin, j = mid + 1, k = 0;;
	while(i <= mid && j <= end) {
		if(data[i] <= data[j]) {
			sortData[k++] = data[i++];
		}
		else {
			sortData[k++] = data[j++];
		}
	}
	while(i <= mid) {
		sortData[k++] = data[i++];
	}
	while(j <= end) {
		sortData[k++] = data[j++];
	}
	for(i = begin, k = 0; k < n; ++i, ++k) {
		data[i] = sortData[k];
	}
	delete[] sortData;
}

void mergeSort(int *data, int begin, int end) {
	if(begin < end) {
		int mid = (end + begin) / 2;
		mergeSort(data, begin, mid);
		mergeSort(data, mid + 1, end);
		merge(data, begin, mid, end);
	}
}

（8）基数排序

#define RADIX_NUM 10
#define KEY_NUM 3
int getNumInPos(int num, int pos) {
	while(pos > 1) {
		num /= 10;
		--pos;
	}
	return num%10;
}

void radixSort(int *data, int n) {
	int *radix[RADIX_NUM];
	for(int i = 0; i < RADIX_NUM; ++i) {
		radix[i] = new int[n + 1];
	}
	for(int i = 1; i <= KEY_NUM;++i) {
		//radix[i][o]用来表示第i个桶内的数据个数，每次重新分配前将radix[i][0]重置为0
		for(int j = 0; j < RADIX_NUM; ++j) {
			radix[j][0] = 0; 
		}
		//分配
		for(int j = 0; j < n; ++j) {
			int num = getNumInPos(data[j], i);
			radix[num][++radix[num][0]] = data[j];
		}
		//收集
		for(int j = 0, k = 0; j < RADIX_NUM; ++j) {
			for(int m = 1; m <= radix[j][0]; ++m) {
				data[k++] = radix[j][m];
			}
		}
	}
	for(int i = 0; i < RADIX_NUM; ++i) {
		delete[] radix[i];
	}
}

各种排序算法的时间复杂度和空间复杂度对比：