冒泡排序，选择排序，插入排序，希尔排序，堆排序，归并排序，快速排序实现

最新推荐文章于 2023-06-04 21:48:42 发布
最新推荐文章于 2023-06-04 21:48:42 发布
阅读量2.2k 收藏 30
点赞数 7
分类专栏： 算法学习 文章标签： 排序 快速排序 希尔排序 归并排序 冒泡排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LunaW/article/details/83383505
版权

前言：排序的定义

排序是计算机内经常进行的一种操作，其目的是将一组“无序”的记录序列调整为“有序”的记录序列。分内部排序和外部排序，若整个排序过程不需要访问外存便能完成，则称此类排序问题为内部排序。反之，若参加排序的记录数量很大，整个序列的排序过程不可能在内存中完成，则称此类排序问题为外部排序。内部排序的过程是一个逐步扩大记录的有序序列长度的过程

在这里插入图片描述

各种排序的时间复杂度

排序方法平均情况最好情况最坏情况辅助空间稳定性
冒泡排序O(n^2)O(n)O(n^2)O(1)稳定
简单选择排序O(n^2)O(n^2)O(n^2)O(1)稳定
直接插入排序O(n^2)O(n)O(n^2)O(1)稳定
希尔排序O(nlogn)~O(n^2)O(n^1.3)O(n^2)O(1)不稳定
堆排序O(nlogn)O(nlogn)O(nlogn)O(1)不稳定
归并排序O(nlogn)O(nlogn)O(nlogn)O(n)稳定
快速排序O(nlogn)O(nlogn)O(n^2)O(logn)~O(n)不稳定

各种排序的时间测试

排序方法5万数据50万数据100 万数据
优化冒泡排序8.183984s太慢太慢
简单选择排序2.682234s太慢太慢
直接插入排序1.496184s太慢太慢
希尔插入排序0.008725s0.120478s0.256040s
顶堆选择排序0.007705s0.097579s0.204354s
递归归并排序0.006827s栈溢出栈溢出
非递归并排序0.006666s0.080683s0.148987s
普通快速排序0.007767s0.086778s0.188957s
优化快速排序0.007215s0.087385s0.182627s

冒泡排序

  • 冒泡排序，通过两两比较相邻记录，依次浮出最小或者最大值
  • 优化方案：增加标志位判断是否已经有序，而不继续冒泡

在这里插入图片描述

实现代码
int BubbleSort1(SqList * L)
{
    int i, j;
    int flag = 1;
    for (i = 0; i < MAXSIZE - 1 && flag; i++) {
        flag = 0;   // 若标志位flag不为1，说明已经有序，这个时候就可以退出循环了
        for (j = MAXSIZE - 1; j > i; j--) {
            if (L->r[j] < L->r[j - 1]) {
                swap(L, j, j - 1);
                flag = 1;
            }
        }
    }
    return 0;
}

简单选择排序

  • 简单选择排序，通过n-i次关键字的比较，从n-i+1个记录中选出关键字最小的记录，然后与第i的位置替换
  • 通俗的讲就是，循环比较出后面最小的值依次放在前面去，就是从小到大了

在这里插入图片描述

实现代码
int SelectSort(SqList * L)
{
    int i, j, min;
    for (i = 0; i < MAXSIZE - 1; i++) {
        min = i;    // 将最小值的下标min指向当前下标i，起始位置
        for (j = i + 1; j < MAXSIZE; j++) {
            if (L->r[min] > L->r[j]) {
                min = j;    // 将最小值的下标min指向下标j，不停的比较，min指向当前循环最小值的下标
            }
        }
        if (i != min) {
            swap(L, i, min);    // 将最小值min交换到有序的i的位置，则每次循环以后，最小的值都依次被排序
        }
    }
    return 0;
}

直接插入排序

  • 直接插入排序，从第二个数开始循环，将当前数拿出来，依次将左边大于当前值的数向后移动一位，直到不大于当前值停止，然后将当前值插入空档

在这里插入图片描述

实现代码
int InsertSort(SqList * L)
{
    int i, j, flag;
    for (i = 1; i < MAXSIZE; i++) { // 从下标1开始，假设下标0已经有序
        if (L->r[i] < L->r[i - 1]) {    // 若当前的值小于前一位，则执行下面的操作
            flag = L->r[i]; // 将当前值记录到储存位
            for (j = i - 1; j >= 0 && L->r[j] > flag; j--) {    // 将左边大于当前值的依次向后移动一位，直到不大于为止
                L->r[j + 1] = L->r[j];
            }
            L->r[j + 1] = flag; // 插入储存位到空档
        }
    }
    return 0;
}

希尔排序

  • 希尔排序，直接插入排序的高效版，先使整个序列基本有序，然后再进行插入排序，大突破，打破O[n^2]
  • 使基本有序的方法就是把顺序循环变成跳跃方式的间隔循环，例如a[i]和a[i+1]比较变成a[i]和a[i+4]比较，然后慢慢缩小a[i]和a[i+2]比较，最后为1的时候就是插入排序了，这个过程在逐渐把排序变成基本有序

在这里插入图片描述

实现代码
int ShellSort(SqList * L)
{
    int i, j, flag;
    int increment = MAXSIZE;
    while (increment > 1) {
        increment = increment / 3 + 1;  // 增量，目前没有最好的增量，可以调整
        for (i = increment; i < MAXSIZE; i++) { // 跳跃调整序列为基本有序，increment等于1时为普通插入排序
            if (L->r[i] < L->r[i - increment]) {
                flag = L->r[i]; // 将当前值记录到储存位
                for (j = i - increment; j >= 0 && L->r[j] > flag; j -= increment) {
                    L->r[j + increment] = L->r[j];  // 记录后移，查找插入位置
                }
                L->r[j + increment] = flag; //插入储存位到空档
            }
        }
    }
    return 0;
}

堆排序，归并排序

  • 不做仔细讲解，这两个略麻烦
  • 堆排序利用二叉树构建大顶堆取根节点
  • 归并排序采用拆分比较，再归并的方式实现排序

在这里插入图片描述

实现代码
// 见完整代码

快速排序

  • 王者段位的排序，冒泡排序的升级版
  • 中心思想就是递归不断的把小的放左边，大的放右边，最后实现排序

在这里插入图片描述

实现代码
int QuickSort(SqList * L)
{
    QSort(L, 0, MAXSIZE - 1);
    return 0;
}

int QSort(SqList * L, int low, int high)
{
    int pivot;
    if (low < high) {
        pivot = Partition(L, low, high);    // 将low..high一分为二
        QSort(L, low, pivot - 1);   // 向低子表递归排序
        QSort(L, pivot + 1, high);  // 向高子表递归排序
    }
    return 0;
}

int Partition(SqList * L, int low, int high)
{
    int pivotkey;
    pivotkey = L->r[low];   //先暂时定第一个位置为中枢。此时选取可优化，因为可能不是中间值，可能偏大偏小
    while (low < high) {    // 不停的移动下标，当上下位置移动相交以后退出循环，此时中枢前后分别小于和大于中枢值
        while (low < high && L->r[high] >= pivotkey) {  // 从上向下直到当前值小于中枢值
            high--;
        }
        swap(L, low, high); // 把上半区中比中枢记录小的交换到低端
        while (low < high && L->r[low] <= pivotkey) {   // 从下向上直到当前值大于中枢值
            low++;
        }
        swap(L, low, high); // 把下半区中比中枢记录大的交换到顶端
    }
    return low;     // 返回中枢下标位置
}

完整代码

/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*

  > Author: xiaojunyu/LunaW
  > Mail  : xiaojunyu@lunaw.cn
  > Gmail : lunaw.cn@gmail.com
  > Blog  : http://blog.csdn.net/lunaw
  > Web   : http://lunaw.cn

 *-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <sys/time.h>

#define MAXSIZE 50000       // 设置数据量
#define IsPrintf 0      // 设置为1可以查看输出

typedef struct {
    int r[MAXSIZE + 1];
} SqList;

void Init(SqList * L);      // 初始化随机数
void Print(SqList * L);     // 输出数据
void swap(SqList * L, int i, int j);    // 交换值
double GetTime(void);       // 获取当前时间

int BubbleSort0(SqList * L);
/* 最简单的交换排序，不是真正意义上的冒泡排序 */

int BubbleSort(SqList * L);
/* 真正意义上的冒泡排序，两两交换，浮出最小或者最大值 */

int BubbleSort1(SqList * L);
/* 优化的冒泡排序，浮出最小或者最大值，增加标志位判断是否已经有序 */

int SelectSort(SqList * L);
/* 简单选择排序，通过n-i次关键字的比较，从n-i+1个记录中选出关键字最小的记录，然后与第i的位置替换 */

int InsertSort(SqList * L);
/* 直接插入排序，从第二个数开始循环，将当前数拿出来，依次将左边大于当前值的数向后移动一位，直到不大于当前值停止，然后将当前值插入空档 */

int ShellSort(SqList * L);
/* 希尔排序，直接插入排序的高效版，先使整个序列基本有序，然后再进行插入排序，大突破，打破O[n的平方] */

int HeapAdjust(SqList * L, int s, int m);   // 构建大顶堆
int HeapSort(SqList * L);
/* 堆排序，简单选择排序的升级*/

int MSort(int SR[], int TR1[], int s, int t);
int Merge(int SR[], int TR[], int i, int m, int n);
int MergeSort(SqList * L);
/* 递归归并排序 */

int MergePass(int SR[], int TR[], int s, int n);
int MergeSort1(SqList * L);
/* 非递归并排序 */

int Partition(SqList * L, int low, int high);   // 选取中枢，然后使左边都比它小，右边都比它大
int QSort(SqList * L, int low, int high);   // 递归排序
int QuickSort(SqList * L);
/* 快速排序，冒泡排序的升级，王者段位的排序，中心思想就是递归不断的把小的放左边，大的放右边*/

int Partition1(SqList * L, int low, int high);  // 三数取中法选取中枢，使左边都比它小，右边都比它大
int QSort1(SqList * L, int low, int high);  // 递归排序
int QuickSort1(SqList * L);
/* 优化快速排序，采用三数取中法选取中枢，同时减少中枢的交换次数 */

int main(void)
{
    double start, end;
    SqList H;
    SqList L;

    printf("数据量: %d\n\n", MAXSIZE);
    Init(&H);

    // printf("原始数据: \n");
    // Print(&H);

    // L = H;
    // start = GetTime();
    // BubbleSort0(&L);
    // end = GetTime();
    // printf("初级冒泡排序: \n");
    // Print(&L);
    // printf("运行时间: %lfs\n\n", end - start);

    // L = H;
    // start = GetTime();
    // BubbleSort(&L);
    // end = GetTime();
    // printf("标准冒泡排序: \n");
    // Print(&L);
    // printf("运行时间: %lfs\n\n", end - start);

    if (MAXSIZE <= 50000) { // 数据大了时间太久
        L = H;
        start = GetTime();
        BubbleSort1(&L);
        end = GetTime();
        printf("优化冒泡排序: \n");
        Print(&L);
        printf("运行时间: %lfs\n\n", end - start);

        L = H;
        start = GetTime();
        SelectSort(&L);
        end = GetTime();
        printf("简单选择排序: \n");
        Print(&L);
        printf("运行时间: %lfs\n\n", end - start);

        L = H;
        start = GetTime();
        InsertSort(&L);
        end = GetTime();
        printf("直接插入排序: \n");
        Print(&L);
        printf("运行时间: %lfs\n\n", end - start);
    }

    L = H;
    start = GetTime();
    ShellSort(&L);
    end = GetTime();
    printf("希尔插入排序: \n");
    Print(&L);
    printf("运行时间: %lfs\n\n", end - start);

    L = H;
    start = GetTime();
    HeapSort(&L);
    end = GetTime();
    printf("顶堆选择排序: \n");
    Print(&L);
    printf("运行时间: %lfs\n\n", end - start);

    if (MAXSIZE <= 100000) {    // 数组递归把栈内存占满了会报错，分配内存又很慢
        L = H;
        start = GetTime();
        MergeSort(&L);
        end = GetTime();
        printf("递归归并排序: \n");
        Print(&L);
        printf("运行时间: %lfs\n\n", end - start);
    }

    L = H;
    start = GetTime();
    MergeSort1(&L);
    end = GetTime();
    printf("非递归并排序: \n");
    Print(&L);
    printf("运行时间: %lfs\n\n", end - start);

    L = H;
    start = GetTime();
    QuickSort(&L);
    end = GetTime();
    printf("普通快速排序: \n");
    Print(&L);
    printf("运行时间: %lfs\n\n", end - start);

    L = H;
    start = GetTime();
    QuickSort1(&L);
    end = GetTime();
    printf("优化快速排序: \n");
    Print(&L);
    printf("运行时间: %lfs\n\n", end - start);

    return 0;
}

void Print(SqList * L)
{
    if (IsPrintf) {
        int i;
        for (i = 0; i < MAXSIZE; i++) {
            printf("%d ", L->r[i]);
        }
        printf("\n");
    }
}

void Init(SqList * L)
{
    int i;
    srand((unsigned)time(NULL));
    for (i = 0; i < MAXSIZE; i++) {
        L->r[i] = rand() % MAXSIZE;
    }
}

void swap(SqList * L, int i, int j)
{
    int temp = L->r[i];
    L->r[i] = L->r[j];
    L->r[j] = temp;
}

int BubbleSort1(SqList * L)
{
    int i, j;
    int flag = 1;
    for (i = 0; i < MAXSIZE - 1 && flag; i++) {
        flag = 0;   // 若标志位flag不为1，说明已经有序，这个时候就可以退出循环了
        for (j = MAXSIZE - 1; j > i; j--) {
            if (L->r[j] < L->r[j - 1]) {
                swap(L, j, j - 1);
                flag = 1;
            }
        }
    }
    return 0;
}

int BubbleSort(SqList * L)
{
    int i, j;
    for (i = 0; i < MAXSIZE - 1; i++) {
        for (j = MAXSIZE - 1; j > i; j--) {
            if (L->r[j] < L->r[j - 1]) {
                swap(L, j, j - 1);
            }
        }
    }
    return 0;
}

int BubbleSort0(SqList * L)
{
    int i, j;
    for (i = 0; i < MAXSIZE - 1; i++) {
        for (j = i + 1; j < MAXSIZE; j++) {
            if (L->r[i] > L->r[j]) {
                swap(L, i, j);
            }
        }
    }
    return 0;
}

int InsertSort(SqList * L)
{
    int i, j, flag;
    for (i = 1; i < MAXSIZE; i++) { // 从下标1开始，假设下标0已经有序
        if (L->r[i] < L->r[i - 1]) {    // 若当前的值小于前一位，则执行下面的操作
            flag = L->r[i]; // 将当前值记录到储存位
            for (j = i - 1; j >= 0 && L->r[j] > flag; j--) {    // 将左边大于当前值的依次向后移动一位，直到不大于为止
                L->r[j + 1] = L->r[j];
            }
            L->r[j + 1] = flag; // 插入储存位到空档
        }
    }
    return 0;
}

int ShellSort(SqList * L)
{
    int i, j, flag;
    int increment = MAXSIZE;
    while (increment > 1) {
        increment = increment / 3 + 1;  // 增量，目前没有最好的增量，可以调整
        for (i = increment; i < MAXSIZE; i++) { // 跳跃调整序列为基本有序，increment等于1时为普通插入排序
            if (L->r[i] < L->r[i - increment]) {
                flag = L->r[i]; // 将当前值记录到储存位
                for (j = i - increment; j >= 0 && L->r[j] > flag; j -= increment) {
                    L->r[j + increment] = L->r[j];  // 记录后移，查找插入位置
                }
                L->r[j + increment] = flag; //插入储存位到空档
            }
        }
    }
    return 0;
}

int SelectSort(SqList * L)
{
    int i, j, min;
    for (i = 0; i < MAXSIZE - 1; i++) {
        min = i;    // 将最小值的下标min指向当前下标i，起始位置
        for (j = i + 1; j < MAXSIZE; j++) {
            if (L->r[min] > L->r[j]) {
                min = j;    // 将最小值的下标min指向下标j，不停的比较，min指向当前循环最小值的下标
            }
        }
        if (i != min) {
            swap(L, i, min);    // 将最小值min交换到有序的i的位置，则每次循环以后，最小的值都依次被排序
        }
    }
    return 0;
}

double GetTime(void)
{
    struct timeval tv;
    gettimeofday(&tv, NULL);
    return tv.tv_sec + (double)tv.tv_usec / 1000000;
}

// 在L->r[s..m]中除l->r[s]外都满足堆的定义的情况下，调整L->r[s]的值，使其成为大顶堆
int HeapAdjust(SqList * L, int s, int m)
{
    int temp, j;
    temp = L->r[s];
    for (j = 2 * s; j <= m; j *= 2) {   // 沿关键字较大的孩子节点向下筛选
        if (j < m && L->r[j] < L->r[j + 1]) {
            ++j;    // j为关键字中较大的记录的下标
        }
        if (temp >= L->r[j]) {
            break;
        }
        L->r[s] = L->r[j];
        s = j;
    }
    L->r[s] = temp;     // 插入
    return 0;
}

int HeapSort(SqList * L)
{
    int i;
    for (i = (MAXSIZE - 1) / 2; i >= 0; i--) {  // 构建一个大顶堆
        HeapAdjust(L, i, MAXSIZE - 1);
    }
    for (i = MAXSIZE - 1; i >= 1; i--) {    // 反复将堆顶移到最后有序的位置，最后排序完成
        swap(L, 0, i);  // 将堆顶与后面未排序的最后一位交换
        HeapAdjust(L, 0, i - 1);    // 将交换后的序列重新调整为成大顶堆
    }
    return 0;
}

int MergeSort1(SqList * L)
{
    int *TR = (int *)malloc(MAXSIZE * sizeof(int));
    int k = 1;
    while (k < MAXSIZE) {
        MergePass(L->r, TR, k, MAXSIZE);
        k = 2 * k;  // 子序列长度加倍
        MergePass(TR, L->r, k, MAXSIZE);
        k = 2 * k;  // 子序列长度加倍
    }
    return 0;
}

int MergePass(int SR[], int TR[], int s, int n)
{
    int i = 1;
    int j;
    while (i <= n - 2 * s + 1) {
        Merge(SR, TR, i - 1, i + s - 1 - 1, i + 2 * s - 1 - 1);
        i = i + 2 * s;
    }
    if (i < n - s + 1) {
        Merge(SR, TR, i - 1, i + s - 1 - 1, n - 1);
    } else {
        for (j = i; j <= n; j++) {
            TR[j - 1] = SR[j - 1];
        }
    }
    return 0;
}

int MergeSort(SqList * L)
{
    MSort(L->r, L->r, 0, MAXSIZE - 1);
    return 0;
}

int MSort(int SR[], int TR1[], int s, int t)
{
    int m;
    int TR2[MAXSIZE + 1];
    if (s == t) {
        TR1[s] = SR[s];
    } else {
        m = (s + t) / 2;
        MSort(SR, TR2, s, m);
        MSort(SR, TR2, m + 1, t);
        Merge(TR2, TR1, s, m, t);
    }
    return 0;
}

int Merge(int SR[], int TR[], int i, int m, int n)
{
    int j, k, l;
    for (j = m + 1, k = i; i <= m && j <= n; k++) {
        if (SR[i] < SR[j]) {
            TR[k] = SR[i++];
        } else {
            TR[k] = SR[j++];
        }
    }
    if (i <= m) {
        for (l = 0; l <= m - i; l++) {
            TR[k + l] = SR[i + l];
        }
    }
    if (i <= n) {
        for (l = 0; l <= n - j; l++) {
            TR[k + l] = SR[j + l];
        }
    }
    return 0;
}

int Partition(SqList * L, int low, int high)
{
    int pivotkey;
    pivotkey = L->r[low];   //先暂时定第一个位置为中枢。此时选取可优化，因为可能不是中间值，可能偏大偏小
    while (low < high) {    // 不停的移动下标，当上下位置移动相交以后退出循环，此时中枢前后分别小于和大于中枢值
        while (low < high && L->r[high] >= pivotkey) {  // 从上向下直到当前值小于中枢值
            high--;
        }
        swap(L, low, high); // 把上半区中比中枢记录小的交换到低端
        while (low < high && L->r[low] <= pivotkey) {   // 从下向上直到当前值大于中枢值
            low++;
        }
        swap(L, low, high); // 把下半区中比中枢记录大的交换到顶端
    }
    return low;     // 返回中枢下标位置
}

// 优化函数
int Partition1(SqList * L, int low, int high)
{
    int pivotkey;
    /* 三数取中法 使中枢更接近中间值 */
    int m = low + (high - low) / 2;
    if (L->r[low] > L->r[high]) {
        swap(L, low, high);
    }
    if (L->r[m] > L->r[high]) {
        swap(L, high, m);
    }
    if (L->r[m] > L->r[low]) {
        swap(L, m, low);
    }
    pivotkey = L->r[low];   //先暂时定第一个位置为中枢。此时选取可优化，因为可能不是中间值，可能偏大偏小
    L->r[MAXSIZE] = pivotkey;   // [减少中枢交换优化] 先保存中枢到备份位
    while (low < high) {    // 不停的移动下标，当上下位置移动相交以后退出循环，此时中枢前后分别小于和大于中枢值
        while (low < high && L->r[high] >= pivotkey) {  // 从上向下直到当前值小于中枢值
            high--;
        }
        L->r[low] = L->r[high]; // [减少中枢交换优化] 改交换为替换，可以减少交换次数
        while (low < high && L->r[low] <= pivotkey) {   // 从下向上直到当前值大于中枢值
            low++;
        }
        L->r[high] = L->r[low]; // [减少中枢交换优化] 改交换为替换，可以减少交换次数
    }
    L->r[low] = L->r[MAXSIZE];  // [减少中枢交换优化] 将中枢数据替换回来
    return low;     // 返回中枢下标位置
}

int QSort(SqList * L, int low, int high)
{
    int pivot;
    if (low < high) {
        pivot = Partition(L, low, high);    // 将low..high一分为二
        QSort(L, low, pivot - 1);   // 向低子表递归排序
        QSort(L, pivot + 1, high);  // 向高子表递归排序
    }
    return 0;
}

int QSort1(SqList * L, int low, int high)
{
    int pivot;
    if (low < high) {
        pivot = Partition1(L, low, high);   // 将low..high一分为二
        QSort(L, low, pivot - 1);   // 向低子表递归排序
        QSort(L, pivot + 1, high);  // 向高子表递归排序
    }
    return 0;
}

int QuickSort(SqList * L)
{
    QSort(L, 0, MAXSIZE - 1);
    return 0;
}

int QuickSort1(SqList * L)
{
    QSort1(L, 0, MAXSIZE - 1);
    return 0;
}
逐风者の宇
关注
  • 7
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
直接插入排序，希尔排序，选择排序，冒泡排序，快速排序，归并排序图解及代码
m0_58887749的博客
04-03 821
一，直接插入排序 1.思路分析： 第一步我们假定数组中的首元素是有序的，然后从第二个元素开始，先把该元素拷贝到temp中，我们用temp与该元素下标之前的元素进行比较如果该元素的值大于temp那么就让它向后移动一位，这样当遇到比temp小的元素时该元素后面的位置插入temp。 2.画图演示： 3.代码描述： public static void insertSort(int [] array){ if(array.length <= 1){ .
各种常见的排序，冒泡排序，选择排序，插入排序，希尔排序，堆排序，快速排序，基数排序，桶排序
六道的专栏
08-04 1702
各种常见的排序 要开始找工作了，把以前学的各种小知识复习一遍，以下是各种常见的排序的简单实现（冒泡排序，选择排序，插入排序，希尔排序，堆排序，快速排序，基数排序，桶排序），至于原理就不写出来了，代码比较简单，看一下就懂，再不行可以随意找本书或百度！ #include using namespace std; // 冒泡 void BubbleSort(int data[], int l
排序算法 —— 希尔排序（图文超详细）
热门推荐
超烦豆先森
10-29 6万+
java 实现希尔排序
希尔排序详解(Shell Sort)
Wzill
05-29 1万+
直接插入排序是由两层嵌套循环组成的。外层循环标识并决定待比较的数值。内层循环为待比较数值确定其最终位置。直接插入排序将待比较的数值与它的前一个数值进行比较，所以外层循环是从第二个数值开始的。当前一数值比待比较数值大的情况下继续循环比较，直到找到比待比较数值小的并将待比较数值置入其后一位置，结束该次循环。
“希尔”排序
weixin_70056514的博客
04-04 6106
希尔排序法又称缩小增量法。 希尔排序法的基本思想是：先选定一个整数gap，把待排序文件中所有元素分成gap组，即所有距离为gap的分在同一组内，并对每一组内的元素进行直接插入排序（本质是进行预排序，使数组更接近有序，目的是使最后一次直接插入排序提高效率）。然后取gap=gap/2或者gap=gap/3+1重复上述分组和排序的工作。当gap到达1时，数组是已经接近有序的，而对于直接插入排序在顺序有序或者接近顺序有序的数组内的时间复杂度为O(N)，效率极高。
数据结构与算法之希尔排序
努力让自己发光，对的人才能迎着光而来
09-12 2万+
希尔排序概念 代码实现 时间复杂度
排序算法——希尔排序
XXXTENTAC1ON的博客
11-17 2313
希尔排序什么是希尔排序为什么不直接使用插入排序希尔排序代码实现 什么是希尔排序 希尔排序也叫做：缩小增量排序。 分组（分组的组数需要循环递减，直到减为1）排序。 先将待排序序列分成若干组，然后使用直接插入排序在组内排序。循环着将分组数减小，执行以上过程。直到分组减为1. 所有的分组数都互质。 分组可为任意数字，且每次分组数都比上一次分组要小，直至分组数为1。 为什么不直接使用插入排序 相比较插入排序，希尔排序输入直接插入排序的一种，但是在两种算法的比较上 希尔排序: 就是直接插入排序的优化， 数据
冒泡排序，选择排序，插入排序，希尔排序，堆排序，归并排序，快速排序源码实现
10-26
以下是关于"冒泡排序，选择排序，插入排序，希尔排序，堆排序，归并排序，快速排序"这七种常见排序算法的源码实现及相关知识点的详细解释： 1. **冒泡排序**：冒泡排序是一种简单的排序算法，它重复地遍历待排序的...
冒泡排序；直接插入排序；希尔排序；快速排序；堆排序；归并排序；基数排序
05-16
这里我们将深入探讨七种经典的排序算法：冒泡排序、直接插入排序、希尔排序、快速排序、堆排序、归并排序以及基数排序。 1. **冒泡排序**： 冒泡排序是最基础的排序算法之一。它通过重复遍历待排序的数据序列，...
Java实现八个常用的排序算法：插入排序、冒泡排序、选择排序、希尔排序等
09-03
快速排序是一种高效的排序算法，由C.A.R. Hoare在1960年提出。基本思想是通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，然后分别对这两部分记录继续进行排序，以达到...
C# 插入排序 冒泡排序 选择排序 快速排序 堆排序 归并排序 基数排序 希尔排序
10-15
- C# 实现堆排序时，主要涉及建堆、交换堆顶和调整堆的过程，可以使用数组来模拟二叉堆。 6. **归并排序**（Merge Sort）： - 归并排序是一种稳定的排序算法，也是分治策略的典型应用。将数组分为两半，分别排序...
C++实现八个常用的排序算法：插入排序、冒泡排序、选择排序、希尔排序等
09-03
在本文中，我们将深入探讨C++实现的八种常见的排序算法，它们分别是插入排序、冒泡排序、选择排序、希尔排序、快速排序、归并排序、堆排序和LST基数排序。这些排序算法在计算机科学中有着广泛的应用，是理解和掌握...
希尔排序详解
wang20010104的博客
05-20 1万+
1.概述 希尔排序(Shell's Sort)是插入排序的一种又称“缩小增量排序”（Diminishing Increment Sort），是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因 D.L.Shell 于 1959 年提出而得名。 希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至 1 时，整个文件恰被分成一组，算法便终止。 2.步骤 希尔排序的基本步骤，在此我们选择增量ga...
【数据结构排序算法（二）】希尔排序
weixin_60053402的博客
03-16 2999
基础数据结构之八大排序算法（二） ②希尔排序（对直接插入排序的优化），最小增量排序 时间复杂度：O（1.3）~ O（1.5） 通过最小增量数组对数据进行排序，每个最小增量进行一次排序（每次排序使数据更为有序，则下次时间复杂度变小） 空间复杂度：O（1） 所有额外辅助变量不会影响整体问题的规模 稳定性：不稳定 存在跳跃交换 （以顺序表作为待排序对象） 1.基本思想： 以数组 { 7 6 5 9 3 18 21 8 22 10 66 77 35 91 29 } 为例。 最
数据结构——希尔排序（图文精选）
girls的博客
08-17 3604
希尔排序： 希尔排序(Shell Sort，又称缩小增量法)是一种分组插入排序方法。 排序思想： ① 先取一个正整数d1(d1<n)作为第一个增量，将全部n个记录分成d1组，把所有相隔d1的记录放在一组中，即对于每个k(k=1, 2, … d1)，R[k], R[d1+k], R[2d1+k] , …分在同一组中，在各组内进行直接插入排序。这样一次分组和排序过程称为一趟希尔排序； ② 取新的增量d2<d1，重复①的分组和排序操作；直至所取的增量di=1为止，即所有记录放进一个组中排.
经典排序之希尔排序
scarificed的博客
01-30 701
希尔排序(Shell Sort):将待排序数据分组，各组之内进行插入排序。 假如待排序数据为：12、28、3、9、13、1、7、22、24、16、5。 我们传统思想上的分组可能就是挨着的元素在一起，我们3个分一组，12、28、 3；9、13、1；7、22、24；16、5；在对每一组进行插入排序之后，结果只是这组内的元素顺序有序，比如第一组的结果为3、12、28；可是对于我们要排序的所有数据来说，大的元素可能还是在前面，小的元素可能还是在后面，所以我们采用传统思想上的分组不合适，我们采用隔几个元素的方法来分组
排序算法——希尔排序图文详解
Forward♞的博客
06-04 3550
基本思想是：先选定一个整数gap，把待排序文件中所有记录分成数组，所有距离为gap的记录分在同一组内，并对每一组内的记录进行排序。然后缩小gap，重复上述步骤，当gap == 1时，所有记录在统一组内已经排好序
【算法】——希尔排序，最直观的方法理解希尔排序
她的坏机器人
03-23 682
希尔排序(Shell's Sort)是插入排序的一种，又称“缩小增量排序”（Diminishing Increment Sort），是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。 希尔排序的基本思想是：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录"基本有序"时，再对全体记录进行依次直接插入排序。 排序步骤： （这里取增量（步长）为最...
GEE数据集-高分辨率全球树冠高度地图（1 米）Meta 公司.pdf
最新发布
07-17
绘制植被结构图对于了解全球碳循环以及监测基于自然的气候适应和减缓方法至关重要。通过对这些数据的重复测量，可以观察现有森林的砍伐或退化情况、森林的自然再生以及农林业等可持续农业实践的实施情况。高空间分辨率的树冠高度和树冠投影面积评估对于监测碳通量和评估基于树木的土地利用也很重要，因为森林结构在空间上可能高度异质，特别是在农林系统中。极高分辨率的卫星图像（地面采样距离小于一米）使提取树木层面的信息成为可能，同时还能进行大尺度监测。本文介绍了第一份同时为多个次国家辖区制作的高分辨率树冠高度图。具体来说，我们为加利福尼亚州和圣保罗州制作了非常高分辨率的树冠高度地图，与之前基于哨兵/GEDI 的全球树冠高度地图的十米（10 米）分辨率相比，分辨率有了显著提高。这些地图是通过在 2017 年至 2020 年的 Maxar 图像上训练的自监督模型中提取特征，并根据航空激光雷达地图训练密集预测解码器生成的。我们还引入了一个后处理步骤，使用在 GEDI 观测数据上训练的卷积网络。我们利用预留验证激光雷达数据以及与其他遥感地图和实地收集的数据进行比较，对所提出的地图进行了评估，发现我们的模型产生的平均绝对
计算机专业一些常见排序方法的算法实现
04-15
本文介绍了一个计算机专业的排序类，其中包含了常见的排序算法实现包括冒泡排序、选择排序、堆排序、插入排序、希尔排序、快速排序、二叉树排序、归并排序。这些算法都是面向对象的编程思想，是作者在自己的考研复习...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值