常见排序总结

最新推荐文章于 2024-06-30 10:23:17 发布
原创 最新推荐文章于 2024-06-30 10:23:17 发布 · 256 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍了八种常见的排序算法：冒泡排序、快速排序、计数排序、插入排序、选择排序、希尔排序、归并排序、鸡尾酒排序和桶排序，并提供了每种排序算法的C语言实现。通过这些实例，读者可以深入理解各种排序算法的工作原理和效率特点。

冒泡

#include <stdio.h>

void bubble_sort(int array[], int length);

void bubble_sort(int array[], int length)
{
    int i, j, temp;

    for (i = 0; i < length - 1; i++)
    {
        for (j = 0; j < length - 1 - i; j++)
        {
            if (array[j] > array[j + 1])
            {
                temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }
        }
    }
}

int main(void)
{
    int array[] = { 73, 108, 111, 118, 101, 70, 105, 115, 104, 67, 46, 99, 111, 109 };
    int i, length;

    length = sizeof(array) / sizeof(array[0]);
    bubble_sort(array, length);

    printf("排序后的结果是：");
    for (i = 0; i < length; i++)
    {
        printf("%d ", array[i]);
    }
    putchar('\n');

    return 0;
}

快排

#include <stdio.h>

void quick_sort(int array[], int left, int right);

void quick_sort(int array[], int left, int right)
{
    int i = left, j = right;
    int temp;
    int pivot;

    // 基准点设置为中间元素，你也可以选择其它元素作为基准点
    pivot = array[(left + right) / 2];

    while (i <= j)
    {
        // 找到左边大于等于基准点的元素
        while (array[i] < pivot)
        {
            i++;
        }
        // 找到右边小于等于基准点的元素
        while (array[j] > pivot)
        {
            j--;
        }
        // 如果左边下标小于右边，则互换元素
        if (i <= j)
        {
            temp = array[i];
            array[i] = array[j];
            array[j] = temp;
            i++;
            j--;
        }
    }

    if (left < j)
    {
        quick_sort(array, left, j);
    }

    if (i < right)
    {
        quick_sort(array, i, right);
    }
}

int main(void)
{
    int array[] = { 73, 108, 111, 118, 101, 70, 105, 115, 104, 67, 46, 99, 111, 109 };
    int i, length;

    length = sizeof(array) / sizeof(array[0]);
    quick_sort(array, 0, length - 1);

    printf("排序后的结果是：");
    for (i = 0; i < length; i++)
    {
        printf("%d ", array[i]);
    }
    putchar('\n');

    return 0;
}

在这里插入图片描述

计数排序：

#include <stdio.h>
#include <stdlib.h>

void counting_sort(int array[], int length);

void counting_sort(int array[], int length)
{
    int i, max;
    int* buffer = NULL;
    int* sorted = NULL;

    max = array[0];
    for (i = 1; i < length; i++)
    {
        if (array[i] > max)
        {
            max = array[i];
        }
    }

    buffer = (int*)malloc((max + 1) * sizeof(int));
    for (i = 0; i < max + 1; i++)
    {
        buffer[i] = 0;
    }

    for (i = 0; i < length; i++)
    {
        buffer[array[i]]++;
    }

    for (i = 1; i < max + 1; i++)
    {
        buffer[i] += buffer[i - 1];
    }

    sorted = (int*)malloc(length * sizeof(int));
    for (i = length; i > 0; i--)
    {
        sorted[--buffer[array[i - 1]]] = array[i - 1];
    }

    for (i = 0; i < length; i++)
    {
        array[i] = sorted[i];
    }

    free(buffer);
    free(sorted);
}

int main(void)
{
    int array[] = { 73, 108, 111, 118, 101, 70, 105, 115, 104, 67, 46, 99, 111, 109 };
    int i, length;

    length = sizeof(array) / sizeof(array[0]);
    counting_sort(array, length);

    printf("排序后的结果是：");
    for (i = 0; i < length; i++)
    {
        printf("%d ", array[i]);
    }
    putchar('\n');

    return 0;
}

在这里插入图片描述

插入排序

#include <stdio.h>

void insertion_sort(int array[], int length);

void insertion_sort(int array[], int length)
{
    int i, j, temp;

    for (i = 1; i < length; i++)
    {
        temp = array[i];
        j = i - 1;
        for (; j >= 0 && array[j] > temp; j--)
        {
            array[j + 1] = array[j];
        }
        array[j + 1] = temp;
    }
}

int main(void)
{
    int array[] = { 73, 108, 111, 118, 101, 70, 105, 115, 104, 67, 46, 99, 111, 109 };
    int i, length;

    length = sizeof(array) / sizeof(array[0]);
    insertion_sort(array, length);

    printf("排序后的结果是：");
    for (i = 0; i < length; i++)
    {
        printf("%d ", array[i]);
    }
    putchar('\n');

    return 0;
}

选择排序

#include <stdio.h>

void selection_sort(int array[], int length);

void selection_sort(int array[], int length)
{
    int i, j, min, temp;

    for (i = 0; i < length - 1; i++)
    {
        min = i;
        for (j = i + 1; j < length; j++)
        {
            if (array[min] > array[j])
            {
                min = j;
            }
        }
        temp = array[min];
        array[min] = array[i];
        array[i] = temp;
    }
}

int main(void)
{
    int array[] = { 73, 108, 111, 118, 101, 70, 105, 115, 104, 67, 46, 99, 111, 109 };
    int i, length;

    length = sizeof(array) / sizeof(array[0]);
    selection_sort(array, length);

    printf("排序后的结果是：");
    for (i = 0; i < length; i++)
    {
        printf("%d ", array[i]);
    }
    putchar('\n');

    return 0;
}

希尔排序

#include <stdio.h>

void shell_sort(int array[], int length);

void shell_sort(int array[], int length)
{
    int i, j, step, temp;

    for (step = length / 2; step > 0; step /= 2)
    {
        for (i = step; i < length; i++)
        {
            temp = array[i];
            for (j = i - step; j >= 0 && array[j] > temp; j -= step)
            {
                array[j + step] = array[j];
            }
            array[j + step] = temp;
        }
    }
}

int main(void)
{
    int array[] = { 73, 108, 111, 118, 101, 70, 105, 115, 104, 67, 46, 99, 111, 109 };
    int i, length;

    length = sizeof(array) / sizeof(array[0]);
    shell_sort(array, length);

    printf("排序后的结果是：");
    for (i = 0; i < length; i++)
    {
        printf("%d ", array[i]);
    }
    putchar('\n');

    return 0;
}

归并排序

#include <stdio.h>

void merge_sort(int array[], int length);
void merge_sort_recursive(int array[], int reg[], int start, int end);

void merge_sort_recursive(int array[], int reg[], int start, int end)
{
    if (start >= end)
    {
        return;
    }

    int k = start;
    int length = end - start;
    int mid = (length / 2) + start;
    int start1 = start, end1 = mid;
    int start2 = mid + 1, end2 = end;

    merge_sort_recursive(array, reg, start1, end1);
    merge_sort_recursive(array, reg, start2, end2);

    while (start1 <= end1 && start2 <= end2)
    {
        reg[k++] = array[start1] < array[start2] ? array[start1++] : array[start2++];
    }

    while (start1 <= end1)
    {
        reg[k++] = array[start1++];
    }

    while (start2 <= end2)
    {
        reg[k++] = array[start2++];
    }

    for (k = start; k <= end; k++)
    {
        array[k] = reg[k];
    }
}

void merge_sort(int array[], int length)
{
    int reg[14];
    merge_sort_recursive(array, reg, 0, length - 1);
}

int main(void)
{
    int array[] = { 73, 108, 111, 118, 101, 70, 105, 115, 104, 67, 46, 99, 111, 109 };
    int i, length;

    length = sizeof(array) / sizeof(array[0]);
    merge_sort(array, length);

    printf("排序后的结果是：");
    for (i = 0; i < length; i++)
    {
        printf("%d ", array[i]);
    }
    putchar('\n');

    return 0;
}

在这里插入图片描述

鸡尾酒排序

#include <stdio.h>

void cocktail_sort(int array[], int length);

void cocktail_sort(int array[], int length)
{
    int i, left = 0, right = length - 1;
    int temp;

    while (left < right)
    {
        for (i = left; i < right; i++)
        {
            if (array[i] > array[i + 1])
            {
                temp = array[i];
                array[i] = array[i + 1];
                array[i + 1] = temp;
            }
        }
        right--;
        for (i = right; i > left; i--)
        {
            if (array[i - 1] > array[i])
            {
                temp = array[i];
                array[i] = array[i - 1];
                array[i - 1] = temp;
            }
        }
        left++;
    }
}

int main(void)
{
    int array[] = { 73, 108, 111, 118, 101, 70, 105, 115, 104, 67, 46, 99, 111, 109 };
    int i, length;

    length = sizeof(array) / sizeof(array[0]);
    cocktail_sort(array, length);

    printf("排序后的结果是：");
    for (i = 0; i < length; i++)
    {
        printf("%d ", array[i]);
    }
    putchar('\n');

    return 0;
}

在这里插入图片描述

桶排序

#include <stdio.h>
#include <stdlib.h>

int* add_item(int* array, int count, int item);
void bucket_sort(int array[], int length);

struct Bucket
{
    int* data;
    int count;
};

int* add_item(int* array, int count, int item)
{
    int* newArray = (int*)malloc(sizeof(int) * (count + 1));
    int i;

    for (i = 0; i < count; i++)
    {
        newArray[i] = array[i];
    }

    newArray[count] = item;

    return newArray;
}

void bucket_sort(int array[], int length)
{
    int min = array[0];
    int max = array[0];
    int i, j, k, cap, size;
    struct Bucket* bucket = NULL;
    struct Bucket b;

    for (i = 1; i < length; i++)
    {
        if (array[i] > max)
        {
            max = array[i];
        }

        if (array[i] < min)
        {
            min = array[i];
        }
    }

    cap = max - min + 1;
    bucket = (struct Bucket*)malloc(sizeof(struct Bucket) * cap);

    for (i = 0; i < cap; i++)
    {
        bucket[i] = *(struct Bucket*)malloc(sizeof(struct Bucket));
    }

    for (i = 0; i < length; i++)
    {
        b = bucket[array[i] - min];
        if (b.count < 0)
        {
            b.count = 0;
        }

        bucket[array[i] - min].data = add_item(b.data, b.count++, array[i]);
        bucket[array[i] - min].count = b.count;
    }

    for (i = 0, k = 0; i < cap; i++)
    {
        size = bucket[i].count;

        if (size > 0)
        {
            for (j = 0; j < size; j++)
            {
                array[k] = bucket[i].data[j];
                k++;
            }
        }
    }
}

int main(void)
{
    int array[] = { 73, 108, 111, 118, 101, 70, 105, 115, 104, 67, 46, 99, 111, 109 };
    int i, length;

    length = sizeof(array) / sizeof(array[0]);
    bucket_sort(array, length);

    printf("排序后的结果是：");
    for (i = 0; i < length; i++)
    {
        printf("%d ", array[i]);
    }
    putchar('\n');

    return 0;
}

在这里插入图片描述

心形 图案

#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#define I 20
#define R 340
int main()
{
    int i, j, e;
    int a;
    long time;
    system("title 寻梦SSS");
    for (i = 1, a = I; i < I / 2; i++, a--)
    {
        for (j = (int)(I - sqrt(I * I - (a - i) * (a - i))); j > 0; j--)
            printf(" ");
        for (e = 1; e <= 2 * sqrt(I * I - (a - i) * (a - i)); e++)
            printf("\3");
        for (j = (int)
            (2 * (I - sqrt(I * I - (a - i) * (a - i)))); j > 0; j--)
            printf(" ");
        for (e = 1; e <= 2 * sqrt(I * I - (a - i) * (a - i)); e++)
            printf("\3");
        printf("\n");
    }
    for (i = 1; i < 80; i++)
    {
        if (i == 25)
        {
            printf(" 一路向前冲冲冲！！！！！！！");
            i += 30;
        }
        printf("\3");
    }
    printf("\n");
    for (i = 1; i <= R / 2; i++)
    {
        if (i % 2 || i % 3)
            continue;
        for (j = (int)(R - sqrt(R * R - i * i)); j > 0; j--)
            printf(" ");
        for (e = 1; e <= 2 * (sqrt(R * R - i * i) - (R - 2 * I)); e++)
            printf("\3");
        printf("\n");
    }

    for (; ; )
    {
        system("color a");
        for (time = 0; time < 99999999; time++); system("color b");
        for (time = 0; time < 99999999; time++); system("color c");
        for (time = 0; time < 99999999; time++); system("color d");
        for (time = 0; time < 99999999; time++); system("color e");
        for (time = 0; time < 99999999; time++); system("color f");
        for (time = 0; time < 99999999; time++);
        system("color 0"); for (time = 0; time < 99999999; time++);
        system("color 1"); for (time = 0; time < 99999999; time++);
        system("color 2"); for (time = 0; time < 99999999; time++);
        system("color 3"); for (time = 0; time < 99999999; time++);
        system("color 4");
        for (time = 0; time < 99999999; time++); system("color 5");
        for (time = 0; time < 99999999; time++); system("color 6");
        for (time = 0; time < 99999999; time++); system("color 7");
        for (time = 0; time < 99999999; time++); system("color 8");
        for (time = 0; time < 99999999; time++); system("color 9");
        for (time = 0; time < 99999999; time++); system("color ab");
        for (time = 0; time < 99999999; time++); system("color ac");
        for (time = 0; time < 99999999; time++); system("color ad");
        for (time = 0; time < 99999999; time++); system("color ae");
        for (time = 0; time < 99999999; time++); system("color af");
        for (time = 0; time < 99999999; time++);
    }
    return 0;
}

在这里插入图片描述

【数据结构】常见七大排序总结
四季轮换叶，一路招摇胜
10-23 7157
常见七大排序概念算法总结
c语言的特点
weixin_34255793的博客
11-18 433
基本特性 1、高级语言：它是把高级语言的基本结构和语句与低级语言的实用性结合起来的工作单元。 2、结构式语言：结构式语言的显著特点是代码及数据的分隔化，即程序的各个部分除了必要的信息交流外彼此独立。这种结构化方式可使程序层次清晰，便于使用、维护以及调试。C 语言是以函数形式提供给用户的，这些函数可方便的调用，并具有多种循环、条件语句控制程序流向，从而使程序完全结构化。 4、代码级别的跨平台：由于标...
《带你学C带你飞》——冒泡排序
earther19949的博客
08-19 210
**冒泡排序（Bubble Sort）**是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。 冒泡排序通俗易懂，适合初次接触排序算法的童鞋学习。不过冒泡排序的效率算比较低的，如果你尤其喜欢冒泡排序，还可以...
C++实现冒泡排序
weixin_59566851的博客
12-16 2681
C++实现冒泡排序
自己实现一个bubble_sort(冒泡排序)，可以完成不同类型数据的排序
lei19950206的博客
05-07 2178
void bubble_sort(void *arr, int len, int(*cmp)(void*, void*)) { int *start = (int*)arr; assert(start && len > 0); int i = 0; for (; i < len; i++){ int j = 0; for (; j < len - i - 1; j++){ i
成成你好呀（C知识点整理五）
weixin_43144288的博客
05-03 215
[扩展阅读] 各种各这样的排序算法：冒泡排序（*） 冒泡排序的执行效果是这样的： #include <stdio.h> void bubble_sort(int array[], int length); void bubble_sort(int array[], int length) { int i, j, temp; for (i = 0; i < length - 1; i++) { for
Java实现常见排序算法总结
05-02
【Java实现常见排序算法总结】 排序算法是计算机科学中至关重要的一部分，它涉及到数据处理和算法设计。本文将探讨两种常见的排序算法在Java中的实现：直接插入排序和希尔排序。 1. **直接插入排序（直接插入排序...
常见排序算法总结.pdf
03-28
【排序算法总结】 排序算法是计算机科学中处理数据排列的重要工具，主要分为稳定排序和非稳定排序、内排序和外排序两大类。稳定排序保证了相同元素在排序后的相对位置不变，而非稳定排序则不作此保证。内排序是指...
常见排序算法总结.docx
03-28
以上就是对常见排序算法的总结，包括稳定性和非稳定性、内排序与外排序的概念，以及插入排序和选择排序的详细讲解。这些基础排序算法在实际编程中非常常见，理解它们的工作原理有助于优化算法性能并解决实际问题。
c++常见排序算法总结
最新发布
qq_71286244的博客
06-30 842
c++常见排序算法总结
数据结构与算法--冒泡排序（bubble sort）
IRQHandler的博客
07-13 316
今天分享一下最简单的排序算法：冒泡排序。 冒泡排序是由于它排序的方式而得名的，它是一种稳定的排序算法。 编程思路：依次比较相邻两个变量，将变量值大的放在变量值小的后面（升序），直到没有任何两个相邻变量可以交换。 冒泡排序代码如下： #include<stdio.h> #define ARRAY_LEN 10 void array_print(int *a,int num); int swap(int *x,int *y); void bubble_sort(int *a,int
C语言的printf一些骚操作
weixin_30920597的博客
05-24 506
#include <stdio.h> int main(){ printf("打印五个字符：%c %c %c %c %c\n", 70, 105, 115, 104, 67); printf("前边用 填充：%10d\n", 2015); printf("前边用0填充：%010d\n", 2015); printf("右对齐，保...
c语言数组排序程序设计,《C语言及程序设计》实践参考——数组的排序
weixin_39909366的博客
05-22 360
返回：贺老师课程教学链接项目要求【项目3 - 数组的排序】(1)编写函数，完成冒泡排序要求不能改变下面的main函数。//两个函数bubble_sort和output_array的声明int main( ){int a[20]={86,76,62,58,77,85,92,80,96,88,77,67,80,68,88,87,64,59,61,76};int b[15]={27,61,49,88...
【排序算法】直接选择排序(SelectSort)与冒泡排序(BubbleSort)
xiaoding133的专栏【Stay hungry,Stay foolish】
07-13 1858
直接选择排序：每一趟在n-i-1(i=1,2,...n-1)个记录中选取关键字最小的记录，并和第i个记录进行交换。 void SelectSort(int Array[],int n)//n为数组长度,不稳定排序 { int i,j,k; int temp; for(i=0;i<n-1;i++) { k=i; //保存最小值 for(j=i+1;j<n;j+
【算法-排序】归并排序
holysll的博客
04-15 341
归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法，该算法是采用分治法（Divide and Conquer）的一个非常典型的应用，且各层分治递归可以同时进行。归并算法指的是将两个已经排序的序列合并成一个序列的操作。归并排序算法依赖归并操作 采用分治法: 分割：递归地把当前序列平均分割成两半。 集成：在保持元素顺序的同时将上一步得到的子序列集成到一起（归并...
三大基础排序算法BubbleSort、SelectSort、InsertSort
weixin_30340617的博客
11-24 174
public class Strategy { public static void main(String[] args) { int [] array=new int[]{26,25,15,42,36,16,12}; IInfo test1=new BubbleSort(); //接口引用指向实现了此接口的类创建的实例，创建具体的策略对象 IInfo test2=new SelectS...
带你学C带你飞
京庐空间
09-20 2604
课程介绍 《带你学C带你飞》第一季讲解内容：C语言语法，我们会讲变量、数组、函数、指针、结构、标准库这样一些纯粹的C语言知识。 基本上你大学第一学期学的就是咱第一季的内容，我知道很多朋友学完C语言一时感觉没什么用？然后大一学完大二就还给体育老师了……咳咳，毕竟现在是一个连程序都要刷颜值的年代……使用C语言，确实不容易写出外观炫酷的程序，但你要知道，往往一个只是好看的程序，其实更需要的是一个优秀
BUBBLE_SORT
muyexueshang的博客
12-12 310
/* 冒泡排序：bubble sort 时间复杂度：O(n^2) 空间复杂度：O(1) 稳定性：稳定 TIME:2017年10月17日 09:43:56 ascend */ void bubble_sort(int array[],int array_length) {     for(int i=0;i     {         for(int j=0;j   
数据结构常见排序算法笔试总结与应用
本文将对数据结构中的各种常见排序算法进行一个全面的总结，并简要分析它们的特点、适用场景以及时间复杂度，以期帮助大家在笔试和实际应用中更加得心应手。 ### 常见排序算法总结 #### 1. 冒泡排序（Bubble Sort...
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

寻梦&之璐

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

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

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

打赏作者

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

抵扣说明：

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

余额充值