内排序及时间复杂度分析-插入排序&选择排序&交换排序&归并排序&分配和索引排序对比...

最新推荐文章于 2022-04-06 08:47:32 发布
最新推荐文章于 2022-04-06 08:47:32 发布
阅读量266 收藏 1
点赞数
文章标签： 数据结构与算法 shell
原文链接：https://juejin.im/post/5b4b5f88e51d451945581464
版权

基本概念

什么是排序？

  • 排序
    • 将序列中的记录按照排序码顺序排列起来
    • 排序码域的值具有不减(或不增)的顺序
  • 内排序
    • 整个排序过程在内存中完成
  • 给定一个序列 R = { r1, r2, ...，rn }
    • 其排序码分别为 k = { k1, k2, ...，kn }
  • 排序的目的:将记录按排序码重排
    • 形成新的有序序列R’={r’1,r’2,...，r’n}
    • 相应排序码为 k’= { k’1, k’2, ...，k’n }
  • 排序码的顺序
    • 其中 k’1 ≤ k’2 ≤ ... ≤ k’n，称为不减序
    • 或 k’1 ≥ k’2 ≥ ... ≥ k’n ，称为不增序

排序的稳定性

  • 稳定性
    • 存在多个具有相同排序码的记录
    • 排序后这些记录的相对次序保持不变
  • 排序稳定性的意义
    • 保持第一关键字相同的数据排序前后顺序不变，若不稳定的排序要做到这一点，则需要增加第二个关键字。

插入排序

直接插入排序算法

template <class Record>
void ImprovedInsertSort (Record Array[], int n){ //Array[] 为待排序数组，n 为数组长度
Record TempRecord; // 临时变量
for (int i=1; i<n; i++){ // 依次插入第 i 个记录
TempRecord = Array[i];
//从 i 开始往前寻找记录 i 的正确位置
int j = i-1;
//将那些大于等于记录 i 的记录后移
while ((j>=0) && (TempRecord < Array[j])){
Array[j+1] = Array[j];
j = j - 1; }
//此时 j 后面就是记录 i 的正确位置，回填
Array[j+1] = TempRecord; }
}
复制代码
算法分析
  • 稳定
  • 空间代价:Θ(1)
  • 时间代价:
    • 最佳情况:n-1次比较，2(n-1)次移动，Θ(n)
    • 最差情况:Θ(n2)
      • 比较次数为n(n-1)/2 = O(n2)
      • 移动次数为 (n-1)(n-4)/2 = O(n2)
  • 平均情况:Θ(n2)
  • 性质：
    • 序列本身有序的话时间代价为O（N）
    • 对于短序列比较有效

Shell排序

算法思想
  • 先将序列转化为若干小序列，然后在小序列里面插入排序
  • 逐步增加小序列规模，从而减少小序列个数
  • 最后对整个序列扫尾直接插入排序
“增量每次除以2”的Shell排序
template <class Record>
void ShellSort(Record Array[], int n) {
// Shell排序，Array[]为待排序数组，n为数组长度
int i, delta;
// 增量delta每次除以2递减
for (delta = n/2; delta>0; delta /= 2)
for (i = 0; i < delta; i++)
// 分别对delta个子序列进行插入排序 //“&”传 Array[i]的地址，数组总长度为n-i ModInsSort(&Array[i], n-i, delta);
// 如果增量序列不能保证最后一个delta间距为1 // 可以安排下面这个扫尾性质的插入排序
// ModInsSort(Array, n, 1);
}

template <class Record> // 参数delta表示当前的增量 void ModInsSort(Record Array[], int n, int delta) {
int i, j;
// 对子序列中第i个记录，寻找合适的插入位置 for (i = delta; i < n; i += delta)
                                         // j以dealta为步长向前寻找逆置对进行调整 for(j=i;j>=delta;j-=delta) {
if (Array[j] < Array[j-delta]) // 逆置对 swap(Array, j, j-delta);// 交换
else break; }
                                          }
复制代码
算法分析
  • 不稳定
  • 空间代价O（1）
  • 时间代价O（n2)
  • 选取的增量并不互质，实际上上一轮子序列都排序过了，导致效率过低
  • 选取合适的增量序列，可以是时间接近于O（n）
Hibbard 增量序列
  • Hibbard 增量序列
    • {2k -1，2k-1 -1，...，7，3，1}
  • Shell(3) 和 Hibbard 增量序列的 Shell 排序的效率可以达到 Θ(n3/2)
Shell最好的代价
  • 呈 2p3q 形式的一系列整数: – 1, 2, 3, 4, 6, 8, 9, 12
  • Θ(nlog2n)

选择排序

  • 直接选择排序
  • 堆排序

直接选择排序

每次从剩下的堆中选择最小的

template <class Record>
void SelectSort(Record Array[], int n) {
// 依次选出第i小的记录，即剩余记录中最小的那个
for (int i=0; i<n-1; i++) {
// 首先假设记录i就是最小的 int Smallest = i;
// 开始向后扫描所有剩余记录 for (int j=i+1;j<n; j++)
// 如果发现更小的记录，记录它的位置 if (Array[j] < Array[Smallest])
Smallest = j;
// 将第i小的记录放在数组中第i个位置（从而导致不稳定）
swap(Array, i, Smallest);  
} }
复制代码
算法分析
  • 不稳定（因为会交换位置）
  • 空间代价O（1）
  • 时间代价
    • 比较次数O（n2)
    • 交换次数n-1
    • 总时间代价O（n2)

堆排序

  • 选择类内排序 由于直接选择排序是从剩余记录中线性地去查找最大记录所以效率较低，我们可以采用最大堆来实现，效率会更高
  • 选择类外排序（这一部分后面讨论）
    • 置换选择排序
    • 赢者树、败方树
template <class Record>
void sort(Record Array[], int n){
int i;
// 建堆
MaxHeap<Record> max_heap
= MaxHeap<Record>(Array,n,n); // 算法操作n-1次，最小元素不需要出堆 for (i = 0; i < n-1; i++)
// 依次找出剩余记录中的最大记录，即堆顶
max_heap. RemoveMax(); }
复制代码
算法分析
  • 不稳定（Siftdown的过程会有可能导致相同元素出入序列不一致）
  • 建堆O（n）
  • 删除堆顶O（log n）
  • 总时间代价O（nlog n）
  • 空间代价O（1）
  • 在只需得到最大或最小的一部分元素时有优势（部分排序）

交换排序

  • 冒泡排序
  • 快速排序

冒泡排序

  • 算法思想
    • 不停地比较相邻的记录，如果不满足排序要求，就 交换相邻记录，直到所有的记录都已经排好序
  • 检查每次冒泡过程中是否发生过交换，如果没 有，则表明整个数组已经排好序了，排序结束
    • 避免不必要的比较
template <class Record>
void BubbleSort(Record Array[], int n) {
bool NoSwap; // 是否发生了交换的标志 
int i, j;
for (i = 0; i < n-1; i++) {
    NoSwap = true;
    for (j = n-1; j > i; j--){
    if (Array[j] < Array[j-1]) {
        swap(Array, j, j-1); 
        NoSwap = false
    }
    if (NoSwap)
    return; 
    }
} }
复制代码
算法分析
  • 稳定
  • 空间代价O（1）
  • 时间代价
    • 比较次数
      • 最少O(n)
      • 最多O(n2)
    • 交换次数 平均O(n2)
  • 结论
    • 最大平均为O(n2)
    • 最小为O（n）
    • 冒泡排序和直接选择排序从时间复杂度上来讲是一样的，都是O(n^2)的排序算法，但是因为冒泡排序是每次交换相邻两个，所以在常数上可能要稍微大一点。冒泡排序是稳定的，直接选择排序是不稳定的。

快速排序

  • 思想（分治策略）
    • 选择轴值(pivot)
    • 将序列划分为两个子序列L和R，使得L中所有记录都小于或等于轴值，R中记录都大于轴值
    • 对子序列L和R递归进行快速排序
  • 轴值选择
    • 尽可能使 L, R 长度相等
    • 选择策略:
      • 选择最左边记录
      • 随机选择
      • 选择平均值
template <class Record>
void QuickSort(Record Array[], int left, int right) {
    if (right <= left)     // 只有0或1个记录，就不需排序 
        return;
    int pivot = SelectPivot(left, right); // 选择轴值
    swap(Array, pivot, right); // 轴值放到数组末端 
    pivot = Partition(Array, left, right); // 分割后轴值正确 
    QuickSort(Array, left, pivot-1); // 右子序列递归快排 
    QuickSort(Array, pivot +1, right); // 右子序列递归快排
}
int SelectPivot(int left, int right) {
    return (left+right)/2;// 选中间记录作为轴值
}

//分割函数
template <class Record>
int Partition(Record Array[], int left, int right) { // 分割函数，分割后轴值已到达正确位置
    int l = left; // l 为左指针
    int r = right; // r 为右指针
    Record TempRecord = Array[r];   // 保存轴值
    while (l != r) { // l, r 不断向中间移动，直到相遇
    // l 指针向右移动，直到找到一个大于轴值的记录 
        while (Array[l] <= TempRecord && r > l)
            l++;
        if (l < r) { // 未相遇，将逆置元素换到右边空位
            Array[r] = Array[l];
        r--; // r指针向左移动一步 
    }
    // r 指针向左移动，直到找到一个大于轴值的记录 
    while (Array[r] >= TempRecord && r > l)
        r--;
    if (l < r) {                 // 未相遇，将逆置元素换到左空位
        Array[l] = Array[r];
        l++; // l 指针向右移动一步 }
    } //end while
    Array[l]=TempRecord; //把轴值回填到分界位置l上
    return l;
    // 返回分界位置l
}
复制代码
时间代价
  • 不稳定（轴值的选择会影响到）
  • 最差情况:
    • 时间代价:Θ(n2)
    • 空间代价:Θ(n)
  • 最佳情况:
    • 时间代价:Θ(nlog n)
    • 空间代价:Θ(log n)
  • 平均情况:
    • 时间代价:Θ(nlog n)
    • 空间代价:Θ(log n)
快速排序优化
  • 轴值选择 RQS
  • 小子串不递归 (比如阈值 28， 采用直接插入排序等)
  • 消除递归(用栈，队列)
  • 更多参见这篇文章
  • 快速排序比大部分排序算法都要快。尽管我们可以在某些特殊的情况下写出比快速排序快的算法，但是就通常情况而言，没有比它更快的了。快速排序是递归的，对于内存非常有限的机器来说，它不是一个好的选择。

归并排序

归并排序思想

  • 划分为两个子序列
  • 分别对每个子序列归并排序
  • 有序子序列合并

两路归并排序

#include<iostream>
using namespace std;

// 两个有序子序列都从左向右扫描，归并到新数组
template <class Record>
void Merge(Record Array[], Record TempArray[], int left ,int right,int middle){
    int i,j,index1,index2;
    for(j=left;j<=right;j++)
        TempArray[j] = Array[j]; //放入临时数组
    i = left;
    index1 = left;
    index2 = middle+1;
    while(index1<=middle && index2<=right){
        if(TempArray[index2] < TempArray[index1])
            Array[i++] = TempArray[index2++];
        else
            Array[i++] = TempArray[index1++];
    }
    while(index1<=middle) //复制剩下的左序列
        Array[i++] = TempArray[index1++];
    while(index2<=right) //复制剩下的右序列
        Array[i++] = TempArray[index2++];
}

template <class Record>
void MergeSort(Record Array[], Record TempArray[], int left, int right) {
// Array为待排序数组，left，right两端
    int middle;
    if (left < right) { // 否则序列中只有0或1个记录，不用排序
        middle = (left + right) / 2; // 平分为两个子序列 
        // 对左边一半进行递归 
        MergeSort(Array,TempArray,left,middle);
        // 对右边一半进行递归
        MergeSort(Array, TempArray,middle+1,right);
        Merge(Array, TempArray,left,right,middle); // 归并 
    }
}

int main(){
    int arr[] = {1,9,7,10,5,8,4,2,11,6};
    int tempArr[10];
    MergeSort(arr,tempArr,0,9);
    for(int i:arr)
        cout<<i<<" ";
    cout<<endl;
    return 1;
}
复制代码

归并算法优化

  • 同优化的快速排序一样，对基本已排序序 列直接插入排序
  • R.Sedgewick优化:归并时从两端开始 处理，向中间推进，简化边界判断
#include<iostream>
using namespace std;
#define THRESHOLD 28

template <class Record> 
void InsertSort(Record *p,int len){
    Record TempRecord; // 临时变量
    for (int i=1; i<len; i++){ // 依次插入第 i 个记录
        TempRecord = *(p+i);
        //从 i 开始往前寻找记录 i 的正确位置
        int j = i-1;
        //将那些大于等于记录 i 的记录后移
        while ((j>=0) && (TempRecord < *(p+j))){
            *(p+j+1) = *(p+j);
            j = j - 1; 
        }
        *(p+j+1) = TempRecord; 
    }
}

template <class Record> 
void ModMerge(Record Array[],Record TempArray[],int left,int right,int middle) {
    int index1,index2; // 两个子序列的起始位置 
    int i,j,k ;
    for (i = left; i <= middle; i++)
        TempArray[i] = Array[i]; // 复制左边的子序列 
    for (j = 1; j <= right-middle; j++) // 颠倒复制右序列
        TempArray[right-j+1] = Array[j+middle];
    for (index1=left, index2=right, k=left; k<=right; k++)
        if (TempArray[index1] <= TempArray[index2])
            Array[k] = TempArray[index1++];
        else
            Array[k] = TempArray[index2--];
}

template <class Record>
void ModMergeSort(Record Array[], Record TempArray[], int left, int right) { // Array为待排序数组，left，right两端
    int middle;
    if (right-left+1 > THRESHOLD) { // 长序列递归
        middle = (left + right) / 2; // 从中间划为两个子序列 
        ModMergeSort(Array, TempArray ,left,middle); // 左 
        ModMergeSort(Array, TempArray ,middle+1,right);// 右 
        // 对相邻的有序序列进行归并
        ModMerge(Array, TempArray ,left,right,middle); // 归并 
    }
    else 
        InsertSort(&Array[left],right-left+1);   // 小序列插入排序
}

 

int main(){
    int arr[] = {1,9,7,10,5,8,4,2,11,6,11,12,13,14,15,16,17,18,19,28,17,14,12,13,16,36,27,29,20,4,2,11,6,11,12,13,14,15,16,17,18,19,28};
    int tempArr[43];
    ModMergeSort<int>(arr,tempArr,0,42);
    for(int i:arr)
        cout<<i<<" ";
    cout<<endl;
    return 1;
}
复制代码
算法分析
  • 空间代价O(n)
  • 最大，最小，平均时间代价O(nlog n)
  • 普通归并排序是稳定的，因为合并的时候是按照顺序合并。Sedgewick采用一个正序一个逆序合并所以相同值会颠倒顺序。所以是不稳定的。
  • Sedgewick算法需要更多地元素之间的比较，但是普通算法需要判断边界，所以比较次数更多。总体来说Sedgewick 算法更优。

分配排序和基数排序

  • 不需要进行纪录之间两两比较
  • 需要事先知道记录序列的一些 具体情况

桶排序

  • 事先知道序列中的记录都位于某个小区间段 [0, m) 内
  • 将具有相同值的记录都分配到同一个桶中，然后依次按照编号从桶中取出记录，组成一个有序序列
template <class Record> 
void BucketSort(Record Array[], int n, int max) { 
    Record *TempArray = new Record[n]; // 临时数组
    int *count = new int[max]; 
    int i;
    for (i = 0; i < n; i++)
        TempArray[i] = Array[i]; 
    for (i = 0; i < max; i++)
        count[i] = 0;
    for (i = 0; i < n; i++)
        count[Array[i]]++; 
    for (i = 1; i < max; i++)
        count[i] = count[i-1]+count [i]; // c[i]记录i+1的起址
    for (i = n-1; i >= 0; i--) // 尾部开始，保证稳定性 
        Array[--count[TempArray[i]]] = TempArray[i];
}
复制代码
算法分析
  • 数组长度为 n, 所有记录区间 [0, m) 上
  • 时间代价:
    • 统计计数:Θ(n+m) ， 输出有序序列时循环 n 次
    • 总的时间代价为 Θ(m+n)
    • 适用于m相对于n很小的情况，也就是适用于小区间，但m不要超过nlogn比较好,因为桶式排序的算法复杂度为O(n+m),如果m过大则换用其它方法比较好.
  • 空间代价:
    • m 个计数器，长度为 n 的临时数组，Θ(m+n)
  • 稳定

基数排序

  • 桶式排序只适合 m 很小的情况
  • 基数排序:当m很大时，可以将一个记录的值即排序码拆分为多个部分来进行比较
例子

例如:对 0 到 9999 之间的整数进行排序

  • 将四位数看作是由四个排序码决定，即千、百 、十、个位，其中千位为最高排序码，个位为 最低排序码。基数 r=10。
  • 可以按千、百、十、个位数字依次进行4次桶 式排序
  • 4趟分配排序后，整个序列就排好序了
低位优先法
  • LSD，Least Significant Digit first
  • 从最低位 k0 开始排序
  • 对于排好的序列再用次低位 k1 排序;
  • 依次重复，直至对最高位 kd-1 排好序后， 整个序列成为有序的
  • 分、收;分、收;...;分、收的过程 – 比较简单，计算机常用
基数排序的实现
  • 主要讨论 LSD(低位优先法）
    • 基于顺序存储
    • 基于链式存储
  • 原始输入数组R的长度为n，基数为 r，排序码个数为 d

基于数组的基数排序

template <class Record>
void RadixSort(Record Array[], int n, int d, int r) {
    Record *TempArray = new Record[n];
    int *count = new int[r]; int i, j, k;
    int Radix = 1; // 模进位，用于取Array[j]的第i位 
    for(i=1;i<=d;i++) { //对第i个排序码分配
        for (j = 0; j < r; j++)
            count[j] = 0; // 初始计数器均为0
    for(j=0;j<n;j++){ //统计每桶记录数 
        k = (Array[j] / Radix) % r; // 取第i位 
        count[k]++; // 相应计数器加1
    }

    for (j = 1; j < r; j++) // 给桶划分下标界 
        count[j] = count[j-1] + count[j];
    for(j=n-1;j>=0;j--) { //从数组尾部收集 
        k=(Array[j]/Radix)%r; //取第i位 
        count[k]--; // 桶剩余量计数器减1 
        TempArray[count[k]] = Array[j]; // 入桶
    }
    for (j = 0; j < n; j++) // 内容复制回 Array 中
        Array[j] = TempArray[j];
        Radix *= r; // 修改模Radix
    } 
}
复制代码
顺序基数排序代价分析
  • 空间代价:
    • 临时数组, n
    • r 个计数器
    • 总空间代价 Θ(n+r)
  • 时间代价
    • 桶式排序:Θ(n+r)
    • d 次桶式排序
    • Θ(d·(n+r))
基于静态链的基数排序
  • 将分配出来的子序列存放在 r 个 (静 态链组织的) 队列中
  • 链式存储避免了空间浪费情况
链式基数排序算法代价分析
  • 空间代价
    • n 个记录空间
    • r 个子序列的头尾指针
    • Θ(n + r)
  • 时间代价
    • 不需要移动记录本身， 只需要修改记录的 next 指针
    • Θ(d·(n+r))
template <class Record>
void RadixSort(Record *Array, int n, int d, int r) {
    int i, first = 0; // first指向第一个记录 
    StaticQueue *queue = new StaticQueue[r];
    for (i = 0; i < n-1; i++)
        Array[i].next = i + 1; // 初始化静态指针域 
    Array[n-1].next = -1; // 链尾next为空
    // 对第i个排序码进行分配和收集，一共d趟 
    for(i=0;i<d;i++) {
        Distribute(Array, first, i, r, queue);
        Collect(Array, first, r, queue); 
    }
    delete[] queue;
    AddrSort(Array, n, first); // 整理后，按下标有序 
}

template <class Record>
void Distribute(Record *Array, int first, int i, int r, StaticQueue *queue) {
    int j, k, a, curr = first;
    for (j = 0; j < r; j++) 
        queue[j].head = -1;
    while (curr != -1) { // 对整个静态链进行分配
        k = Array[curr].key;
    for (a = 0; a < i; a++) // 取第i位排序码数字k
        k = k / r; 
    k = k % r;
    if (queue[k].head == -1) // 把数据分配到第k个桶中 
        queue[k].head = curr;
    else 
        Array[queue[k].tail].next = curr; 
    queue[k].tail = curr;
    curr = Array[curr].next;   // curr移动，继续分配
    } 
}

template <class Record>
void Collect(Record *Array, int& first, int r, StaticQueue *queue) {
    int last, k=0; // 已收集到的最后一个记录 
    while (queue[k].head == -1) 
        k++; // 找到第一个非空队 
    first = queue[k].head; 
    last = queue[k].tail;
    while (k < r-1) { // 继续收集下一个非空队列
        k++;
        while (k < r-1 && queue[k].head == -1)
            k++;
        if(queue[k].head!=-1) {//试探下一个队列
            Array[last].next = queue[k].head;
            last = queue[k].tail; 
        } 
    }
    Array[last].next = -1;
}
复制代码
线性时间整理静态链表
template <class Record>
void AddrSort(Record *Array, int n, int first) {
    int i, j;
    j = first; // j待处理数据下标
    Record TempRec;
    for(i=0;i<n-1;i++) {//循环，每次处理第i个记录
        TempRec = Array[j]; // 暂存第 i 个的记录 Array[j] swap(Array[i], Array[j]);
        Array[i].next = j;
        j = TempRec.next; 
        while (j <= i)
            j = Array[j].next; 
    }
}
复制代码
基数排序效率
  • 时间代价为Θ(d·n)， 实际上还是 Θ(nlog n)
  • 基数排序中应该是d>=logrm，m为排序码中的最大数。实际测试的时候当n>=10亿时，在64bit系统下基数排序还是有优势的。甚至比introsort还要快一些。只有排序码中元素两两不相同时，才有m=n。

索引排序

在排序时，若是数据很复杂，对数据的移动显然是费时的。若把数据移动改为索引(或指针)移动，则减少了操作复杂度。索引排序，也叫地址排序，就是这种排序思想。

索引含义

根据索引的含义不同，索引排序的算法上也主要分为两种。

  • index[i]为array[i]最终在有序序列中的位置。
  • index[i]为位置i上最终应存放元素的下标。即最终元素按array[index[0]]、array[index[1]]……有序。
索引排序的适用性
  • 一般的排序方法都可以
    • 那些赋值(或交换)都换成对index 数组的赋值(或交换)
  • 举例:插入排序
插入排序的索引地址排序版本
template<class Record>
void AddrSort(Record Array[], int n) {
           //n为数组长度
int *IndexArray = new int[n], TempIndex; int i,j,k;
    Record TempRec;
    for (i=0; i<n; i++)
        //只需一个临时空间
        IndexArray[i] = i; 
        for (i=1; i<n; i++)
        // 依次插入第i个记录
        // 依次比较，发现逆置就交换
            for (j=i; j>0; j--)
                if ( Array[IndexArray[j]] <Array[IndexArray[j-1]])
                    swap(IndexArray, j, j-1);
                else break;
        //此时i前面记录已排序
        for(i=0;i<n;i++) { // 调整为按下标有序
            j= i;
            TempRec = Array[i];
            while (IndexArray[j] != i) {
                k=IndexArray[j]; 
                Array[j]=Array[k]; 
                IndexArray[j] = j; 
                j = k;
            }
            Array[j] =TempRec; 
            IndexArray[j] = j;
        } 
}
复制代码

总结

  • 时间复杂度（试验时间）

  • 稳定性
    • 对于稳定的排序算法，在排序前将数据随机打乱，就可以达到不稳定的效果了。
    • 对于不稳定的排序算法，可以将数据扩充出一个域，用于记录初始下标，当数据关键值相同时，比较下标大小，这样排序算法就是稳定的了。
weixin_33670786
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
排序总结，插入排序 选择排序 交换排序 归并排序 计数排序 时间复杂度空间复杂度稳定性详解
baidu_37964044的博客
05-25 2003
排序大体分为两类：比较排序和非比较排序一    各个排序的基本实现1.直接插入排序和希尔排序//整体思路：往一段有序区间插入元素，end标记为有序区间的最后一个元素下标，要插入的元素下标为end+1此处就称tmp，先把他保存起来，（否则可能被覆盖）如果end+1这个元素 //比有序区间的小，就把有序区间元素依次向后移动，移动结束条件有两个，1.end变为-1,2.有序区间内找到比tmp小的数。 v...
插入排序、归并排序、快速排序的比较和分析
rose_gong的专栏
02-23 1439
插入排序、归并排序、快速排序的比较和分析 三者的时间复杂度： 平均情况，依次是O(n^2), O(nlogn), O(nlogn) 最好情况，依次是O(n), O(nlogn), O(nlogn) 最差情况，依次是O(n^2), O(nlogn), O(n^2) 三者的空间复杂度：依次是O(1), O(n), O(1) 1）插入排序 #include #includ
插入排序，选择排序，交换排序，归并排序，基数排序等算法 的时间复杂度及稳定性总结
baoziqyp的博客
04-06 936
算法时间复杂度
选择排序、冒泡排序、归并排序、快速排序、插入排序的算法原理与比较
weixin_40933866的博客
12-01 1594
一、选择排序 （1）算法分析 1、从第一个元素开始，分别与后面的元素向比较，找到最小的元素与第一个元素交换位置； 2、从第二个元素开始，分别与后面的元素相比较，找到剩余元素中最小的元素，与第二个元素交换； 3、重复上述步骤，直到所有的元素都排成由小到大为止。 （2）算法实现 /* * 选择排序 * 需要比较n（n-1）/2次； * 选择排序的算法复杂度仍为O（n*n）； */...
插入排序、归并排序（源代码）以及复杂度分析
03-20
插入排序算法、归并排序算法的c++实现，以及递归算法的复杂性分析文档。详情可以参考我的博客，http://blog.csdn.net/zhongkelee
JavaScript-使用javascript开发的排序算法-sorting.zip
最新发布
02-25
在这个"JavaScript-使用javascript开发的排序算法-sorting.zip"压缩包中，很可能是包含了各种常见的排序算法实现，比如冒泡排序、插入排序、选择排序、快速排序、归并排序以及堆排序等。 1. **冒泡排序**：冒泡排序...
Java排序代码.docx-综合文档
05-21
在给定的文件中，我们看到了Java实现的四种基本排序算法：插入排序、冒泡排序、选择排序和Shell排序。这些排序算法是计算机科学中基础且重要的数据处理方法，广泛应用于各种场景，如数据库索引、数据分析等。下面将...
Java常用排序算法&程序员必须掌握的8大排序算法+二分法查找
08-03
7. **希尔排序**：改进的插入排序，通过比较距离较远的元素来减少交换次数，提高了效率。 8. **计数排序**：非基于比较的排序，适用于整数排序，时间复杂度为O(n)，但不适合大数据范围。 接下来，我们关注二分法...
js实现直接选择排序，前端必会
09-20
此外，通过学习和实践直接选择排序，开发者可以更好地理解和对比其他更高效的排序算法，如冒泡排序、插入排序、快速排序等，这对于提升算法分析和解决问题的能力至关重要。 总的来说，掌握JavaScript实现的直接选择...
Python排序搜索基本算法之选择排序实例分析
09-21
2. **效率**：虽然选择排序易于理解和实现，但由于其O(n^2)的时间复杂度，它并不适合大规模数据集的排序。 3. **应用**：选择排序通常用于教学目的或者小型数据集的排序任务。 #### 五、扩展阅读 对于想要进一步...
【算法】图解 选择排序、插入排序、归并排序、快速排序的思想及优化方案，附代码
winrh的博客
03-21 355
1.插入排序 ①一般思路： ②（优化）减少交换次数 代码： public class InsertionSort {//已优化 public static void insertionSort(int[] a,int left , int right){//下标是闭区间 for(int i=left+1; i<=right; i++){ int temp = a...
交换排序之冒泡排序优化源码及时间复杂度
scuyxi的专栏
04-20 1088
常见的交换排序包括冒泡排序和快速排序。用于显示的代码：show.cpp#include <iostream>using namespace std;template <class T>void showww(T* t, int n) { for(int i=0; i<n; i++) cout << *(t+i) << endl; }冒泡排序bubble.cpptemplate <
插入排序、选择排序、快速排序以及归并排序（附Python代码）
走过路过不要错过
09-02 915
排序算法基本原理以及复杂度等知识点可跳转至该博客了解https://www.cnblogs.com/onepixel/p/7674659.html，本博客主要对排序算法性能进行对比以及记录对比过程发现的问题 1. 插入排序和选择排序的对比 1.1 插入排序：从列表第一个元素 List[0] 开始每次取出列表一个元素，与该元素的前面元素进行比较，如果前面元素比该元素大，则把前面元素后移，直到前面元素不比该元素大，则插入。 插入排序示例 lst = [1,4,2,7,5] -------------.
交换排序之快速排序原理、源码及时间、空间复杂度
scuyxi的专栏
04-21 697
快速排序的原理：分治策略和递归分治策略分治的基本思想是将原问题分解为若干与原问题结构相似的小问题，递归地解决这些小问题，小问题的解就组合为原问题的解。基本方法 选基准 基准放中间，划分为左右两个区域（左小又大） 再递归地采用该方法分别解决左右两个区域的排序。 源码尽可能地减少递归调用的次数//quick_sort template <class T> int quick_sort(T* t, int
各排序算法介绍及时间复杂度分析
zephyr_wang的博客
02-11 1505
1.排序算法总览 通过任何键比较的算法，其时间复杂度不会优于nlgn。分配排序不是键比较算法。 2.交换排序（冒泡排序） 算法介绍 所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。 void swapsort(int a[]) { for(int i=1; i<=n; i++)...
交换排序
代码大湿的专栏
04-25 282
交换排序一般包括冒泡排序，时间复杂度为O（n*n）,快速排序,最好情况和平均情况时间复杂度是O（n*logn），最坏情况是O（n*n）。快速排序可以看我之前专门有一章是扎un们讲快速排序的
八大排序算法之交换排序
Monster_Girl
08-18 1257
在之前的两篇博客中，我们分别说了插入排序和选择排序，有兴趣的同学还可以戳链接去看看八大排序算法之选择排序、八大排序算法之插入排序。交换排序主要说得是冒泡排序和快速排序，思想就和名字一样是用交换来实现的。
Shell排序
zhj12399的博客
12-18 2882
Shell排序增量每次除以2递减的程序原理其它形式的Shell排序Hibbard增量序列Shell最好的代价 增量每次除以2递减的 程序 void ModInsSort(int array[], int n, int delta) { for (int i = delta; i < n; i += delta) { for (int j = i; j >= delta; j -= delta) { if (array[j]
内部排序算法详解：基数排序实例与性能分析
内部排序算法可以分为五类：插入排序、交换排序（如冒泡排序和快速排序）、选择排序（如简单选择排序和堆排序）、归并排序以及基数排序。这些算法在时间复杂度上有所不同，其中基数排序的时间复杂度为O(d·n)，d是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值