十大排序方法汇总
关于时间复杂度
平方阶 (O(n2)) 排序 各类简单排序:直接插入、直接选择和冒泡排序。
线性对数阶 (O(nlog2n)) 排序 快速排序、堆排序和归并排序;
O(n1+§)) 排序,§ 是介于 0 和 1 之间的常数。 希尔排序
线性阶 (O(n)) 排序 基数排序,此外还有桶、箱排序。
关于稳定性
稳定的排序算法:冒泡排序、插入排序、归并排序和基数排序。
不是稳定的排序算法:选择排序、快速排序、希尔排序、堆排序。
名词解释:
• n:数据规模
• k:"桶"的个数
• In-place:占用常数内存,不占用额外内存
• Out-place:占用额外内存
• 稳定性:排序后 2 个相等键值的顺序和排序之前它们的顺序相同
1、冒泡排序
void bsort(int a[], int len) {
if(len <= 0) return ;
for(int i = 0; i < len-1; i++) {
for(int j = 0; j < len-1-i; j++) {
if(a[j] > a[j+1]) {
std::swap(a[j], a[j+1]);
}
}
}
}
2、选择排序
void ssort(int a[], int len) {
if(len <= 0) return;
for(int i = 0; i < len-1; i++) {
int minpos = i;
for(int j = i+1; j < len; j++) {
if(a[minpos] > a[j]) {
minpos = j;
}
}
std::swap(a[minpos], a[i]);
}
}
3、插入排序
void isort(int a[], int len) {
if(len <= 0) return ;
for(int i = 1; i < len; i++) {
int key = a[i];
int j = i-1;
while(j >= 0 && a[j] > key) {
a[j+1] = a[j];
j--;
}
a[j+1] = key;
}
}
4、希尔排序
void shell_sort(int a[], int len) {
for(int h = len >> 1; h > 0; h >>= 1) {
for(int i = h; i < len; i++) {
int tmp = a[i];
int j = i - h;
while(j >= 0 && a[j] > tmp) {
a[j+h] = a[j];
j -= h;
}
a[j+h] = tmp;
}
}
}
5、归并排序
void msort(int a[], int len) {
if(!a || len<=0) {
return ;
}
int* p1 = a;
int* p2 = (int*)malloc(len*sizeof(int));
for(int seg = 1; seg < len; seg*=2) {
for(int start = 0; start < len; start += seg*2) {
int mid = std::min(start + seg, len);
int end = std::min(start + seg*2, len);
int s1 = start, s2 = mid;
int k = s1;
while(s1 < mid && s2 < end) {
p2[k++] = p1[s1] < p1[s2] ? p1[s1++] : p1[s2++];
}
while(s1 < mid) {
p2[k++] = p1[s1++];
}
while(s2 < end) {
p2[k++] = p1[s2++];
}
}
std::swap(p1, p2);
}
if(p2 == a) {
for(int i = 0; i < len; i++) {
p2[i] = p1[i];
}
p2 = p1;
}
free(p2);
}
6、快速排序
#include <iostream>
using namespace std;
void quick_sort(int a[], int low, int high) {
if(low >= high) return;
int i = low, j = high;
int pivot = a[i];
while(i < j) {
while(i < j && a[j] >= pivot) j--;
a[i] = a[j];
while(i < j && a[i] <= pivot) i++;
a[j] = a[i];
}
a[i] = pivot;
quick_sort(a, low, i-1);
quick_sort(a, i+1, high);
}
int main() {
int a[] = {1, 8, 4, 5, 2};
quick_sort(a, 0, 4);
for(int i = 0;i < 5;i++) {
cout << a[i] << endl;
}
return 0;
}
7、堆排序
#include<iostream>
void heapfy(int a[], int index, int heapsize) {
int left = index*2+1;
int right = left+1;
int largest = index;
if(left < heapsize && a[index] < a[left]) {
largest = left;
}
if(right < heapsize && a[largest] < a[right]) {
largest = right;
}
if(largest != index) {
std::swap(a[index], a[largest]);
heapfy(a, largest, heapsize);
}
}
void makeheap(int a[], int len) {
for(int i = len/2-1; i >= 0; i--) {
heapfy(a, i, len);
}
}
void heapsort(int a[], int len) {
makeheap(a, len);
for(int i = len-1; i > 0; i--) {
std::swap(a[0], a[i]);
heapfy(a, 0, i);
}
}
int main()
{
int a[10] = {9,3,4,5,1,8,0,2,7,6};
heapsort(a, 10);
return 0;
}
8、计数排序
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
void print_arr(int *arr, int n) {
int i;
printf("%d", arr[0]);
for (i = 1; i < n; i++)
printf(" %d", arr[i]);
printf("\n");
}
void counting_sort(int *ini_arr, int *sorted_arr, int n) {
int *count_arr = (int *) malloc(sizeof(int) * 100);
int i, j, k;
for (k = 0; k < 100; k++)
count_arr[k] = 0;
for (i = 0; i < n; i++)
count_arr[ini_arr[i]]++;
for (k = 1; k < 100; k++)
count_arr[k] += count_arr[k - 1];
for (j = n; j > 0; j--)
sorted_arr[--count_arr[ini_arr[j - 1]]] = ini_arr[j - 1];
free(count_arr);
}
int main(int argc, char **argv) {
int n = 10;
int i;
int *arr = (int *) malloc(sizeof(int) * n);
int *sorted_arr = (int *) malloc(sizeof(int) * n);
srand(time(0));
for (i = 0; i < n; i++)
arr[i] = rand() % 100;
printf("ini_array: ");
print_arr(arr, n);
counting_sort(arr, sorted_arr, n);
printf("sorted_array: ");
print_arr(sorted_arr, n);
free(arr);
free(sorted_arr);
return 0;
}
9、桶排序
// C++ program to sort an array using bucket sort
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
// Function to sort arr[] of size n using bucket sort
void bucketSort(float arr[], int n)
{
// 1) Create n empty buckets
vector<float> b[n];
// 2) Put array elements in different buckets
for (int i=0; i<n; i++)
{
int bi = n*arr[i]; // Index in bucket
b[bi].push_back(arr[i]);
}
// 3) Sort individual buckets
for (int i=0; i<n; i++)
sort(b[i].begin(), b[i].end());
// 4) Concatenate all buckets into arr[]
int index = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < b[i].size(); j++)
arr[index++] = b[i][j];
}
/* Driver program to test above funtion */
int main()
{
float arr[] = {0.897, 0.565, 0.656, 0.1234, 0.665, 0.3434};
int n = sizeof(arr)/sizeof(arr[0]);
bucketSort(arr, n);
cout << "Sorted array is \n";
for (int i=0; i<n; i++)
cout << arr[i] << " ";
return 0;
}
10、基数排序
int maxbit(int data[], int n) //辅助函数,求数据的最大位数
{
int maxData = data[0]; ///< 最大数
/// 先求出最大数,再求其位数,这样有原先依次每个数判断其位数,稍微优化点。
for (int i = 1; i < n; ++i)
{
if (maxData < data[i])
maxData = data[i];
}
int d = 1;
int p = 10;
while (maxData >= p)
{
//p *= 10; // Maybe overflow
maxData /= 10;
++d;
}
return d;
/* int d = 1; //保存最大的位数
int p = 10;
for(int i = 0; i < n; ++i)
{
while(data[i] >= p)
{
p *= 10;
++d;
}
}
return d;*/
}
void radixsort(int data[], int n) //基数排序
{
int d = maxbit(data, n);
int *tmp = new int[n];
int *count = new int[10]; //计数器
int i, j, k;
int radix = 1;
for(i = 1; i <= d; i++) //进行d次排序
{
for(j = 0; j < 10; j++)
count[j] = 0; //每次分配前清空计数器
for(j = 0; j < n; j++)
{
k = (data[j] / radix) % 10; //统计每个桶中的记录数
count[k]++;
}
for(j = 1; j < 10; j++)
count[j] = count[j - 1] + count[j]; //将tmp中的位置依次分配给每个桶
for(j = n - 1; j >= 0; j--) //将所有桶中记录依次收集到tmp中
{
k = (data[j] / radix) % 10;
tmp[count[k] - 1] = data[j];
count[k]--;
}
for(j = 0; j < n; j++) //将临时数组的内容复制到data中
data[j] = tmp[j];
radix = radix * 10;
}
delete []tmp;
delete []count;
}