九大基础排序算法总结
Posted yccy1230
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了九大基础排序算法总结相关的知识,希望对你有一定的参考价值。
九大基础排序算法小结
一直想做份总结,总是抽不出时间,趁着周末闲着直接用了一整天做一份,一些内容参考了网上的一些博主的总结,还有网络上的一些图片。
好了,接下来就看看内容吧!
排序算法:
排序方法 | 时间复杂度 | 空间复杂度 | 稳定性 | 选用情况 | ||
平均情况 | 最坏情况 | 最好情况 | ||||
Insertion Sort | O(n^2) | O(n^2) | O(n) | O(1) | 稳定 | n较小时 |
Selection Sort | O(n^2) | O(n^2) | O(n^2) | O(1) | 不稳定 | n较小时 |
Bubble Sort | O(n^2) | O(n^2) | O(n) | O(1) | 稳定 | n较小时 |
Shell Sort | O(nlog2n) | O(n^s) | O(nlog2n) | O(1) | 不稳定 | S是所选组数 |
Quick Sort | O(nlog2n) | O(n^2) | O(nlog2n) | O(nlog2n) | 不稳定 | n较大时 |
Merge Sort | O(nlog2n) | O(nlog2n) | O(nlog2n) | O(1) | 稳定 | n较大时 |
Heap Sort | O(nlog2n) | O(nlog2n) | O(nlog2n) | O(1) | 不稳定 | n较大时 |
Radix Sort | O((n+r)d) | O((n+r)d) | O((n+r)d) | O(n+r) | 稳定 | 位数少,数据量大 |
Tree Sort | O(nlog2n) | O(nlog2n) | O(nlog2n) | O(1) | (不允许出现重复数字) | 基本无序时 |
注:Radix Sort中n=数字个数; r=分配后链表的个数;d=数字或字符串的位数.
1.插入排序(Insertion Sort)
1)算法描述:
· Step1:将待排序数组分为有序和无序两组(初始情况下有序组为第一个元素) · Step2:取出无序组第一个元素(First_unsorted)放入临时空间,将first_unsorted与有序组从最后一个元素开始进行比较,如果比有序组小,则将有序组中的该元素向后移一位,直到找到第一个比first_unsorted小的时候,将first_unsorted放入。至此,有序组++,无序组--。 · Step3:重复step2,直到无序组数量为0.
算法结束。 |
2)适用情况分析:
· 稳定 · 数组,链表均可实现 · 空间复杂度O(1) · 时间复杂度O(n2) · 最差情况:反序,需要移动n*(n-1)/2个元素 · 最好情况:正序,不需要移动元素 · 数据量较小,较有序的情况下性能较好
|
3)参考代码:
顺序版本↓:
template<class List_entry>
void Sortable_List<List_entry>::insertion_sort()
{
List_entry current;
if (count == 0)return;
for (int first_unsorted = 1; first_unsorted < count; first_unsorted++) {
if (entry[first_unsorted] >= entry[first_unsorted - 1])continue;
current = entry[first_unsorted];
int position = first_unsorted;
do {
entry[position] = entry[position - 1];
position--;
} while (position > 0 && entry[position - 1] > current);
entry[position] = current;
}
}
链式版本↓:
template<class List_entry>
void Sortable_list<List_entry>::insertion_sort()
{
Node<List_entry> *first_unsorted, *last_sorted, *current, *previous;
if (head == NULL)return;
last_sorted = head;
while (last_sorted->next){
first_unsorted = last_sorted->next;
if (first_unsorted->entry < head->entry) {
last_sorted->next = first_unsorted->next;
first_unsorted->next = head;
head = first_unsorted;
}
else {
previous = head;
current = previous->next;
while (current->entry < first_unsorted->entry) {
previous = current;
current = current->next;
}
if (current == first_unsorted)last_sorted = first_unsorted;
else {
last_sorted->next = first_unsorted->next;
first_unsorted->next = current;
previous->next = first_unsorted;
}
}
}
}
2.选择排序(selection Sort)
1)算法描述:
· Step1:将待排序数组分为有序和无序两组(初始情况下有序组为空) · Step2:从左向右扫描无序组,找出最小的元素,将其放置在无序组的第一个位置。至此有序组++,无序组--; · Step3:重复Step2,直至无序组只剩下一个元素。
算法结束。 |
2)适用情况分析:
· 不稳定 · 数组,链表均可实现 · 空间复杂度:O(1) · 时间复杂度:O(n2) · 最坏情况:O(n2) 第一个元素为最大元素,其余元素正序,需要交换n-1个元素(如:4 3 2 1) · 最好情况:O(n2) 正序,不需要交换元素 · 选择排序的最坏情况和最好情况下的实际没有太大区别。即选择排序对于原始记录的顺序不敏感。
|
3)参考代码:
template<class List_entry>
void Sortable_List<List_entry>::selection_sort()
{
for (int i = 0; i < count - 1; i++) {
int min = min_key(i, count - 1);
swap(min, i);
}
}
template<class List_entry>
int Sortable_List<List_entry>::min_key(int low, int high)
{
int min = low;
for (int i = low + 1; i <= high; i++) {
if (entry[min] > entry[i])min = i;
}
return min;
}
template<class List_entry>
void Sortable_List<List_entry>::swap(int low, int high)
{
List_entry tmp = entry[low];
entry[low] = entry[high];
entry[high] = tmp;
}
3. 冒泡排序(Bubble Sort)
1)算法描述:
· Step1:比较相邻的元素。如果第一个比第二个大,就交换他们两个 · Step2:对每一对元素均进行此操作,经过一轮后最大的元素应位于最后一位 · Step3:从第一个元素重复进行前两步,每一轮最后一个元素都不参与比较,进行n轮 算法结束。 |
2)适用情况分析:
稳定 · 大部分采取顺序,链式也可实现 · 空间复杂度O(1) · 时间复杂度O(n2) · 数据顺序对算法影响不大 |
3)参考代码:
template<class List_entry>
void Sortable_List<List_entry>::bubble_sort()
{
for(int i=0;i<count;i++)
for (int j = 0 ; j < count-i-1; j++)
if (entry[j] > entry[j+1]) {
List_entry tmp = entry[j];
entry[j] = entry[j + 1];
entry[j + 1] = tmp;
}
}
4.希尔排序(Shell Sort)---插入排序的优化
1)算法描述:
· Step1:先将整个待排元素序列分割成若干个子序列(由相隔某个“增量”的元素组成的)分别进行直接插入排序 · Step2:依次缩减增量再进行排序 · Step3:待整个序列中的元素基本有序(增量足够小)时,再对全体元素进行一次直接插入排序
算法结束
因为直接插入排序在元素基本有序的情况下(接近最好情况),效率是很高的,因此希尔排序相较于前几种方法有较大的提升 |
2)适用情况分析:
· 不稳定 · 采取顺序实现,对下标敏感 · 空间复杂度O(1) · 时间复杂度O(nlogn) · 步长的选择是希尔排序的重要部分。只要最终步长为1任何步长序列都可以工作。 · Donald Shell 最初建议步长选择为N/2并且对步长取半直到步长达到1 · 已知的最好步长序列是由Sedgewick提出的(1, 5, 19, 41, 109,...) |
3)参考代码:
template<class List_entry>
void Sortable_List<List_entry>::shell_sort()
{
int increment = count;
do {
increment = increment / 3 + 1;
for (int start = 0; start < increment; start++)
sort_interval(start, increment);
} while (increment > 1);
}
template<class List_entry>
void Sortable_List<List_entry>::sort_interval(int start, int increment)
{
List_entry current;
int position;
for (int first_unsorted = start + increment; first_unsorted < count;
first_unsorted += increment) {
if (entry[first_unsorted] < entry[first_unsorted - increment]) {
position = first_unsorted;
current = entry[position];
do {
entry[position] = entry[position - increment];
position -= increment;
} while (position > start&&entry[position - increment] > current);
entry[position] = current;
}
}
}
在网络上看到了简化版本的shell sort,也可作参考:
void shellsort3(int a[], int n)
{
int i, j, gap;
for (gap = n / 2; gap > 0; gap /= 2)
for (i = gap; i < n; i++)
for (j = i - gap; j >= 0 && a[j] > a[j + gap]; j -= gap)
swap(a[j], a[j + gap]);
}
5.快速排序(Quick Sort)
1)算法描述:
· Step1:在待排序列中选取一个轴点(pivot),通常选取中间点 · Step2:将轴点与其他元素进行比较,将比轴点小的元素放在轴点之前,比轴点大的元素放在轴点之后。至此,pivot已被排好序 · Step3:对0-(pivot-1)和(pivot+1)-n分别递归进行上述两步。 算法结束。 |
2)适用情况分析:
· 不稳定。 · 顺序实现 · 空间复杂度:O(1) · 时间复杂度:O(nlog2n) · 最坏情况:O(n2)要排序数组基本有序,基准值每次取最大(最小)元素,退化为冒泡。 · 最好情况:O(nlog2n) 基准值两边元素个数基本相同. |
3)参考代码:
template<class List_entry>
void Sortable_List<List_entry>::quick_sort()
{
do_quick_sort(0, count - 1);
}
template<class List_entry>
void Sortable_List<List_entry>::do_quick_sort(int low, int high)
{
int pivot_position;
if (low < high) {
pivot_position = partition(low, high);
do_quick_sort(low, pivot_position - 1);
do_quick_sort(pivot_position + 1, high);
}
}
template<class List_entry>
int Sortable_List<List_entry>::partition(int low, int high)
{
List_entry pivot;
swap(low, (low + high) / 2); //将pivot放置到第一位
pivot = entry[low];
int last_small = low;
for (int i = low + 1; i <= high; i++)
if (entry[i] < pivot) swap(last_small++, i); //比pivot小的元素前移
swap(low, last_small); //将pivot放回
return last_small;
}
6.归并排序(Merge Sort)
1)算法描述:
Step1:把待排序的列表划分为分成近似相等的两部分 Step2:分别将两个子列表排序(递归进行) Step3:然后再合并成一个完整的列表 算法结束。 |
2)使用情况分析:
· 稳定 · 链式实现 · 空间复杂度:O(n) · 时间复杂度:O(nlog2n) · 最坏情况:O(nlog2n) · 最好情况:O(nlog2n) |
3)参考代码:
template<class List_entry>
void Sortable_list<List_entry>::mergesort(Sortable_list<List_entry> & list)
{
Sortable_list secondlist;
if (list.size() > 1) {
mergedivide(list, secondlist);
mergesort(list);
mergesort(secondlist);
mergecombine(list, secondlist);
}
}
template<class List_entry>
void Sortable_list<List_entry>::mergecombine(Sortable_list<List_entry> & firstlist, const Sortable_list<List_entry> & secondlist)
{
Sortable_list tmp;
List_entry x, y;
int n = 0, m = 0, i = 0;
while (n < firstlist.size() && m < secondlist.size()) {
firstlist.retrieve(n, x);
secondlist.retrieve(m, y);
if (x <= y) {
tmp.insert(i++, x);
n++;
}
else {
tmp.insert(i++, y);
m++;
}
}
while (n < firstlist.size()) {
firstlist.retrieve(n++, x);
tmp.insert(i++, x);
}
while (m < secondlist.size()) {
secondlist.retrieve(m++, y);
tmp.insert(i++, y);
}
firstlist = tmp;
}
template<class List_entry>
void Sortable_list<List_entry>::mergedivide(Sortable_list<List_entry>& firstlist, Sortable_list<List_entry>& secondlist)
{
int mid = (firstlist.size() - 1) / 2 + 1;
List_entry x;
for (int i = 0; firstlist.retrieve(mid, x)==success; i++) {
secondlist.insert(i, x);
firstlist.remove(mid, x);
}
}
7.堆排序(Heap Sort)
1)算法描述:
堆的定义:堆是一棵完全二叉树或者是近似完全二叉树。根结点(亦称为堆顶)的关键字是堆里所有结点关键字中最小者的堆称为小根堆,又称最小堆。根结点(亦称为堆顶)的关键字是堆里所有结点关键字中最大者,称为大根堆,又称最大堆。
· Step1:建堆,序列分成无序和有序两组(初始有序为0) · Step2:取出堆顶最大的元素,与待排序列的最后一个元素作交换,至此,无序组--,有序组++,并对无序组进行堆调整 · Step3:重复上述步骤,直至无序组仅剩一个元素 算法结束。 |
2)使用情况分析:
不稳定 顺序结构实现 时间复杂度:o(nlogn) 空间复杂度:o(1) 由于建初始堆所需的比较次数较多,不建议在数据量小的情况下使用 |
3)参考代码:
template<class List_entry>
void Sortable_List<List_entry>::heap_sort()
{
build_heap(); //建堆
for (int last_unsorted = count - 1; last_unsorted > 0; last_unsorted--) {
List_entry current = entry[last_unsorted];
entry[last_unsorted] = entry[0];
insert_heap(current, 0, last_unsorted - 1); //将最后一个元素插入堆中,获取下一个最值
}
}
template<class List_entry>
void Sortable_List<List_entry>::insert_heap(const List_entry & current, int low, int high)
{
int large = 2 * low + 1;
while (large <= high) {
if (large < high&&entry[large] < entry[large + 1])
large++; //将下标large调整为最大孩节点
if (entry[large] < current)break;
else { //promote entry[large]
entry[low] = entry[large];
low = large;
large = 2 * low + 1;
}
}
entry[low] = current;
}
template<class List_entry>
void Sortable_List<List_entry>::build_heap()
{
for (int low = count / 2 - 1; low >= 0; low--) {
List_entry current = entry[low];
insert_heap(current, low , count - 1);
}
}
8.基数排序(Radix Sort)
1)算法描述:
LSD: Step1:将待排序的元素按照最后一位进行分桶操作(桶按照最后一位排序从大到小) Step2:按顺序将各个桶中的数据连接起来,形成新的序列 Step3:依次对新序列的倒数第二位至第一位进行上述两步操作 算法结束
MSD: Step1:将待排序的元素按照最高位进行分桶操作 Step2:对每个桶的按照第二位进行再次分桶(递归进行) Step3:进行至最后一位分桶操作完成后,对每个桶进行合并操作,得到有序序列 算法结束 |
2)使用情况分析:
· 稳定 · 链式实现 · 时间复杂度:假设在基数排序中,r为基数,d为位数。则基数排序的时间复杂度为O(d(n+r)) · 空间复杂度:在基数排序过程中,对于任何位数上的基数进行“装桶”操作时,都需要n+r个临时空间 · 数据量大时有明显优势,通常使用LSD法 |
3)参考代码:
MSD:
int alphabetic_order(char c)
{
if (c == ' ' || c == '\\0') return 0;
if (c >= 'a'&&c <= 'z')return (c - 'a' + 1);
if (c >= 'A'&&c <= 'Z')return (c - 'A' + 1);
return 27;
}
void Sortable_list::rethread(queue<Record> queues[])
{
Record x;
for (int i = 0; i < max_char; i++)
while (!queues[i].empty()) {
x = queues[i].front();
insert(size(), x);
queues[i].pop();
}
}
void Sortable_list::MSD_radix_sort()
{
Record data;
queue<Record> queues;
while(remove(0,data)==success){
queues.push(data);
}
sort(queues, key_size);
}
LSD:
void Sortable_list::LSD_radix_sort()
{
Record data;
queue<Record> queues[max_char];
for (int position = key_size - 1; position >= 0; position--) {
// Loop from the least to the most significant position.
while (remove(0, data) == success) {
int queue_number = alphabetic_order(data.key_letter(position));
queues[queue_number].push(data); // Queue operation.
}
rethread(queues); // Reassemble the list.
}
}
9.树排序(Tree Sort)
1)算法描述:
对于一棵二叉查找树,中序遍历的序列即为有序序列。 因此,二叉查找树的插入过程也可以看成是排序的过程。即 · Step1:将无序序列逐一插入二叉排序树。 · Step2:对二叉排序树进行中序遍历 算法结束 |
2)适用情况分析:
· 不稳定 · 链式实现 · 时间复杂度:o(nlogn) · 空间复杂度:o(1) · Tree sort比较适合于无序的序列,对于基本有序的序列效率较低
|
3)参考代码:
template<class Record>
Error_code Binary_search_tree<Record>::c_insert(const Record & item)
{
Binary_node<Record> *&tmp=root;
if(!tmp)root = new Binary_node<Record>(item);
else {
while (tmp != NULL) {
if (tmp->data > item)tmp = tmp->left_child;
else if (tmp->data < item)tmp = tmp->right_child;
else return duplicate_error;
}
tmp = new Binary_node<Record>(item);
return success;
}
}
template<class Entry>
void Binary_tree<Entry>::recursive_inorder(Binary_node<Entry>* sub_root, void(*visit)(Entry &))
{
if (sub_root) {
recursive_inorder(sub_root->left_child,visit);
(*visit)(sub_root->data);
recursive_inorder(sub_root->right_child, visit);
}
}
template<class Entry>
void Binary_tree<Entry>::recursive_inorder(Binary_node<Entry>* sub_root, void(*visit)(Entry &))
{
if (sub_root) {
recursive_inorder(sub_root->left_child,visit);
(*visit)(sub_root->data);
recursive_inorder(sub_root->right_child, visit);
}
}
做的有些仓促,还望大家指正错误。
以上是关于九大基础排序算法总结的主要内容,如果未能解决你的问题,请参考以下文章