「笔记」数据结构与算法之美 - 基础篇（二）

最新推荐文章于 2023-06-24 07:30:00 发布

D.Chuan

最新推荐文章于 2023-06-24 07:30:00 发布

阅读量498

点赞数 1

分类专栏：「笔记」数据结构与算法之美文章标签：二分查找快速排序归并排序线性排序有序度

本文链接：https://blog.csdn.net/YangDongChuan1995/article/details/104889217

版权

「笔记」数据结构与算法之美专栏收录该内容

3 篇文章 0 订阅

订阅专栏

排序（上）

如何分析一个排序算法
- 排序算法的执行效率
  - 最好情况、最坏情况、平均情况时间复杂度
    - 有序度不同的数据，对于排序的执行时间肯定是有影响的
  - 时间复杂度的系数、常数、低阶
    - 在对同一阶时间复杂度的排序算法性能对比的时候，我们就要把系数、常数、低阶也考虑进来
  - 比较次数和交换（或移动）次数
- 排序算法的内存消耗
  - 原地排序算法，就是特指空间复杂度是 O(1) 的排序算法
- 排序算法的稳定性
  - 稳定性：如果待排序的序列中存在值相等的元素，经过排序之后，相等元素之间原有的先后顺序不变
有序度与逆序度
- 有序度是数组中具有有序关系的元素对的个数
  - 对于一个完全有序的数组，比如 1，2，3，4，5，6，有序度就是 n*(n-1)/2；也被称为满有序度
- 逆序度的定义正好跟有序度相反（默认从小到大为有序）
- 公式：逆序度 = 满有序度 - 有序度
- 排序的过程就是一种增加有序度，减少逆序度的过程，最后达到满有序度，就说明排序完成
冒泡排序（Bubble Sort）
- 每次冒泡操作都会对相邻的两个元素进行比较，看是否满足大小关系要求（如果不满足就让它俩互换）
- 性能分析
  - 是原地排序算法
  - 是稳定排序算法
  - 时间复杂度
    - 最好时间复杂度是 O(n)
    - 最坏时间复杂度是 O(n^2)
    - 平均时间复杂度是 O(n^2)
插入排序（Insertion Sort）
- 将数组中的数据分为两个区间，已排序区间和未排序区间
  - 插入算法的核心思想是取未排序区间中的元素，在已排序区间中找到合适的插入位置将其插入
  - 并保证已排序区间数据一直有序，重复这个过程，直到未排序区间中元素为空，算法结束
    - 插入排序也包含两种操作，一种是元素的比较，一种是元素的移动
- 性能分析
  - 是原地排序算法
  - 是稳定排序算法
  - 时间复杂度
    - 最好时间复杂度是 O(n)
    - 最坏时间复杂度是 O(n^2)
    - 平均时间复杂度是 O(n^2)
选择排序（Selection Sort）
- 分已排序区间和未排序区间，每次会从未排序区间中找到最小的元素，将其放到已排序区间的末尾
- 性能分析
  - 是原地排序算法
  - 不是稳定排序算法
  - 时间复杂度
    - 最好时间复杂度是 O(n^2)
    - 最坏时间复杂度是 O(n^2)
    - 平均时间复杂度是 O(n^2)
排序（下）
归并排序的原理
- 归并排序使用的就是分治思想。分治，顾名思义，就是分而治之，将一个大问题分解成小的子问题来解决
  - 分治是一种解决问题的处理思想，递归是一种编程技巧
- 依次合并子数组
归并排序的性能分析
- 不是原地排序算法（空间复杂度是 O(n)）
- 是稳定排序算法
- 时间复杂度
  - 不管是最好情况、最坏情况，还是平均情况，时间复杂度都是 O(nlogn)
快速排序的原理
- 快排的思想是这样的：如果要排序数组中下标从 p 到 r 之间的一组数据，我们选择 p 到 r 之间的任意一个数据作为 pivot（分区点）
  - 遍历 p 到 r 之间的数据，将小于 pivot 的放到左边，将大于 pivot 的放到右边，将 pivot 放到中间
  - 数组 p 到 r 之间的数据就被分成了三个部分，根据分治、递归的处理思想继续递归左右部分
- 分区的整个过程（原地排序的方式实现）
  - 这里我们只需要将 A[i]与 A[j]交换，就可以在 O(1) 时间复杂度内将 A[j]放到下标为 i 的位置
快速排序的性能分析
- 是原地排序算法
- 不是稳定排序算法
- 时间复杂度
  - 最好时间复杂度是 O(nlogn)
  - 最坏时间复杂度是 O(n^2)
  - 平均时间复杂度是 O(nlogn)
快排和归并用的都是分治思想，那它们的区别在哪里呢？
- 方向
  - 归并排序的处理过程是由下到上的，先处理子问题，然后再合并
  - 快排正好相反，它的处理过程是由上到下的，先分区，然后再处理子问题
- 空间复杂度及稳定性
  - 归并排序虽然是稳定的，但不是原地排序（原因是合并函数无法在原地执行）
  - 快速排序是不稳定排序，但是是原地排序（通过设计巧妙的原地分区函数来实现的）

线性排序

线性排序：排序算法的时间复杂度是线性的（例子：桶排序、计数排序、基数排序
桶排序（Bucket sort）
- 核心思想是将要排序的数据分到几个有序的桶里，每个桶里的数据再单独进行排序
  - 桶内排完序之后，再把每个桶里的数据按照顺序依次取出，组成的序列就是有序的了
- 桶排序对要排序数据的要求是非常苛刻的
  - 要排序的数据需要很容易就能划分成 m 个桶，并且，桶与桶之间有着天然的大小顺序
  - 数据在各个桶之间的分布是比较均匀的（极端情况下，数据都被划分到一个桶里，那就退化为 O(nlogn) 了
    - 可以对热点桶数据再一步划分，划分成多个子桶
- 桶排序比较适合用在外部排序中
  - 所谓的外部排序就是数据存储在外部磁盘中，数据量比较大，内存有限，无法将数据全部加载到内存中
计数排序（Counting sort）
- 当要排序的 n 个数据，所处的范围并不大的时候，比如最大值是 k，我们就可以把数据划分成 k 个桶
  - 每个桶内的数据值都是相同的，省掉了桶内排序的时间
  - 个人觉得，计数排序其实是桶排序的一种特殊情况，应用场景：高考成绩快速排序得出名次
- 计数排序全过程
  - C[6]内存储的并不是考生，而是对应的考生个数
- 计数排序只能用在数据范围不大的场景中，如果数据范围 k 比要排序的数据 n 大很多，就不适合用计数排序
  - 计数排序只能给非负整数排序，如果要排序的数据是其他类型的，要将其在不改变相对大小的情况下，转化为非负整数
基数排序（Radix sort）
- 基数排序的过程分解图
  - 这里按照每位来排序的排序算法要是稳定的，否则这个实现思路就是不正确的
- 时间复杂度分析
  - 根据每一位来排序，我们可以用刚讲过的桶排序或者计数排序，它们的时间复杂度可以做到 O(n)
  - 如果要排序的数据有 k 位，那我们就需要 k 次桶排序或者计数排序，总的时间复杂度是 O(k*n)
  - 当 k 不大的时候，比如手机号码排序的例子，k 最大就是 11，所以基数排序的时间复杂度就近似于 O(n)
- 对于待排序字段长度位数不一致的场景，可以通过低位补 0 的方式补齐（因为根据ASCII 值，所有字母都大于 0
- 基数排序对要排序的数据是有要求的
  - 要可以分割出独立的“位”来比较，而且位之间有递进的关系，若 a 数据的高位比 b 数据大，则 a 直接大于 b
  - 每一位的数据范围不能太大，要可以用线性排序算法来排序，否则，基数排序的时间复杂度就无法做到 O(n)

排序优化

如何选择合适的排序算法
- 如果对小规模数据进行排序，可以选择时间复杂度是 O(n2) 的算法
- 如果对大规模数据进行排序，时间复杂度是 O(nlogn) 的算法更加高效
  - 为了兼顾任意规模数据的排序，首选时间复杂度是 O(nlogn) 的排序算法
  - 归并排序和快排平均时间复杂度都是O(nlogn) ，但前者不是原地排序（空间复杂度为O(n)
如何优化快速排序
- 最坏时间复杂度出现的主要原因还是因为我们分区点选的不够合理
  - 最理想的分区点是：被分区点分开的两个分区中，数据的数量差不多
- 三数取中法
- 从区间的首、尾、中间，分别取出一个数，然后对比大小，取这 3 个数的中间值作为分区点
- 如果要排序的数组比较大，可以扩大参考数量，比如要“五数取中”或者“十数取中”等
- 随机法
  - 随机法就是每次从要排序的区间中，随机选择一个元素作为分区点
  - 时间复杂度退化为最糟糕的 O(n2) 的情况，出现的可能性不大
举例分析排序函数
- 拿 Glibc 中的 qsort() 函数举例说明一下
  - qsort() 会优先使用归并排序来排序输入数据，因为归并排序的空间复杂度是 O(n)
    - 对于小数据量的排序，比如 1KB、2KB 等，归并排序额外需要 1KB、2KB 的内存空间，这个问题不大
  - 要排序的数据量比较大的时候，qsort() 会改为用快速排序算法来排序
    - qsort() 选择分区点的方法就是“三数取中法”
  - 如何避免递归太深导致堆栈溢出的问题
    - sort() 是通过自己实现一个堆上的栈，手动模拟递归来解决的
  - qsort() 并不仅仅用到了归并排序和快速排序，它还用到了插入排序
    - 在快速排序的过程中，当要排序的区间中，元素的个数小于等于 4 时，qsort() 就退化为插入排序
    - 在小规模数据面前，O(n2) 时间复杂度的算法并不一定比 O(nlogn) 的算法执行时间长
      - O(nlogn) 在没有省略低阶、系数、常数之前可能是 O(knlogn + c)，k 和 c 可能是一个比较大的数
      - 当我们对小规模数据（比如 n=100）排序时，n2的值实际上比 knlogn+c 还要小
  - 在 qsort() 插入排序的算法实现中也利用了哨兵来简化代码，提高执行效率
    - 虽然哨兵可能只是少做一次判断，但是排序函数是非常常用、非常基础的函数，性能的优化要做到极致

二分查找（上）

一种针对有序数据集合的查找算法：二分查找（Binary Search）算法，也叫折半查找算法
无处不在的二分思想
- 二分查找针对的是一个有序的数据集合，查找思想有点类似分治思想
- 每次都通过跟区间的中间元素对比，将待查找的区间缩小为之前的一半，直到找到要查找的元素（区间为 0 时
O(logn) 惊人的查找速度
- 这是一种极其高效的时间复杂度，有的时候甚至比时间复杂度是常量级 O(1) 的算法还要高效
- 即便 n 非常非常大，对应的 logn 也很小（例如在 42 亿个有序数据中用二分查找一个数据，最多需要比较 32 次
二分查找的实现
- 最简单的情况就是有序数组中不存在重复元素
  - ```
  public int bsearch(int[] a, int n, int value) {
    int low = 0;
    int high = n - 1;
  
    while (low <= high) {
      int mid = (low + high) / 2;
      if (a[mid] == value) {
        return mid;
      } else if (a[mid] < value) {
        low = mid + 1;
      } else {
        high = mid - 1;
      }
    }
  
    return -1;
  }
```
- 容易出错的 3 个地方
  - 循环退出条件（注意是 low<=high，而不是 low
  - mid 的取值
    - mid=(low+high)/2 这种写法是有问题的，可能会有溢出风险，可以改成 low+(high-low)/2
    - 可以将这里的除以 2 操作转化成位运算 low+((high-low)>>1) ，计算机处理位运算要快得多
  - low 和 high 的更新（注意这里的 +1 和 -1，如果直接写成 low=mid 或者 high=mid，就可能会发生死循环
二分查找应用场景的局限性
- 首先，二分查找依赖的是顺序表结构，简单点说就是数组
  - 要原因是二分查找算法需要按照下标随机访问元素（链表无法有效支持，时间复杂度会变得特别高
- 其次，二分查找针对的是有序数据
  - 二分查找只能用在插入、删除操作不频繁，一次排序多次查找的场景中
- 再次，数据量太小不适合二分查找
  - 数量小时，直接顺序遍历即可，查找速度都差不多
  - 如果数据之间的比较操作非常耗时，不管数据量大小，我都推荐使用二分查找
- 最后，数据量太大也不适合二分查找
  - 二分查找的底层需要依赖数组这种数据结构，要求内存空间连续，对内存的要求比较苛刻
  - 比如，我们有 1GB 大小的数据，如果希望用数组来存储，那就需要 1GB 的连续内存空间

二分查找（下）

4种场景的二分查找变形问题

变体一：查找第一个值等于给定值的元素

比如这样一个有序数组，其中，a[5]，a[6]，a[7]的值都等于 8，是重复的数据，找出第一个（下标为5 那个

代码实现


public int bsearch(int[] a, int n, int value) {
  int low = 0;
  int high = n - 1;
  while (low <= high) {
    int mid =  low + ((high - low) >> 1);
    if (a[mid] > value) {
      high = mid - 1;
    } else if (a[mid] < value) {
      low = mid + 1;
    } else {
      // 如果 mid 等于 0，那这个元素已经是数组的第一个元素，那它肯定是我们要找的
      // 如果 mid 不等于 0，但 a[mid]的前一个元素 a[mid-1]不等于 value，那也说明 a[mid]就是我们要找的第一个值等于给定值的元素
      if ((mid == 0) || (a[mid - 1] != value)) return mid;
      // 如果经过检查之后发现 a[mid]前面的一个元素 a[mid-1]也等于 value
      // 要找的元素肯定出现在[low, mid-1]之间
      else high = mid - 1;
    }
  }
  return -1;
}

对于我们做工程开发的人来说，代码易读懂、没 Bug，其实更重要，所以我觉得第二种写法更好

变体二：查找最后一个值等于给定值的元素
- 同理，改动点在判断那块 if ((mid == n - 1) || (a[mid + 1] != value)) 与 else low = mid + 1;

变体三：查找第一个大于等于给定值的元素

比如，数组中存储的这样一个序列：3，4，6，7，10。如果查找第一个大于等于 5 的元素，那就是 6

代码实现


public int bsearch(int[] a, int n, int value) {
  int low = 0;
  int high = n - 1;
  while (low <= high) {
    int mid =  low + ((high - low) >> 1);
    if (a[mid] >= value) {
      // 如果 a[mid]前面已经没有元素，或者前面一个元素小于要查找的值 value
      // 那 a[mid] 就是我们要找的元素
      if ((mid == 0) || (a[mid - 1] < value)) return mid;
      // 如果 a[mid-1]也大于等于要查找的值 value，那说明要查找的元素在[low, mid-1]之间
      else high = mid - 1;
    } else {
    	// 如果 a[mid]小于要查找的值 value，那要查找的值肯定在[mid+1, high]之间
      low = mid + 1;
    }
  }
  return -1;
}

变体四：查找最后一个小于等于给定值的元素（实现原理同上）

二分查找更适合用在“近似”查找问题（等值查询场景确实不怎么会被用到
代码实现时容易出错的细节有：终止条件、区间上下界更新方法、返回值选择

D.Chuan

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
「笔记」数据结构与算法之美 - 基础篇（二）

排序（上）如何分析一个排序算法排序算法的执行效率最好情况、最坏情况、平均情况时间复杂度有序度不同的数据，对于排序的执行时间肯定是有影响的时间复杂度的系数、常数、低阶在对同一阶时间复杂度的排序算法性能对比的时候，我们就要把系数、常数、低阶也考虑进来比较次数和交换（或移动）次数排序算法的内存消耗原地排序算法，就是特指空间复杂度是 O(1) 的排序算法...
复制链接

扫一扫