• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
DB_Algorithm_and_Data_Structure_About_Sort
 

DB_Algorithm_and_Data_Structure_About_Sort

on

  • 1,551 views

数据结构与算法.02.排序算法

数据结构与算法.02.排序算法

Statistics

Views

Total Views
1,551
Views on SlideShare
1,270
Embed Views
281

Actions

Likes
2
Downloads
80
Comments
0

1 Embed 281

http://www.penglixun.com 281

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    DB_Algorithm_and_Data_Structure_About_Sort DB_Algorithm_and_Data_Structure_About_Sort Presentation Transcript

    • 数据结构与算法 ——排序相关 MySQL DBA 彭立勋 Alibaba B2B DBA Team
      • O(N^2) 排序
      • 冒泡排序
      • 选择排序
      • 插入排序
      • O(N*LogN) 排序
      • 快速排序
      • 归并排序
      • 堆排序
      • 树排序
      • O(N) 排序
      • 桶排序
      • 基数排序
      • 希尔排序
      数据结构与算法——排序相关
      • 区间排序
      • ShortSort (Oracle)
      • TopK 算法 (Knuth)
      • TopMN 算法 (P.Linux)
      数据结构与算法——排序相关
    • 冒泡排序
      • 它重复地访问要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。访问数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。
      • FOR I = 1 TO N-1 DO
      • FOR J = I+1 TO N DO
      • IF (A[i]>A[j]) THEN swap(A[i],A[j]);
      • END FOR
      • END FOR
      数据结构与算法——排序相关
    • 冒泡排序
      • 数据结构:数组
      • 最差时间复杂度: O ( n 2 )
      • 最优时间复杂度: O ( n )—— 因为可以通过判断一轮比较后是否有交换来判定排序是否完成
      • 平均时间复杂度: O ( n 2 )
      • 最差空间复杂度: O ( n ) total,  O (1) auxiliary
      数据结构与算法——排序相关
    • 冒泡排序 数据结构与算法——排序相关
    • 选择排序
      • 首先在未排序序列中找到最小元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小元素,然后放到排序序列末尾。以此类推,直到所有元素均排序完毕。
      • FOR I = 1 TO N DO
      • A[i] = FindMin(I,N);
      • END FOR
      数据结构与算法——排序相关
    • 选择排序
      • 数据结构:数组
      • 最差时间复杂度: О( n²)
      • 最优时间复杂度: О( n²)
      • 平均时间复杂度: О( n²)
      • 最差空间复杂度: О( n)  total,  O(1) auxiliary
      数据结构与算法——排序相关
    • 选择排序 数据结构与算法——排序相关
    • 插入排序
      • 它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。
      • FOR I = 2 TO N DO
      • J = FindPos(1,I-1,x); // 在有序的序列中找 X 的位置
      • MoveNext(J,I); // 将需要占用位置的元素后移
      • A[J] = x; // 空出的位置放入 X
      • END FOR
      数据结构与算法——排序相关
    • 插入排序
      • 数据结构:数组
      • 最差时间复杂度: О( n²)
      • 最优时间复杂度: О( n²)
      • 平均时间复杂度: О( n²)
      • 最差空间复杂度: О( n)  total,  O(1) auxiliary
      数据结构与算法——排序相关
    • 快速排序
      • 从数列中挑出一个元素,称为 " 基准 " ,重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。这个称为分割操作。递归地( recursive )把小于基准值元素的子数列和大于基准值元素的子数列排序。
      数据结构与算法——排序相关
    • 快速排序
      • 数据结构: Varies
      • 最差时间复杂度: Θ( n 2 )
      • 最优时间复杂度: Θ(nlogn)
      • 平均时间复杂度: Θ(nlogn) comparisons
      • 最差空间复杂度根据实现的方式不同而不同
      数据结构与算法——排序相关
    • 快速排序 数据结构与算法——排序相关
    • 归并排序
      • 元素首先分组,每组元素进行比较。然后每组元素看成一个元素,再分组比较。递归此过程直到只有一组元素的时候排序完成。
      • void merge_sort(int arr[], int first, int last) {
      • int mid = 0;
      • if(first<last) {
      • mid = (first+last)/2; // 分成两组分别排序
      • merge_sort(array, first, mid); // 对一个分组排序
      • merge_sort(array, mid+1,last); // 对另一个分组排序
      • merge(array,first,mid,last); // 归并两组排序
      • }
      • }
      数据结构与算法——排序相关
    • 归并排序
      • 数据结构:数组
      • 最差时间复杂度: Θ( n log n )
      • 最优时间复杂度: Θ( n )
      • 平均时间复杂度: Θ( n log n )
      • 最差空间复杂度: Θ( n )
      数据结构与算法——排序相关
    • 归并排序 数据结构与算法——排序相关
    • 堆排序
      • 堆积树是一个近似完全二叉树的结构,并同时满足堆的属性:即子结点的键值或索引总是小于(或者大于)它的父结点。
      • WHILE ( 堆不为空 ) {
      • A[i++] = GetRootFromHeap; // 取出堆根
      • ShiftHeap; // 调堆
      • }
      数据结构与算法——排序相关
    • 堆排序
      • 数据结构:数组
      • 最差时间复杂度: O ( nlogn )
      • 最优时间复杂度: O ( nlogn )
      • 平均时间复杂度: Θ( nlogn )
      • 最差空间复杂度: O ( n ) total,  O (1)auxiliary
      数据结构与算法——排序相关
    • 堆排序 数据结构与算法——排序相关
    • 树排序
      • 首先按照搜索二叉树对数据建树,然后中序遍历搜索树,即可得到有序数列。
      • 普通二叉搜索树, AVL 平衡二叉树等。
      数据结构与算法——排序相关
    • 树排序
      • 数据结构:数组
      • 最差时间复杂度:平衡树 O ( nlogn )
      • 非平衡树 O ( n^2 )
      • 最优时间复杂度: O ( nlogn )
      • 平均时间复杂度: Θ( nlogn )
      • 最差空间复杂度: O ( n ) total,  O (1) auxiliary
      数据结构与算法——排序相关
    • 桶排序
      • 不基于比较,为每个元素设一个计数器,记录每个元素出现多少次。
      • FOR I = 1 TO N DO
      • C[A[i]]++; // 将元素丢入桶中
      • END FOR
      • FOR I = 1 TO MAX DO
      • 输出 C[i] 个 I; // 讲元素依次倒出桶
      • END FOR
      数据结构与算法——排序相关
    • 桶排序
      • 数据结构:数组
      • 最差时间复杂度: Θ (n)
      • 最优时间复杂度: Θ (n)
      • 平均时间复杂度: Θ (n)
      • 最差空间复杂度: O ( MAX ) total
      数据结构与算法——排序相关
    • 基数排序
      • 将所有待比较数值 ( 正整数 ) 统一为同样的数位长度 , 数位较短的数前面补零 . 然后 , 从最低位开始 , 依次进行一次排序 . 这样从最低位排序一直到最高位排序完成以后 , 数列就变成一个有序序列 . 基数排序的方式可以采用 LSD ( Least significant digital )或 MSD ( Most significant digital ), LSD 的排序方式由键值的最右边开始,而 MSD 则相反,由键值的最左边开始。
      数据结构与算法——排序相关
    • 希尔排序
      • 对有 n 个元素的可比较资料,先取一个小于 n 的整数 d1 作为第一个增量,把文件的全部记录分成 d1 个组。所有距离为 d1 的倍数的记录放在同一个组中。先在各组内进行直接插入排序;然后,取第二个增量 d2<d1 重复上述的分组和排序,直至所取的增量 dt=1(dt<dt-1<…<d2<d1) ,即所有记录放在同一组中进行直接插入排序为止。
      • 该方法实质上是一种 分组插入方法 。
      数据结构与算法——排序相关
    • ShortSort
      • ShortSort(N) ,先从序列中取 N 个元素,建立一个堆,从 N+1 开始,依次和堆根元素做比较,比根元素大 ( 小 ) ,则替换堆的根元素,重新调堆,直到没有元素来比较。
      • H = CreateHeap(N); // 建立前 N 个元素的堆
      • FOR I = N+1 TO Max DO
      • IF (A[i] > H[0]) H[0] = A[i]; // 替换堆根
      • ShiftHeap(); // 调堆
      • END FOR
      数据结构与算法——排序相关
    • ShortSort
      • 数据结构:数组
      • 最差时间复杂度: O (n+ nlogk )
      • 最优时间复杂度: O (n+ klogk )
      • 平均时间复杂度: Θ( n+xlogn ) [k < x < n]
      • 最差空间复杂度: O ( n ) total,  O (1)auxiliary
      • 劣势:如果要最大的 N 个,而数据本身升序,那么每次都需要调堆,相当于完全排序。
      数据结构与算法——排序相关
    • TopK
      • 利用二分思想,每次对元素分成左大右小两堆,判断左边的元素数量,如果大约 K 则继续二分左堆,如果已经小于 K ,那么取上次二分结果的左堆进行排序。
      • WHILE (|LeftGroup[now]| > K) {
      • // 如果左堆元素多于 K 个则继续二分
      • LeftGroup[1-now] = Split(LeftGroup[now]);
      • }
      • Sort(LeftGroup[1-now] ); // 在左堆中排序
      数据结构与算法——排序相关
    • TopK
      • 数据结构:数组
      • 最差时间复杂度: O ((n+k)log(n/k)+ klogk )
      • 最优时间复杂度: O ((n+k)log(n/k)+ klogk )
      • 平均时间复杂度: Θ ((n+k)log(n/k)+ klogk )
      • 最差空间复杂度根据实现的方式不同而不同
      • 优势:利用随机的”基准”,可以有效避免全排序
      数据结构与算法——排序相关
    • TopMN
      • 排序 M..N 位的元素,则需要抛弃 1..M-1,N+1..MAX 两部分的元素。利用二分思想,每次对元素分成左大右小两堆,分别处理。左堆继续二分分出前 M-1 个元素,右堆继续二分分出 N+1 个之后的元素。排除无效元素后的元素集,再进行排序。
      • H = Split(A); // 元素分成两堆
      • 利用 TopK 的思想将前 M-1 个元素排到一组。
      • 利用 TopK 的思想将 N+1 位后的元素排到一组。
      • Sort(A,M,N).
      • 备注:可以不用严格要求 M..N 分出来,可以有部分无效元素,只要去掉大部分无效元素即可。
      数据结构与算法——排序相关
    • 数据库算法与数据结构系列
      • B 树相关
      • 排序相关 [*]
      • 锁相关
      • 缓存相关
      • * 操作系统相关 ( 调度模型 / 段页管理 )
      • * 人工智能相关 ( 遗传算法 / 神经网络 )
      数据结构与算法——排序相关
    • 数据库原理系列
      • 笛卡尔积与集合理论
      • 数据库范式理论
      • 分布式事务理论
      数据结构与算法——排序相关