各种排序算法实现(一应俱全)

排序算法总结:

      特点

名称

时间复杂度

原理

稳定性

举例(3,1,4,5,2)

名次排序

O(n2)

先排出名次,再根据名次,将数据放入相应

的数组排序

稳定

名次是(3,1,4,5,2)

排序是(1,2,3,4,5)

冒泡排序

O(n2)

一次冒泡是从前面开始两两比较,如果前面大

后面数小就互换,共冒n次泡

稳定

一次冒泡:1,3,4,2,5

二次冒泡:1,3,2,4,5

三次冒泡:1,2,3,4,5

四次冒泡:1,2,3,4,5

五次冒泡:1,2,3,4,5

插入排序

O(n2)

第一个数据不动,将第二个与之比较,并插

入,第三个与前两个比较并插入....直到n个

稳定

插入第二个:1,3,4,5,2

插入第三个:1,3,4,5,2

插入第四个:1,3,4,5,2

插入第五个:1,2,3,4,5

选择排序

O(n2)

n个数中选择最大的放在最后,再在前n-1个

选择最大的放在倒数第二个...直到第一个.

稳定

第一次:3,1,4,2,5

第二次:3,1,2,4,5

第三次:1,2,3,4,5

第四次:1,2,3,4,5

基数排序

Θ(n)

按照基数r分为r个盒子,将符合条件的数据

放入相应链表盒子里,直到排序完成

稳定

一次:1,2,3,4,5

堆排序

O(nlogn)

利用最大堆排序,将数据初始化为最大堆,依次

删除最大元素,直到删完,排序完成

不稳定

删除5,删除4,删除3,

删除2,删除1,依次放入链表,

12345

拓扑排序

O(n2)

在由任务建立的有向图中,边(i,j)表示在装配

序列中任务i 在任务j  的前面,具有这种性质

的序列称为拓扑序列根据任务的有向图建立

拓扑序列的过程

稳定

快速排序

平均O(nlog2n)

最坏O(n2)

不断寻找一个序列的中点,然后对中点左右

的序列递归的进行排序,直至全部序列排序

完成,使用了分治的思想

稳定

第一次;1,3,4,5,2

第二次:1,3,4,2,5

第三次:1,2,3,4,5

归并排序

平均O(nlog2n)

最坏O(nlog2n)

将原序列划分为有序的两个序列,然后利用

归并算法进行合并,合并之后即为有序序列。

稳定

3,1  4,5,2

1,3  2,4,5

1, 2, 3 ,4, 5

可视化链接:https://visualgo.net/zh/sorting

1.插入排序:

与vector类型相比,数组的显著缺陷在于:数组的长度是固定的,而且程序员无法知道一个给定数组的长度。数组没有获取其容量大小的size操作。那么我们就可以用vector或数组array来实现这些操作。

思想与伪代码:

复杂度:最优:当输入数组就是排好序的时候,复杂度为O(n)。最差:当输入数组为倒序时,复杂度为O(n^2)

//插入排序,从小到大排序
void insert_sort(int arraylist[],int num) {
    int key;
    for (int j = 1; j< num; j++) {
        key = arraylist[j];
        int i = j - 1;
        while (i >= 0 && arraylist[i] > key) {
            arraylist[i + 1] = arraylist[i];
            i = i - 1;
        }
        arraylist[i + 1] = key;
    }
}

 

2.冒泡排序:

思想与伪代码:两两交换,后比前小就交换。复杂度:O(n^2)

//交换两个数
void swap(int* a, int* b) {
    int temp =* a;
    *a =* b;
    *b = temp;
}

void bubble_sort(int arraylist[],int num) {
    for (int j = 0; j < num; j++) {
        for (int i = num - 1; i >= j; i--) {
            if (arraylist[i] < arraylist[i - 1]) {
                swap(&arraylist[i],&arraylist[i - 1]);
            }
        }
    }
}

3.选择排序:

思想与伪代码:每次寻找最小值与当前位置交换。复杂度:O(n^2)

void select_sort(int arraylist[], int num) {
    for (int i = 0; i < num - 1; i++) {
        int min =i;
        for (int j = i + 1; j < num; j++) {
            if (arraylist[j] <arraylist[min]) {
                min = j;
            }
        }
        swap(&arraylist[min], &arraylist[i]);
    }
}

 

以上插入排序、冒泡排序、选择排序运行程序:

#include <iostream>
#include "1sort.h"
using namespace std;

int main() {
    const int num = 10;
    int array[] = {7,2,26,4,9,17,6,25,19,8};
    //insert_sort(array,num);
    //bubble_sort(array, num);
    select_sort(array,num);
    //打印结果
    for (int i = 0; i < num; i++) {
        cout << array[i] << "  ";
    }
    system("pause");
    return 0;
}

 

 

4.归并排序:

思想与伪代码:利用分治法思想排序。复杂度:O(nlgn) 

 

5.堆排序

堆排序其实是利用堆这种数据结构的一种选择排序,它的最坏,最好,平均时间复杂度均为O(nlogn),是不稳定排序。

一般情况下,升序排序用大根堆,降序排序用小根堆。

6.快速排序

7.基数排序

8.计数排序

9.桶排序

正在总结中。。

 

 


 

  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
几种常见排序 基于比较的排序算法: 下界是 nlgn 1.1 SelectionSort:每次选出最下的元素,放在当前循环最左边的位置。 1.2 BubbleSort:每次比较相邻的两个数,使得最大的数像气泡一样冒到最右边。 1. 3 InsertionSort:每次拿起一个数,插入到它左边数组的正确位置。 1.4 QuickSort:选择一个数,作为标准,小于它的放在左边,大于它的放在右边。并把它放在中间;递归地对左右子数组进行排序实现时:1. 确定递归结束条件,初始化左右游标, 选择标准数; 2. while循环,do while实现两个游标同时向中间移动,置换; 3. 置换标准数和右边游标所指的数; 4. 递归调用,对左右子数组进行排序。 1. 5 HeapSort:用最大堆实现实现时:建堆:置换堆顶元素和最后一个元素,堆大小减少,保持新的堆为最大堆; 保持最大堆: 从底向上依次保持最大堆,从第一个父节点到根部。 1.6 MergeSort:拆分数组,递归实现排序,二路归并。用哨兵来阻止游标的越界。 线性时间运行的算法: 1.7 CountingSort: 假设数据分布在0到k之间的。对于每个输入x,确定出小于x的数的个数。假设小于x的数有17个,那么x就应该在第18个输出位置。 1. 8 Radix sort(基数排序):从最低位开始,每位采用稳定的排序算法(如计数排序)。 1.9 Bucket sort:当输入数据比较均匀时采用。 先将数据区间分为n个桶,把数据分放到对应的桶中;对桶内的数据采用插入排序;再把各个桶的排序结果串起来。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

HelloHypatia

希望自己的总结对大家有所帮助!

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值