内部排序算法（插入排序，希尔排序，冒泡排序，快速排序，直接选择排序，堆排序，归并排序，基数排序）总结

最新推荐文章于 2024-04-21 17:41:25 发布
最新推荐文章于 2024-04-21 17:41:25 发布
阅读量354 收藏 2
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构与算法 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_38007695/article/details/82015604
版权

排序算法的稳定性

若待排序表中有两个元素 Ri 和 Rj，其对应的关键字 ki=kj，且在排序前 Ri 在 Rj 前面，若使用某排序算法后，Ri 仍然在 Rj 前面。则称这个排序算法是稳定的，否则称排序算法不稳定。

算法的稳定性是算法的性质，并不能衡量一个算法的优劣

时空复杂度决定内部排序算法的性能

插入排序

插入排序每次将一个待排序的序列插入到一个前面已经排好序的子序列当中

直接插入排序

初始 L[1] 是一个已经排好序的子序列

对于元素 L[i] ( L[2] ~ L[n] ) 插入到前面已经排好序的子序列当中：

  1. 查找出 L[i] 在 L[1...i-1] 中的插入位置 k

  2. 将 L[k...i-1] 中的所有元素全部向后移一个位置

  3. 将 L[i] 复制到 L[k]

 void InsertSort(ElemType A[], int n){
     int i, j;
     for(i=2, i<n, i++){
         A[0] = A[1];
         for(j=i-1; A[0].key<A[j].key; j--)
             A[j+1] = A[j];
         A[j+1] = A[j];
     }
 }
 def insert_sort(L):
     length = len(L)
     for i in range(1, length):
         a = L[i]
         for j in range(i, -1, -1):
             if L[j-1] > a: L[j] = L[j-1]
             else: break
         L[j] = a

时间复杂度：O(n^2)​，空间复杂度：O(1)​ ，稳定，顺序存储和链式存储

折半插入顺序

void BInsertSort(ElemType A[], int n){
     int i, j;
     int low, high, mid;
     for(i=2;i<n;i++){
         A[0] = A[i];
         # 折半查找
         low = 1; high = i-1;
         while(low<=high){
             mid = (low + high) / 2;
             if(A[mid].key > A[0].key)
                 high = mid - 1;
             else
                 low = mid + 1
         }
         # 移动
         for(j=i-1; j>=high; i--)
             A[j+1] = A[j];
         A[high + 1] = A[0];
     }
 }

 

def b_insert_sort(L):
     length = len(L)
     for i in range(1, length):
         a = L[i]
         # 折半查找
         low = 0
         high = i-1
         while low <= high:
             mid = (low + high) // 2
             if L[mid] > a:
                 high = mid - 1
             else:
                 low = mid + 1
         # 移动
         for j in range(i, high, -1):
             L[j] = L[j-1]
         L[high+1] = a
时间复杂度：​​，空间复杂度：​​ ，稳定，顺序存储

希尔排序

先将排序表分割成d个形如 L[i, i+d, i+2d, ..., i+kd] 的“特殊”子表，分别进行直接插入排序，当整个表中的元素已呈“基本有序时”，在对全体记录进行一次直接插入排序

void SheelSort(ElemType A[], int n){
     for(int dk=n/2; dk>=1; dk=dk/2){
         for(int i=dk+1; i<n; ++i){
             if(A[i].key < A[i-dk].key){
                 A[0] = A[i];
                 for(j=i-dk; j>0&&A[0].key<A[j].key, j-=dk)
                     A[j+dk] = A[j];
                 A[j+dk] = A[0]
             }
         }
     }
 }
 def shell_sort(L):
     length = len(L)
     dk = length // 2
     while dk >= 1:
         for i in range(dk, length):
             if L[i] < L[i-dk]:
                 a = L[i]
                 for j in range(i, -1, -dk):
                     if L[j-dk] > a: L[j] = L[j-dk]
                     else: break
                 L[j] = a
         dk = dk // 2

时间复杂度 ​ O(n^2)​​，空间复杂度 O(1)​ ​，不稳定，顺序存储

交换排序

冒泡排序

假设待排序表长为 n，从后往前（从前往后）两两比较相邻元素的值，若为逆序（即A[i-1]>A[i]），则交换他们直到序列比较结束

一次冒泡会将一个元素放置到它最终的位置上

void BubbleSort(ElemType A[], int n){
     // 从后往前
     /*
     for(int i=0; i<n-1; i++){
         bool flag = False;
         for(int j=n-1; j>i; j--){
             if(A[j-1].key > A[j].key){
                 swap(A[j-1], A[j]);
                 flag = true;
             }
         }
         if(flag==false)
             return;
     }
     */
     // 从前往后
     for(int i=n-1; i>0; i--){
         bool flag=false;
         for(int j=0; j<i; j++){
             if(A[j].key > A[j+1].key){
                 swap(A[j], A[j+1]);
                 flag=true;
             }
         }
         if(flag==false)
             return;
     }
 }
 def bubble_sort(L):
     n = len(L)
     # 从前往后
     for i in range(n-1, 0, -1):
         flag = False
         for j in range(i):
             if L[j] > L[j+1]:
                 L[j], L[j+1] = L[j+1], L[j]
                 flag = True
         if not flag: return
     # 从后往前
     # for i in range(n-1):
     #     flag = False
     #     for j in range(n-1, i, -1):
     #         if L[j] < L[j-1]:
     #             L[j], L[j-1] = L[j-1], L[j]
     #             flag = True
     #     if not flag: return

时间复杂度O(n^2)​​ ​，空间复杂度 ​O(1)​ ​，稳定，顺序存储和链式存储

快速排序

在待排序表 L[1...n] 中任取一个元素 pivot 作为基准，通过一趟排序将待排序表划分为具有如下特点的两部分

一次划分会将一个元素 pivot 放置到它最终的位置上

Partition

初始化标记 low 为划分部分第一个元素的位置，high为最后一个元素的位置，然后不断地移动两标记并交换元素

  1. high向前移动找到第一个比 pivot 小的元素

  2. low 向后移动找到第一个比 pivot 大的元素

  3. 交换当前两个位置的元素

  4. 继续移动标记，执行 1 2 3 的过程，直到 low 大于等于 high 为止

 int Partition(ElemType A[], int low, int high){
     ElemType pivot = A[low];
     while(low < high){
         while(low < high && A[high] >= pivot)
             high --;
         A[low] = A[high];
         while(low < high && A[low] <= pivot)
             low ++;
         A[high] = A[low];
     }
     A[low] = pivot;
     return low;
 }
 ​
 void QuickSort(ElemType A[], int low, int high){
     if(low < high){
         int pivotpos = Partition(A, low, high);
         QuickSort(A, low, pivotpos-1);
         QuickSort(A, pivotpos+1, high);
     }
 }
 def partition(L, low, high):
     a = L[low]
     while low < high:
         while high > low and L[high] >= a:
             high -= 1
         L[low] = L[high]
         while low < high and L[low] <= a:
             low += 1
         L[high] = L[low]
     L[low] = a
     return low
 ​
 ​
 def quick_sort(L, low, high):
     if low < high:
         mid = partition(L, low, high)
         quick_sort(L, low, mid-1)
         quick_sort(L, mid+1, high)

最好、平均时间复杂度 ​O(n \log_2n) ，最坏时间复杂度 ​O(n^2)

最好、平均空间复杂度 O(\log_2n) ​，最坏空间复杂度 ​O(n)

选择排序

直接选择排序

每一趟在后面 n-i+1 （i=1,2, ..., n-1）个待排序元素中选取关键字最小的元素，作为有序子序列的第 i 个元素，直到 n-1趟做完，待排序元素只剩下1个

一趟排序会将一个元素放置在最终的位置上

void SelectSort(ElemType A[], int n){
     for(int i=0; i<n-1;i++){
         int min = i;
         for(int j=i+1; j<n; j++){
             if(A[j] < A[min])
                 min = j;
         }
         if(min != i)
             swap(L[i], L[min]);
     }
 }


  def select_sort(L):
     length = len(L)
     for i in range(length-1):
         min_index = i
         for j in range(i+1, length):
             if L[j] < L[min_index]:
                 min_index = j
         if min_index != i:
             L[min_index], L[i] = L[i], L[min_index]

时间复杂度 ​ O(n^2)，空间复杂度 ​O(1)，不稳定，顺序存储和链式存储

堆排序

堆

n 个关键字序列 L[1...n] 称为堆，当且仅当该序列满足：

  1. 若 L[i] <= L[2i] 且 L[i] <= L[2i+1]， 则称该堆为小根堆

  2. 若 L[i] >= L[2i] 且 L[i] >= L[2i+1]， 则称该堆为大根堆

​1 \leq i \leq \lfloor n/2 \rfloor

在排序过程中将 L[1...n] 视为一棵完全二叉树的顺序存储结构

堆的初始化

大根堆

对所有具有双亲节点含义编号从大到小 （​ \lfloor n/2 \rfloor ~ 1）做出如下调整

  1. 若孩子节点皆小于双亲节点，则该节点的调整结束

  2. 若存在孩子节点大于双亲节点，则将最大的孩子节点与双亲节点交换，并对该孩子节点进行1 2 ，直到出现 1 或到叶节点为止

 void BuildMaxHeap(ElemType A[], int len){
     for(int i=len/2; i>0; i--)
         AdjustDown(A, i, len);
 }
 void AdjustDown(Elemtype A[], int k, int len){
     A[0] = A[k];
     for(int i=2*k; i<=len; i*=2){
         if(i<len && A[i]<A[i+1])
             i++;
         if(A[0]>=A[i])
             break;
         else{
             A[k] = A[i];
             k = i;
         }
     }
     A[k] = A[0];
 }


 def build_max_heap(heap, length):
     # 初始化最大堆
     for i in range(length//2, -1, -1):
         adjust_down(heap, i, length)
 ​
 ​
 def adjust_down(heap, parent, length):
     # 向下调整
     child = parent * 2 + 1
     while child < length:
         if child < length - 1 and L[child] < L[child+1]:
             child += 1
         if heap[parent] >= heap[child]:
             break
         heap[parent], heap[child] = heap[child], heap[parent]
         parent, child = child, child * 2 + 1

初始建堆 ​O(n)

堆排序

不断地输出堆顶元素，并向下调整

 void HeapSort(ElemType A[], int len){
     BuildMaxHeap(A, len);
     for(int i=len; j>1; i--){
         swap(A[i], A[1]);
         AdjustDown(A, 1, i-1);
     }
 }
 def heap_sort(heap, length):
     build_max_heap(heap, length)
     for i in range(length-1, -1, -1):
         heap[i], heap[0] = heap[0], heap[i]
         adjust_down(heap, 0, i-1)

时间复杂度 ​O(n\log_2n)，空间复杂度 O(1)​，不稳定，顺序存储（链式存储）

堆的插入

将新节点放置在末端然后进行向上调整

 void AdjustUp(ElemType A[], int len){
     A[0] = A[k];
     int i=k/2;
     while(i>0 && A[i]<A[0]){
         A[k] = A[i];
         k=i;
         i=k/2
     }
     A[k] = A[0];
 }

归并排序

 
// 合并两个有序线性表
 ElemType *B=(ElemType *)malloc((n+1)*sizeof(ElemType));
 void Merge(ElemType A[], int low, int mid, int high){
     for(int k=low;k<=high;k++)
         B[k] = A[k];
     for(int i=low,j=mid+1,k=low;i<=low&&j<=high;k++){
         if(B[i]<B[j])
             A[k] = B[i++];
         else
             A[k] = B[j++];
     }
     while(i<=low)
         A[k++] = B[i++];
     while(j<=high)
         A[k++] = B[j++]
 }
 ​
 //归并排序
 void MergeSort(ElemType A[], int low, int high){
     if(low < high){
         int mid = (low + high) / 2;
         MergeSort(A, low, mid);
         MergeSort(A, mid+1, high);
         Merge(A, low, mid, high);
     }
 }
 
def merge_sort(L):
     if len(L) <= 1:
         return L
     mid = len(L) // 2
     left = merge_sort(L[:mid])
     right = merge_sort(L[mid:])
     return merge(left, right)
 ​
 ​
 def merge(a, b):
     c = []
     i, j = 0, 0
     while i < len(a) and j < len(b):
         if a[i] < b[j]:
             c.append(a[i])
             i += 1
         else:
             c.append(b[j])
             j += 1
     while i < len(a):
         c.append(a[i])
         i += 1
     while j < len(b):
         c.append(b[j])
         j += 1
     return c
 

时间复杂度 ​O(n\log_2n)，空间复杂度 O(n)​，稳定，顺序存储和链式存储

基数排序

不基于比较

借助“分配”和“收集”两种操作对单逻辑关键字进行排序，分为最高位优先 (MSD) 和最低位优先（LSD）。

内部排序算法比较和应用

应用考虑因素：

元素数目、元素大小、关键字结构及分布、稳定性、存储结构、辅助空间

  1. 若 n 较小时（n<=50），可采用直接插入排序或简单选择排序

    若 n 较大时，则采用快排、堆排或归并排序

  2. 若 n 很大，记录关键字位数较少且可分解，采用基数排序

  3. 当文件的 n 个关键字随机分布时，任何借助于“比较”的排序，至少需要 ​ 的时间

  4. 若初始基本有序，则采用直接插入或冒泡排序

  5. 当记录元素比较大，应避免大量移动的排序算法，尽量采用链式存储

动图演示：<https://visualgo.net/zh/sorting>

CharlesWu123
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
常见排序：冒泡排序、快速排序、归并排序、直接插入排序、希尔排序、选择排序、堆排序
weixin_45481403的博客
11-28 990
常见的排序算法可分为以下四种七类： 一、直接插入排序： 将整列需要排序的数字分为有序区间和无序区间，每次从无序区间取出一个数，插入到有序区间里。 【例】 原始序列：3 8 5 2 7 因为单独的一个数字是有序的，所以第一次有序区间只有数字3，无序区间从数字8开始一直到最后；可定义 “ i ” 从下标为1的位置开始遍历。 每次插入排序过程如下： 代码实现： public sta...
八大排序（直接插入排序、希尔排序、选择排序、堆排序、冒泡排序、快速排序、归并排序、计数排序）
qq_44872688的博客
11-23 1260
文章目录一、冒泡排序二、插入排序 一、冒泡排序 原理是，假设我们要实现从小到大的排序，有 你个数，则从第一个元素开始，往后相邻的数互相比较，创建一个变量，利用变量把两个数中较大的换到后面，这样第一轮过后，最大的数就会被放到后面，然后从第一个元素继续比到第 n-1个元素，剩余数组中最大的元素会被放到第n-1位，经过n-1轮后，整个排序就完成了。 实现代码如下： var a = [1,2,3,43,21,5,0]; console.log("排序前的数组为："); for(var k of a){ c
万字总结——常见的八大排序算法（插入排序、希尔排序、选择排序、堆排序、冒泡排序、快速排序、归并排序、计数排序）
m0_73900674的博客
09-26 2077
二万字排序总结超详解（图示 + 动图）
冒泡排序、选择排序、插入排序、希尔排序、快速排序、归并排序、基数排序图解分析和代码演示
qq_45976767的博客
04-03 672
排序算法 1、内部排序：指将需要处理的的所有数据都需要加载到内部存储中进行排序 2、外部排序：数据量过大，无法将全部加载到内存中，需要借助外部存储进行排序 冒泡排序 介绍 通过从前往后遍历序列，依次比较相邻元素的值，将值较大的逐渐移动到最后 一共进行数组大小-1循环 每一趟排序的次数都在减少 优化，在某一次排序中没有发生一次交换，就可以提前结束循环 图解 代码实现 /** * 冒泡排序 */ public class BobbleSort { public static voi
常见排序算法(插入排序，希尔排序，选择排序，堆排序，冒泡排序，快速排序，归并排序，计数排序，基数排序，桶排序）
2301_80288511的博客
04-21 2272
常见排序算法(插入排序，希尔排序，选择排序，堆排序，冒泡排序，快速排序，归并排序，计数排序，基数排序，桶排序）
比较排序总结——直接插入排序，希尔排序，选择排序，堆排序，冒泡排序，快速排序，归并排序
qingdou_aixuexi的博客
09-18 1278
一，直接插入排序 插入排序（Insertion Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。 步骤： 从第一个
冒泡排序；直接插入排序；希尔排序；快速排序；堆排序；归并排序；基数排序
最新发布
05-16
这里我们将深入探讨七种经典的排序算法：冒泡排序、直接插入排序、希尔排序、快速排序、堆排序、归并排序以及基数排序。 1. **冒泡排序**： 冒泡排序是最基础的排序算法之一。它通过重复遍历待排序的数据序列，...
Java实现八个常用的排序算法：插入排序、冒泡排序、选择排序、希尔排序等
09-03
堆排序是利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子节点的键值或索引总是小于（或者大于）它的父节点。堆排序的时间复杂度为O(nlogn)，原地排序，但...
C++实现八个常用的排序算法：插入排序、冒泡排序、选择排序、希尔排序等
09-03
在本文中，我们将深入探讨C++实现的八种常见的排序算法，它们分别是插入排序、冒泡排序、选择排序、希尔排序、快速排序、归并排序、堆排序和LST基数排序。这些排序算法在计算机科学中有着广泛的应用，是理解和掌握...
C# 插入排序 冒泡排序 选择排序 快速排序 堆排序 归并排序 基数排序 希尔排序
10-15
在编程领域，排序算法是数据结构与算法中的基础部分，对于C#开发者来说，理解并掌握各种排序算法的实现和性能至关重要。以下是对标题和描述中提到的几种排序算法的详细解析： 1. **插入排序**（Insertion Sort）： ...
课设-内部排序算法比较 包括冒泡排序、直接插入排序、简单选择排序、快速排序、希尔排序、归并排序和堆排序.zip
04-27
直接插入排序（Straight Insertion Sort）是一种简单且古老的排序算法，其基本思想是将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录数增1的有序表。12 直接插入排序的算法过程如下： 假设待排序...
7大排序算法实现程序（快速排序，冒泡排序，选择排序，归并排序，插入排序，希尔排序，堆排序）
06-21
7大排序算法（快速排序，冒泡排序，选择排序，归并排序，插入排序，希尔排序，堆排序）实现源码
常见的4种排序方法（冒泡排序、插入排序、归并排序、快速排序）
Yangchenju的博客
08-06 4858
前面课时中，我们学习了分治法的思想，以及二分查找的实现方法。我们讲到，二分查找要求原数组必须有序。其实，由无序到有序，这是算法领域最常见的一类问题，即排序问题。本课时，我们就来学习 4 种常见的排序算法，包括冒泡排序、插入排序、归并排序以及快速排序。此外，我们还会对这 4 种排序算法的优劣势进行详细地对比分析。 什么是排序问题 排序，就是让一组无序数据变成有序的过程。 一般默认这里的有序都是从小到大的排列顺序。下面我们先来讲讲，如何判断不同的排序算法的优劣。 衡量一个排序算法的优劣，我们主要会从以下 3 个
C之插入排序
Dawnfox
03-03 401
研后重新学习数据结构。#include typedef int ElemType; void InsertSort(ElemType A[],int n); void BInsertSort(ElemType A[],int n); void ShellSort(ElemType A[],int n); void print_arr(ElemType A[],int n); int main()
插入排序，选择排序，，希尔排序，冒泡排序，归并排序，快速排序，堆排序，基数排序...
weixin_34072458的博客
10-31 313
无 转载于:https://www.cnblogs.com/bianjing/p/9884066.html
排序算法(直接插入、折半插入、希尔排序、冒泡排序、快速排序、简单选择排序、堆排序、归并排序、基数类排序)
热门推荐
xjtuse123的博客
08-16 1万+
目录 一、概述 二、算法复杂度 三、插入类排序 1.直接插入排序 2.折半插入排序 3.希尔排序 四、交换类排序 1.冒泡排序 2.快速排序 五、选择类排序 1.简单选择排序 2.堆排序 六、归并排序 1.二路归并排序 七、基数排序 1.基数...
插入排序、冒泡排序、选择排序、希尔排序、归并排序、快速排序、堆排序、基数排序的C++实现
qq_42234461的博客
11-28 817
头文件help.h用于生成数组 #include &lt;iostream&gt; #include &lt;ctime&gt; #include &lt;string&gt; using namespace std; /*生成随机数组，以供测试*/ int* makeRamdomArr(int count, int ldomain, int rdomain) { int *arr = ne...
插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序
qq_43541242的博客
07-24 582
排序算法可以分为内部排序和外部排序。 内部排序是数据记录在内存中进行排序。 而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。 常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。 内部排序算法 1. ...
各种排序算法总结和比较
11-30 3004
排序算法可以说是一项基本功，解决实际问题中经常遇到，针对实际数据的特点选择合适的排序算法可以使程序获得更高的效率，有时候排序的稳定性还是实际问题中必须考虑的，这篇博客对常见的排序算法进行整理，包括：插入排序、选择排序、冒泡排序、快速排序、堆排序、归并排序、希尔排序、二叉树排序、计数排序、桶排序、基数排序。 代码都经过了CodeBlocks的调试，但是很可...
C语言内排序算法详解：快速排序、插入与希尔排序
本文档详细介绍了几种基本的内部排序算法，着重于选择、冒泡、插入、快速、堆排序以及归并排序。 首先，内部排序与外部排序的区别在于前者处理内存中的数据，后者则针对大量数据，超出内存范围，需要借助外存。对于...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

CharlesWu123

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值