排序算法可以分为两大类：
非线性时间比较类排序
：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此称为非线性时间比较类排序。
线性时间非比较类排序
：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此称为线性时间非比较类排序。
相关概念：
稳定
：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。
不稳定
：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。
时间复杂度
：对排序数据的总的操作次数。反映当n变化时，操作次数呈现什么规律。
空间复杂度：
是指算法在计算机内执行时所需存储空间的度量，它也是数据规模n的函数。
一. 冒泡排序（BubbleSort）
- 算法思想
两个数比较大小，较大的数下沉，较小的数冒起来。
- 算法过程
- 比较相邻的元素，如果第一个比第二个数大，则交换两个数
- 从前到后针对每一对相邻的元素，进行比较和交换，直到可以把最大的一个数放到最后的位置
- 针对所有的元素重复以上步骤，上面步骤已经把每一次较大的数放到最后的除外
- 重复步骤1~3，直到排序完成，把最小的数据放在了最前面
- 代码实现
#include
<iostream>
using
namespace
std
;
/*************冒泡排序*************/
//最大时间代价，最小时间代价和平均时间代价均为θ(n²)
//交换函数，作用是交换数组中的两个元素的位置
void
swap
(
int
array
[],
int
i
,
int
j
)
{
int
tmp
=
array
[
i
];
array
[
i
]
=
array
[
j
];
array
[
j
]
=
tmp
;
}
void
BubbleSort
(
int
array
[],
int
n
)
{
for
(
int
i
=
0
;
i
<
n
-
1
;
i
++)
{
for
(
int
j
=
n
-
1
;
j
>
i
;
j
--)
{
if
(
array
[
j
]<
array
[
j
-
1
])
swap
(
array
,
j
,
j
-
1
);
}
}
}
int
main
()
{
int
array
[
5
]
=
{
3
,
1
,
2
,
5
,
4
};
BubbleSort
(
array
,
5
);
for
(
int
i
=
0
;
i
<
5
;
i
++)
cout
<<
array
[
i
]
<<
" "
;
cout
<<
endl
;
system
(
"pause"
);
return
0
;
}
- 优化
针对问题：数据的顺序排好之后，冒泡算法仍然会继续下一轮的比较，直到Length-1次，后面的比较是没有意义的。
方案：放置标志位flag，如果发生了交换flag为1，如果没有交换flag为0。这样当一轮之后如果flag仍为0，即 这一轮没有数据发生交换，说明数据的顺序已经排好，没有必要再继续进行下去。
#include
<iostream>
using
namespace
std
;
/*************冒泡排序*************/
//最大时间代价，最小时间代价和平均时间代价均为θ(n²)
//交换函数，作用是交换数组中的两个元素的位置
void
swap
(
int
array
[],
int
i
,
int
j
)
{
int
tmp
=
array
[
i
];
array
[
i
]
=
array
[
j
];
array
[
j
]
=
tmp
;
}
void
BubbleSort
(
int
array
[],
int
n
)
{
int flag = 0;
for
(
int
i
=
0
;
i
<
n
-
1
;
i
++)
{
flag = 0;
for
(
int
j
=
n
-
1
;
j
>
i
;
j
--)
{
if
(
array
[
j
]<
array
[
j
-
1
])
swap
(
array
,
j
,
j
-
1
);
flag = 1;
}
if(!flag) //如果flag一直为0，则说明排序已完成
break;
}
}
int
main
()
{
int
array
[
5
]
=
{
3
,
1
,
2
,
5
,
4
};
BubbleSort
(
array
,
5
);
for
(
int
i
=
0
;
i
<
5
;
i
++)
cout
<<
array
[
i
]
<<
" "
;
cout
<<
endl
;
system
(
"pause"
);
return
0
;
}
二. 选择排序(SelectSort)
- 算法思想
首先在未排序序列中找到最小（大）的元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，
然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
- 算法过程
n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：
- 初始状态：无序区为R[1..n]，有序区为空；
- 第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1..i-1]和R[i..n]。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R[i+1..n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
- n-1趟结束，数组有序化了。
- 代码实现
/*************选择排序*************/
//最大时间代价，最小时间代价和平均时间代价均为θ(n²)
//交换函数，作用是交换数组中的两个元素的位置
void
swap
(
int
array
[],
int
i
,
int
j
)
{
int
tmp
=
array
[
i
];
array
[
i
]
=
array
[
j
];
array
[
j
]
=
tmp
;
}
//选择排序
void
SelectionSort
(
int
array
[],
int
n
)
{
for
(
int
i
=
0
;
i
<
n
-
1
;
i
++)
{
int
smallest
=
i
;
for
(
int
j
=
i
+
1
;
j
<
n
;
j
++)
{
if
(
array
[
smallest
]>
array
[
j
])
smallest
=
j
;
}
swap
(
array
,
i
,
smallest
);
}
}
int
main
()
{
int
array
[
5
]
=
{
3
,
1
,
2
,
5
,
4
};
SelectionSort
(
array
,
5
);
for
(
int
i
=
0
;
i
<
5
;
i
++)
cout
<<
array
[
i
]
<<
" "
;
cout
<<
endl
;
system
(
"pause"
);
return
0
;
}
- 算法分析
表现最稳定的排序算法之一，因为无论什么数据进去都是O(n
2
)的时间复杂度，所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。理论上讲，选择排序可能也是平时排序一般人想到的最多的排序方法了吧。
三.插入排序(InsertionSort)
- 算法思想
在要排序的一组数中，假定前n-1个数已经排好序，现在将第n个数插到前面的有序数列中，使得这n个数也是排好顺序的。如此反复循环，直到全部排好顺序。
- 算法过程
一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：
- 从第一个元素开始，该元素可以认为已经被排序；
- 取出下一个元素，在已经排序的元素序列中从后向前扫描；
- 如果该元素（已排序）大于新元素，将该元素移到下一位置；
- 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
- 将新元素插入到该位置后；
- 重复步骤2~5。
- 代码实现
#include
<iostream>
using
namespace
std
;
/*************插入排序*************/
//最大时间代价为θ(n²)，最小时间代价为θ(n)，平均时间代价为θ(n²)
//交换函数，作用是交换数组中的两个元素的位置
void
swap
(
int
array
[],
int
i
,
int
j
)
{
int
tmp
=
array
[
i
];
array
[
i
]
=
array
[
j
];
array
[
j
]
=
tmp
;
}
//插入排序
void
InsertSort
(
int
array
[],
int
n
)
{
for
(
int
i
=
1
;
i
<
n
;
i
++)
{
for
(
int
j
=
i
;
j
>
0
;
j
--)
{
if
(
array
[
j
]>
array
[
j
-
1
])
swap
(
array
,
j
,
j
-
1
);
else
break
;
}
}
}
int
main
()
{
int
array
[
5
]
=
{
3
,
1
,
2
,
5
,
4
};
InsertSort
(
array
,
5
);
for
(
int
i
=
0
;
i
<
5
;
i
++)
cout
<<
array
[
i
]
<<
" "
;
cout
<<
endl
;
system
(
"pause"
);
return
0
;
}
- 算法分析
插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。
四.希尔排序(ShellSort)
- 算法思想
1959年Shell发明，第一个突破O(n
2
)的排序算法，是简单插入排序的改进版。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫
缩小增量排序
。
在要排序的一组数中，根据某一增量分为若干子序列，并对子序列分别进行插入排序。
然后逐渐将增量减小,并重复上述过程。直至增量为1,此时数据序列基本有序,最后进行插入排序。
- 算法过程
先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：
- 选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
- 按增量序列个数k，对序列进行k 趟排序；
- 每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
- 代码实现
/*************希尔排序*************/
//增量为2的shell排序的时间代价可以达到θ(n的3/2次方)，有的增量可以达到θ(n的7/6次方)，很接近θ(n)。
//交换函数，作用是交换数组中的两个元素的位置
void
swap
(
int
array
[],
int
i
,
int
j
)
{
int
tmp
=
array
[
i
];
array
[
i
]
=
array
[
j
];
array
[
j
]
=
tmp
;
}
//希尔排序
void
ShellSort
(
int
array
[],
int
n
)
{
for
(
int
delta
=
n
/
2
;
delta
>
0
;
delta
/=
2
)
{
for
(
int
i
=
0
;
i
<
delta
;
i
++)
{
for
(
int
j
=
i
+
delta
;
j
<
n
;
j
+=
delta
)
{
for
(
int
k
=
j
;
k
>
0
;
k
-=
delta
)
{
if
(
array
[
k
]<
array
[
k
-
1
])
swap
(
array
,
k
,
k
-
1
);
}
}
}
}
}
int
main
()
{
int
array
[
8
]
=
{
6
,
8
,
7
,
3
,
1
,
2
,
5
,
4
};
ShellSort
(
array
,
8
);
for
(
int
i
=
0
;
i
<
8
;
i
++)
cout
<<
array
[
i
]
<<
" "
;
cout
<<
endl
;
system
(
"pause"
);
return
0
;
}
- 算法分析
希尔排序的核心在于间隔序列的设定。既可以提前设定好间隔序列，也可以动态的定义间隔序列。动态定义间隔序列的算法是《算法（第4版）》的合著者Robert Sedgewick提出的
五.归并排序(MergeSort)
- 算法思想
归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。
- 算法过程
- 把长度为n的输入序列分成两个长度为n/2的子序列；
- 对这两个子序列分别采用归并排序；
- 将两个排序好的子序列合并成一个最终的排序序列。
- 代码实现
/*************归并排序*************/
/*归并过程--将两个有序数组合并成一个有序数组*/
#define
INF
100000000
//定义哨兵元素的值，待排序的元素值应小于此值
void
merge
(
int
*
A
,
int
p
,
int
q
,
int
r
)
{
int
n1
=
q
-
p
+
1
;
//p 到 q的元素个数
int
n2
=
r
-
q
;
// q+1 到 r的元素个数
int
*
p1
=
new
int
[
n1
+
1
];
//每个动态数组的最后一位用于存放哨兵元素。
int
*
p2
=
new
int
[
n2
+
1
];
for
(
int
i
=
0
;
i
<
n1
;
i
++)
p1
[
i
]
=
A
[
p
+
i
];
for
(
int
i
=
0
;
i
<
n2
;
i
++)
p2
[
i
]
=
A
[
q
+
i
+
1
];
p1
[
n1
]
=
INF
;
p2
[
n2
]
=
INF
;
int
i
=
0
,
j
=
0
;
for
(
int
k
=
p
;
k
<=
r
;
k
++)
{
if
(
p1
[
i
]
<=
p2
[
j
])
{
A
[
k
]
=
p1
[
i
];
i
++;
}
else
{
A
[
k
]
=
p2
[
j
];
j
++;
}
}
}
void
merge_sort
(
int
*
A
,
int
p
,
int
r
)
{
if
(
p
<
r
)
{
int
q
=
(
p
+
r
)
/
2
;
merge_sort
(
A
,
p
,
q
);
merge_sort
(
A
,
q
+
1
,
r
);
merge
(
A
,
p
,
q
,
r
);
}
}
int
main
()
{
int
A
[
10
]
=
{
5
,
6
,
7
,
9
,
8
,
4
,
2
,
3
,
1
,
0
};
int
p
=
0
,
r
=
9
;
merge_sort
(
A
,
p
,
r
);
for
(
int
i
=
0
;
i
<=
r
;
i
++)
cout
<<
A
[
i
]
<<
","
;
cout
<<
endl
;
system
(
"pause"
);
return
0
;
}
- 算法分析
归并排序是一种稳定的排序方法。和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是O(nlogn）的时间复杂度。代价是需要额外的内存空间。
六.快速排序(QuickSort)
- 算法思想
快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
- 算法过程
快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：
- 从数列中挑出一个元素，称为 “基准”（pivot）；
- 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
- 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
- 代码实现
/*************快速排序*************/
//最大时间代价为θ(n²)，最小时间代价为θ(n*logn)，平均时间代价为θ(n*logn)
void
Qsort
(
int
a
[],
int
low
,
int
high
)
{
if
(
low
>=
high
)
{
return
;
}
int
first
=
low
;
int
last
=
high
;
int
key
=
a
[
first
];
/*用字表的第一个记录作为枢轴*/
while
(
first
<
last
)
{
while
(
first
<
last
&&
a
[
last
]
>=
key
)
{
--
last
;
}
a
[
first
]
=
a
[
last
];
/*将比第一个小的移到低端*/
while
(
first
<
last
&&
a
[
first
]
<=
key
)
{
++
first
;
}
a
[
last
]
=
a
[
first
];
/*将比第一个大的移到高端*/
}
a
[
first
]
=
key
;
/*枢轴记录到位*/
Qsort
(
a
,
low
,
first
-
1
);
Qsort
(
a
,
first
+
1
,
high
);
}
int
main
()
{
int
a
[]
=
{
57
,
68
,
59
,
52
,
72
,
28
,
96
,
33
,
24
};
Qsort
(
a
,
0
,
sizeof
(
a
)
/
sizeof
(
a
[
0
])
-
1
);
for
(
int
i
=
0
;
i
<
sizeof
(
a
)
/
sizeof
(
a
[
0
]);
i
++)
{
cout
<<
a
[
i
]
<<
" "
;
}
system
(
"pause"
);
return
0
;
}
七.堆排序(HeapSort)
- 算法思想
堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。
- 算法过程
- 将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区；
- 将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n]；
- 由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。
- 代码实现
MaxHeap.h
#include
<iostream>
using
namespace
std
;
/*************堆排序*************/
/*最大堆定义*/
class
MaxHeap
{
private
:
int
size
;
//最大堆的元素数目
int
*
array
;
//最大堆数组的首地址指针
public
:
MaxHeap
(
int
array
[],
int
n
);
//用已有数组初始化一个最大堆
void
buildHeap
();
//构建最大堆
void
siftDown
(
int
index
);
//向下筛选法
void
swap
(
int
index1
,
int
index2
);
//交换位置为index1与index2的元素
void
removeMax
();
//删除堆顶的最大值--与数组最后一个元素交换位置并重新构建最大堆
int
leftChild
(
int
index
);
//返回左孩子的位置
int
rightChild
(
int
index
);
//返回右孩子的位置
};
Maxheap.cpp
#include
<iostream>
#include
"MaxHeap.h"
using
namespace
std
;
/*************堆排序*************/
/*最大堆成员函数实现*/
MaxHeap
::
MaxHeap
(
int
array
[],
int
n
)
{
this
->
array
=
array
;
size
=
n
;
buildHeap
();
}
void
MaxHeap
::
buildHeap
()
{
for
(
int
i
=
size
/
2
-
1
;
i
>=
0
;
i
--)
siftDown
(
i
);
}
void
MaxHeap
::
siftDown
(
int
index
)
{
int
max_index
=
leftChild
(
index
);
while
(
max_index
<
size
)
{
if
(
max_index
<
size
-
1
&&
array
[
rightChild
(
index
)]>
array
[
max_index
])
max_index
++;
if
(
array
[
index
]>
array
[
max_index
])
break
;
swap
(
index
,
max_index
);
index
=
max_index
;
max_index
=
leftChild
(
index
);
}
}
void
MaxHeap
::
swap
(
int
index1
,
int
index2
)
{
int
temp
=
array
[
index1
];
array
[
index1
]
=
array
[
index2
];
array
[
index2
]
=
temp
;
}
void
MaxHeap
::
removeMax
()
{
swap
(
0
,
size
-
1
);
size
--;
siftDown
(
0
);
}
int
MaxHeap
::
leftChild
(
int
index
)
{
return
index
*
2
+
1
;
}
int
MaxHeap
::
rightChild
(
int
index
)
{
return
index
*
2
+
2
;
}
main.cpp
/*************堆排序*************/
#include "MaxHeap.h"
//最大堆排序函数
void heapSort(int array[], int n)
{
MaxHeap max_heap = MaxHeap(array, n);
//删除堆的最大值（堆顶），即每次将最大值与数组的最后一个元素交换位置
for (int i = 0; i<7; i++)
max_heap.removeMax();
}
int main()
{
int array[8] = { 4, 3, 7, 1, 2, 8, 5, 6 };
heapSort(array, 8);
for (int i = 0; i<8; i++)
cout << array[i] << " ";
cout << endl;
system("pause");
return 0;
}
八.计数排序(CountingSort)
- 算法思想
计数排序不是基于比较的排序算法，其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。 作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。
- 算法过程
- 找出待排序的数组中最大和最小的元素；
- 统计数组中每个值为i的元素出现的次数，存入数组C的第i项；
- 对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；
- 反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。
- 代码实现
function countingSort(arr, maxValue) {
var
bucket =
new
Array(maxValue + 1),
sortedIndex = 0;
arrLen = arr.length,
bucketLen = maxValue + 1;
for
(
var
i = 0; i < arrLen; i++) {
if
(!bucket[arr[i]]) {
bucket[arr[i]] = 0;
}
bucket[arr[i]]++;
}
for
(
var
j = 0; j < bucketLen; j++) {
while
(bucket[j] > 0) {
arr[sortedIndex++] = j;
bucket[j]--;
}
}
return
arr;
}
- 算法分析
计数排序是一个稳定的排序算法。当输入的元素是 n 个 0到 k 之间的整数时，时间复杂度是O(n+k)，空间复杂度也是O(n+k)，其排序速度快于任何比较排序算法。当k不是很大并且序列比较集中时，计数排序是一个很有效的排序算法。
九.桶排序(BucketSort)
- 算法思想
桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。桶排序 (Bucket sort)的工作的原理：假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排）。
- 算法过程
- 设置一个定量的数组当作空桶；
- 遍历输入数据，并且把数据一个一个放到对应的桶里去；
- 对每个不是空的桶进行排序；
- 从不是空的桶里把排好序的数据拼接起来。
- 代码实现
function bucketSort(arr, bucketSize) {
if
(arr.length === 0) {
return
arr;
}
var
i;
var
minValue = arr[0];
var
maxValue = arr[0];
for
(i = 1; i < arr.length; i++) {
if
(arr[i] < minValue) {
minValue = arr[i];
// 输入数据的最小值
}
else
if
(arr[i] > maxValue) {
maxValue = arr[i];
// 输入数据的最大值
}
}
// 桶的初始化
var
DEFAULT_BUCKET_SIZE = 5;
// 设置桶的默认数量为5
bucketSize = bucketSize || DEFAULT_BUCKET_SIZE;
var
bucketCount = Math.floor((maxValue - minValue) / bucketSize) + 1;
var
buckets =
new
Array(bucketCount);
for
(i = 0; i < buckets.length; i++) {
buckets[i] = [];
}
// 利用映射函数将数据分配到各个桶中
for
(i = 0; i < arr.length; i++) {
buckets[Math.floor((arr[i] - minValue) / bucketSize)].push(arr[i]);
}
arr.length = 0;
for
(i = 0; i < buckets.length; i++) {
insertionSort(buckets[i]);
// 对每个桶进行排序，这里使用了插入排序
for
(
var
j = 0; j < buckets[i].length; j++) {
arr.push(buckets[i][j]);
}
}
return
arr;
}
十.基数排序(RadixSort)
- 算法思想
基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。
- 算法过程
- 取得数组中的最大数，并取得位数；
- arr为原始数组，从最低位开始取每个位组成radix数组；
- 对radix进行计数排序（利用计数排序适用于小范围数的特点）；
- 代码实现
/*基数排序*/
void
RadixSort
(
int
array
[],
int
size
)
{
int
bucket
[
10
][
10
]
=
{
0
};
//定义基数桶
int
order
[
10
]
=
{
0
};
//保存每个基数桶之中的元素个数
int
key_size
=
KeySize
(
array
,
size
);
//计算关键字位数的最大值
for
(
int
n
=
1
;
key_size
>
0
;
n
*=
10
,
key_size
--)
{
/*将待排序的元素按照关键值的大小依次放入基数桶之中*/
for
(
int
i
=
0
;
i
<
size
;
i
++)
{
int
lsd
=
(
array
[
i
]
/
n
)
%
10
;
bucket
[
lsd
][
order
[
lsd
]]
=
array
[
i
];
order
[
lsd
]++;
}
/*将基数桶中的元素重新串接起来*/
int
k
=
0
;
for
(
int
i
=
0
;
i
<
10
;
i
++)
{
if
(
order
[
i
]
!=
0
)
{
for
(
int
j
=
0
;
j
<
order
[
i
];
j
++)
{
array
[
k
]
=
bucket
[
i
][
j
];
k
++;
}
order
[
i
]
=
0
;
}
}
}
}
int
main
()
{
int
array
[
10
]
=
{
73
,
22
,
93
,
43
,
55
,
14
,
28
,
65
,
39
,
81
};
int
size
=
sizeof
(
array
)
/
sizeof
(
int
);
RadixSort
(
array
,
size
);
for
(
int
i
=
0
;
i
<
size
;
i
++)
cout
<<
array
[
i
]
<<
" "
;
cout
<<
endl
;
system
(
"pause"
);
return
0
;
}
- 算法分析
基数排序基于分别排序，分别收集，所以是稳定的。但基数排序的性能比桶排序要略差，每一次关键字的桶分配都需要O(n)的时间复杂度，而且分配之后得到新的关键字序列又需要O(n)的时间复杂度。假如待排数据可以分为d个关键字，则基数排序的时间复杂度将是O(d*2n) ，当然d要远远小于n，因此基本上还是线性级别的。
基数排序的空间复杂度为O(n+k)，其中k为桶的数量。一般来说n>>k，因此额外空间需要大概n个左右。
参考资料：
- 十大经典排序算法 https://www.cnblogs.com/onepixel/articles/7674659.html
- 排序算法总结 http://www.runoob.com/w3cnote/sort-algorithm-summary.html
扫一扫
2727
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
