4.排序算法

最新推荐文章于 2023-05-21 16:27:15 发布
最新推荐文章于 2023-05-21 16:27:15 发布
阅读量121 收藏
点赞数
分类专栏： 基础算法 文章标签： 算法 数据结构 排序算法 快速排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nodd_le/article/details/115418757
版权

排序算法

排序算法是能将一串数据依照特定排序方式进行排列的算法。排序算法在工程中有大量的应用，也是很多基于有序性的算法的前提。

稳定排序

对于一个排序算法，如果任意两个元素a[i]和a[j]在排序前的线性表中满足i < j且a[i] = a[j]，在排序后a[i]仍在a[j]之前，则称这个排序算法为 稳定排序(stable sort)。

插入排序

插入排序是一种非常直观的排序算法，它的基本思路是将线性表分为已排序的前半部分和待排序的后半部分，从待排序部分选出第一个元素，插入到已排序部分的对应位置中，直到全部记录都插入到已排序部分中。

插入排序每次插入的时间复杂度为 O(n)，一共执行n-1次，因此总体时间复杂度为O(n2)。在插入时查找插入的过程可以使用折半查找算法将查找位置的复杂度优化到O(log n)，但因为还需要O(n)的时间复杂度来在顺序表上执行移动操作，所以总体的时间复杂都依然是O(n2)。

  1. 将数组分成“已排序区”和“待排序区”
  2. 将“已排序区”第一个元素，向前插入到“待排序区”中
  3. 直到“待排序区”没有元素为止
/*************************************************************************
  > File Name: 6.insertion_sort.c
  > Author: 陈杰
  > Mail: 15193162746@163.com
  > Created Time: 2021年04月03日 星期六 14时07分42秒
> 插入排序法
************************************************************************/
#include<stdio.h>
#include <stdlib.h>
#include <time.h>
/*交换算法*/
#define swap(a, b) {\
    __typeof(a) _temp = a;\
    a = b, b = _temp;\
}
/*
* 插入排序法
* @param data: 要排序的数组序列指针
* @param length: 序列长度
* */
void insertion_sort(int *data, int length) {
    for(int i = 1; i < length; i++) {
        for(int j = i; j > 0; j--) {
            if(data[j] < data[j - 1]) {
                swap(data[j], data[j-1]);
            }else break;
        }
    }
}
/*
* 打印数组
* @param data: 要排序的数组序列指针
* @param length: 序列长度
* */
void output(int *data, int length) {
    for(int i = 0; i < length; i++) {
        i == 0 || printf(" ");
        printf("%2d", data[i]);
    }
    printf("\n");
}
int main() {
    srand(time(0));
    #define MAX_N 20
    int num[MAX_N];
    for(int i = 0; i < MAX_N; i++) num[i] = rand() % 100;
    output(num, MAX_N);
    insertion_sort(num, MAX_N);
    output(num, MAX_N);
    #undef MAX_N
    return 0;
}
冒泡排序

和插入排序算法不同，冒泡排序算法是一种基于交换的排序算法。基于交换的排序，是指根据线性表中两个元素关键字的比较结果来对换这两个元素在序列中的位置。

冒泡排序算法的基本思想为：假如待排序线性表的长度为n，从前往后两两比较相邻元素的关键字，若a[i-1] > a[i]，则交换他们，直到线性表比较完成。每趟交换以后最后一个元素一定是最大的，不再参与下一趟交换。也就是对于第i趟交换，只需要比较到a[n-i]即可。直到一趟比较内没有进行交换，算法结束。时间复杂度和插入排序一样，也为O(n2)。

  1. 将数组分成“已排序区”和“待排序区”
  2. 从头到尾扫描“待排序区”，若前面元素比后面元素大，则交换
  3. 每一轮都会将“待排序区”中最大的放到“已排序区”的开头
  4. 直到“待排序区”没有元素为止
/*************************************************************************
> File Name: 6.insertion_sort.c
> Author: 陈杰
> Mail: 15193162746@163.com
> Created Time: 2021年04月03日 星期六 14时07分42秒
> 冒泡排序法
************************************************************************/
#include<stdio.h>
#include <stdlib.h>
#include <time.h>
/*交换算法*/
#define swap(a, b) {\
    __typeof(a) _temp = a;\
    a = b, b = _temp;\
}
/*
* 冒泡排序法
* @param data: 要排序的数组序列指针
* @param length: 序列长度
* */
void bubble_sort(int *data, int length) {
    for(int i = 0; i < length - 1; i++) {
        int swapped = 0;
        for(int j = 0; j < length - i - 1; j++) {
            if(data[j] > data[j + 1]) {
                swapped = 1;
                swap(data[j], data[j + 1]);
            }
        }
        if(!swapped) break;                         // 未交换，说明待排序区的元素已经有序
    }
}
/*
* 打印数组
* @param data: 要排序的数组序列指针
* @param length: 序列长度
* */
void output(int *data, int length) {
    for(int i = 0; i < length; i++) {
        i == 0 || printf(" ");
        printf("%2d", data[i]);
    }
    printf("\n");
}
int main() {
    srand(time(0));
    #define MAX_N 20
    int num[MAX_N];
    for(int i = 0; i < MAX_N; i++) num[i] = rand() % 100;
    output(num, MAX_N);
    bubble_sort(num, MAX_N);
    output(num, MAX_N);
    #undef MAX_N
    return 0;
}
归并排序

归并的意思是将两个有序的线性表组合成一个新的有序线性表。对于归并排序，若当前要排序的区间为a[0]...a[n-1]，则首先让a[0]...a[(n-1)/2]和a[(n-1)/2+1] ... a[n-1]这两个区间内的元素有序，再将这两个区间合并成一个更大的有序区间，直到整个线性表都被排序完成。

归并排序一共需要进行O(log n)层归并操作，每层归并操作的总时间复杂度为O(n)，英雌总体的时间复杂度为O(n log n)。和其他排序有所不同，为了实现归并操作，每次合并都需要开辟额外的空间来临时保存合并后的排序结果，总共需要开辟n个元素的空间，所以归并排序的空间复杂度为O(n)。

/*************************************************************************
	> File Name: 6.merge_sort.c
	> Author: 陈杰
	> Mail: 15193162746@163.com
	> Created Time: 2021年04月03日 星期六 14时07分42秒
  > 归并排序法
************************************************************************/
#include<stdio.h>
#include <stdlib.h>
#include <time.h>
/*
* 归并排序法
* @param data: 要排序的数组序列指针
* @param left: 排序开始位置
* @param right: 数组结束位置
* */
void merge_sort(int *data, int left, int right) {
    if(left == right) return;
    int mid = (left + right) / 2;
    // 大数组分为两个小数组进行排序
    merge_sort(data, left, mid);
    merge_sort(data, mid + 1, right);
    // 数组合并到新数组中
    int temp[right - left + 1];
    int x = left, y = mid + 1, loc = 0;     // 两个数组及新数组的指针
    while(x <= mid || y <= right) {
        if(x <= mid && (y > right || data[x] <= data[y])) temp[loc++] = data[x++];
        else temp[loc++] = data[y++];
    }
    // 数组拷贝
    for(int i = left; i <= right; ++i) data[i] = temp[i - left];
}
/*
* 打印数组
* @param data: 要排序的数组序列指针
* @param length: 序列长度
* */
void output(int *data, int length) {
    for(int i = 0; i < length; i++) {
        i == 0 || printf(" ");
        printf("%2d", data[i]);
    }
    printf("\n");
}
int main() {
    srand(time(0));
    #define MAX_N 20
    int num[MAX_N];
    for(int i = 0; i < MAX_N; i++) num[i] = rand() % 100;
    output(num, MAX_N);
    merge_sort(num, 0, MAX_N-1);
    output(num, MAX_N);
    #undef MAX_N
    return 0;
}

不稳定排序

对于一个排序算法，如果任意两个元素a[i]和a[j]在排序前的线性表中满足i < j且a[i] = a[j]，在排序后a[i]并不一定a[j]之前，则称这个排序算法为 不稳定排序(unstable sort)

选择排序

选择排序的思想是，每趟从线性排序区域选取关键字最小的元素，将其放到已排序区域的最后。因为每趟可以让待排序区域的元素数了减少一个，所以总共需要n - 1趟操作就可以将整个线性表排序完成。很显然，选择排序的时间复杂度也是 O(n2)。

在每次查找关键字最小的元素时，可以使用堆对效率进行优化，使用堆来优化的选择排序就是堆排序。由于一共要查找n次最小值，每次查找的时间为O(log n)，所以堆排序的时间复杂度为O(nlogn)。

  1. 将数组分成“已排序区”和“待排序区”
  2. 每一轮从“待排序区”中选择一个最小的元素放到“已排序区”的尾部
  3. 直到“待排序区”为空
/*************************************************************************
	> File Name: 6.selection_sort.c
	> Author: 陈杰
	> Mail: 15193162746@163.com
	> Created Time: 2021年04月03日 星期六 14时07分42秒
  > 选择排序法
************************************************************************/
#include<stdio.h>
#include <stdlib.h>
#include <time.h>
/*交换算法*/
#define swap(a, b) {\
    __typeof(a) _temp = a;\
    a = b, b = _temp;\
}
/*
* 选择排序法
* @param data: 要排序的数组序列指针
* @param length: 序列长度
* */
void selection_sort(int *data, int length) {
    for(int i = 0; i < length - 1; i++) {
        int ind = i;
        for(int j = i + 1; j < length; j++) {
            if(data[ind] > data[j]) ind = j;
        }
        if(ind != i)  swap(data[i], data[ind]);
    }
}
/*
* 打印数组
* @param data: 要排序的数组序列指针
* @param length: 序列长度
* */
void output(int *data, int length) {
    for(int i = 0; i < length; i++) {
        i == 0 || printf(" ");
        printf("%2d", data[i]);
    }
    printf("\n");
}
int main() {
    srand(time(0));
    #define MAX_N 20
    int num[MAX_N];
    for(int i = 0; i < MAX_N; i++) num[i] = rand() % 100;
    output(num, MAX_N);
    selection_sort(num, MAX_N);
    output(num, MAX_N);
    #undef MAX_N
    return 0;
}
快速排序

快速排序是目前应用最广泛的排序算法之一。它的基本思想是，每次从排序区域选取一个元素(我们在后面的课程中都是选取第一个)作为基准记录，所有比基准记录小的元素都在基准记录的左边，而所有比基准记录大的元素都在基准记录的右边。之后分别对基准记录的左边和右边两个区间进行快速排序，直至将整个线性表排序完成。

/*************************************************************************
	> File Name: 6.quick_sort.c
	> Author: 陈杰
	> Mail: 15193162746@163.com
	> Created Time: 2021年04月03日 星期六 14时07分42秒
  > 快速排序法
************************************************************************/
#include<stdio.h>
#include <stdlib.h>
#include <time.h>
/*
* 快速排序法
* @param data: 要排序的数组序列指针
* @param left: 排序开始位置
* @param right: 数组结束位置
* */
void quick_sort(int *data, int left, int right) {
    if(left > right) return;
    int pivot = data[left];                 // 选择一个基准点
    int low = left, high = right;           // 两个指针指向最开始的最高和最低位
    while(low < high) {
        while(low < high && data[high] >= pivot) high--;
        // 当高位指针的值小于基准值时，高位的值给低位
        data[low] = data[high];
        while(low < high && data[low] <= pivot) low++;
        // 当低位指针的值大于基准值时，低位的值给高位
        data[high] = data[low];
    }
    // 当高位与低位重合时，当前为赋值为基准值，即为中间值
    data[low] = pivot;
    quick_sort(data, left, low - 1);
    quick_sort(data, low + 1, right);
}
/*
* 打印数组
* @param data: 要排序的数组序列指针
* @param length: 序列长度
* */
void output(int *data, int length) {
    for(int i = 0; i < length; i++) {
        i == 0 || printf(" ");
        printf("%2d", data[i]);
    }
    printf("\n");
}
int main() {
    srand(time(0));
    #define MAX_N 20
    int num[MAX_N];
    for(int i = 0; i < MAX_N; i++) num[i] = rand() % 100;
    output(num, MAX_N);
    quick_sort(num, 0, MAX_N-1);
    output(num, MAX_N);
    #undef MAX_N
    return 0;
}

快速排序的时间复杂度不是稳定的，可以证明快速排序的平均时间复杂度为O(n log n)，最坏情况为O(n2) (当序列的排序顺序与预期的顺序完全相反时，快速排序退化为选择排序)。可以通过随机选择基准记录来竟可能避免最坏情况的出现。同时将前半部分进行手动交换，来优化快速排序

/*************************************************************************
	> File Name: 6.quick_sort.c
	> Author: 陈杰
	> Mail: 15193162746@163.com
	> Created Time: 2021年04月03日 星期六 14时07分42秒
  > 快速排序法
************************************************************************/
#include<stdio.h>
#include <stdlib.h>
#include <time.h>
/*交换算法*/
#define swap(a, b) {\
    __typeof(a) _temp = a;\
    a = b, b = _temp;\
}
/*
* 快速排序法
* @param data: 要排序的数组序列指针
* @param left: 排序开始位置
* @param right: 数组结束位置
* */
void quick_sort(int *data, int left, int right) {
    while(left < right) {
        int pivot = data[(left + right) >> 1];                 // 选择一个基准点
        int low = left, high = right;           // 两个指针指向最开始的最高和最低位
        do {
            while(data[low] < pivot) low++;
            while(data[high] > pivot) high--;
            if(low <= high) {
                swap(data[low], data[high]);
                low++, high--;
            }
        }while(low <= high);
        quick_sort(data, left, high);
        left = low;
    }
}
/*
* 打印数组
* @param data: 要排序的数组序列指针
* @param length: 序列长度
* */
void output(int *data, int length) {
    for(int i = 0; i < length; i++) {
        i == 0 || printf(" ");
        printf("%2d", data[i]);
    }
    printf("\n");
}
int main() {
    srand(time(0));
    #define MAX_N 20
    int num[MAX_N];
    for(int i = 0; i < MAX_N; i++) num[i] = rand() % 100;
    output(num, MAX_N);
    quick_sort(num, 0, MAX_N-1);
    output(num, MAX_N);
    #undef MAX_N
    return 0;
}
nodd_le
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
各种排序算法
01-08
快速排序 归并排序 希尔排序掌握常用的排序方法，并掌握用高级语言实现排序算法的方法； 深刻理解排序的定义和各种排序方法的特点，并能加以灵活应用； 了解各种方法的排序过程及其依据的原则，并掌握各种排序方法的时间复杂性和稳定性的分析方法。
排序算法.zip排序算法.zip排序算法.zip
03-27
在计算机科学领域，排序算法是数据结构与算法分析的重要组成部分，它主要用于将一组无序的数据序列重新排列成一个有序的序列。排序对于数据分析、数据库管理、优化搜索效率等任务至关重要。下面我们将深入探讨几种...
排序算法群星豪华大汇演
qiudesuo的专栏
10-30 422
排序算法群星豪华大汇演   排序算法相对简单些，但是由于它的家族比较庞大——这也许是因为简单的缘故吧，网上整理排序算法实在太多了，什么经典排序算法，八大排序算法总结，精通八大排序算法等枚不胜举，当然这里也不例外，同样是整理，同样是学习的过程。 之前一些排序算法总是说不清楚（作者自己的感受），这倒不是因为太难，作者觉得是因为排序算法太繁复了（一些算法之间的区别不是很明显），那也没有他法，只...
排序算法
喂_balabala
07-30 125
https://www.jianshu.com/p/40366c82c69f @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); int[] ran...
Java排序算法练习：1.快速排序 2.归并排序 3.插入排序 4.冒泡排序 5.选择排序 6.堆排序
08-08
4. **冒泡排序**：是最基础的排序算法，通过重复遍历数组，比较相邻元素并交换位置，使得每一轮遍历后最大的元素“浮”到数组末尾。冒泡排序的时间复杂度较高，但在最佳情况下（已排序数组）仍能实现线性时间。 5. ...
Sort.sln排序算法
12-28
折半查找
排序算法介绍.zip基础算法
最新发布
03-27
排序算法是计算机科学中的核心部分，它涉及到如何有效地组织和处理数据。在“排序算法介绍.zip基础算法”这个压缩包中，我们很可能会找到关于各种排序算法的详细讲解，包括它们的基本原理、实现方式以及性能分析。...
十大经典排序算法.pdf
12-08
十大经典排序算法是数据结构与算法领域中的基础，它们包括冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序、计数排序、桶排序和基数排序。这些算法分别适用于不同的场景，具有各自的时间复杂度...
常见算法-排序算法
作者：大头兵（kit）
08-08 152
算法一直是我不愿触碰的领域，但是数据结构+算法才是完整的编码人生，生活总是很无奈，没办法，生活以痛吻你，你需报之以歌。
几种排序算法
csdn_chuxuezhe的博客
03-21 169
八大经典排序算法：http://blog.csdn.net/mpk_no1/article/details/76397713 1. 堆排序平均性能：O(N*logN)。定义：堆排序是利用堆积树这种结构的一种排序算法，是选择排序的一种。堆分为大根堆和小根堆。大根堆要求每个节点的值都不大于 其父节点的值，由大根堆的要求可知，最大值一定在堆顶。思想：1. 将初始序列（R0，R1...,Rn）构建成大顶堆...
排序算法总结
大致若愚的博客
12-26 6591
一、常用排序算法 各种常用排序算法 类别 排序方法 时间复杂度 ...
排序算法总结（一）
十年磨一剑，沉淀……
06-10 1805
【前言】 前一阵子直在学习算法，通过不断的总结我也发现了算法的魅力。虽然只是简单的排序算法，但是每一次自己动手去画图，去排列对比，看一些相关小视频的时候，感触就会越来越深，从刚开始的只不过简简单单的排序到后来升华成算法的艺术，需要自己慢慢去体会这个过程。 排序主要分为内排序和外排序，如果待排序的记录比较少，整个过程的所有记录都可以存在内存中，这样的排序叫做“内排序”。...
常见的几种排序算法
mzpqq的博客
04-11 1968
目录一、插入排序二、 希尔排序三、选择排序四、冒泡排序五、堆排序六、快速排序挖坑法6.1、递归实现6.2、非递归实现(遍历实现)七、归并排序7.1、递归实现7.2、非递归实现(遍历实现) 一、插入排序 思路： 在我看来插入排序就是先将一段数列变得有序，在将后面的数字不断的插入到这个有序数列中来的这种方法叫做插入排序。 步骤： 我们可以把第一个数字看成一个有序数列，从第二个开始循环遍历。在遍历的途中在定义一个循环，不断的与前面的有序数列进行比较，找到位置之后结束本次循环，并将数字插入到有序数列中去，从而达成目
8种排序算法--快速排序
飞鱼
09-16 1359
快速排序是非常优越的一种排序，时间复杂度为nlogn，空间复杂度为logn。 下面我说说他实现的排序的算法。 快速排序的实现思想：将一组数据，从里面随便找一个值为key值（一般以这组数的第一个数为key），然后用这个key值将数据划分为2部分（一边大于他的数，一边小于他的数）然后将这两边的数分别用这个方法来递归实现字。直到所有都排序完毕。     我们来看看这个数据如何进行快速排序的。
排序算法——七种排序算法汇总，详细（Java）
xy199931的博客
11-21 2442
七种排序算法汇总
七大经典排序算法总结【详解】
weixin_63189874的博客
05-21 7720
数据量规模较小，考虑插入或选择。当元素分布有序时插入将大大减少比较和移动记录的次数，如果不要求稳定性，可以使用选择，效率略高于插入；数据量规模中等，使用希尔排序；数据量规模较大，考虑堆排序（元素分布接近正序或逆序）、快速排序（元素分布随机）和归并排序（稳定性）；一般来说不使用冒泡。
编程实现以下排序算法： 1. 直接插入排序算法； 2. 冒泡排序算法； 3. 快速排序算法； 4. 简单选择排序算法；
06-01
4. 简单选择排序算法 ```python def select_sort(nums): for i in range(len(nums)-1): min_idx = i for j in range(i+1, len(nums)): if nums[j] [min_idx]: min_idx = j nums[i], nums[min_idx] = nums[min...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值