十大排序算法简易代码实现

已于 2022-07-24 21:54:34 修改
阅读量392 收藏
点赞数
分类专栏： 算法总结 文章标签： 排序算法 算法 数据结构
于 2022-07-24 15:00:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51721904/article/details/125959181
版权

十大排序算法：冒泡排序，选择排序，插入排序，希尔排序，快速排序，归并排序，基数排序，桶排序(箱排序)，堆排序。

提示：所有代码都加了打印测试，看上去代码会较多一点，实际核心代码数只有几行。

1.冒泡排序（六行）

#include <stdio.h>
#define NUM 10
#if 0
void Bubble_sort(int * arr) {   //普通版本
    
    for( int i = 0; i < NUM - 1; i ++ ) {
        for( int j = 0; j < NUM - 1 - i; j ++ ) {
            if(arr[j + 1] < arr[j]) {
                int tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
            }
        }
    }
}
# else 
void Bubble_sort(int * arr) {  //优化版，特定情况减少排序次数
    int lastExchangeIdx = 0;  //记录最后一次交换的位置
    int unsortBorder = NUM - 1; //记录无序数组的边缘位置

    for( int i = 0; i < NUM - 1; i ++ ) {
        bool IsSort = true; //判断次数循环是否一直处于有序状态，若是说明不用继续了，直接退出
        for  ( int j = 0; j < unsortBorder; j ++ ) {
            if(arr[j + 1] < arr[j]) {
                IsSort = false;
                int tmp = arr[j + 1] ;
                arr[j + 1] = arr[j]; 
                arr[j] = tmp;
                lastExchangeIdx = j;
            }
        }
        unsortBorder = lastExchangeIdx;
        if(IsSort) {  //如果一直都没有调整过位置，说明已经有序了。
            break;  
        }
    }
}
void print_test(int * arr, int isfirst) {  
    if(isfirst) {
        printf("排序前：\n");
    } else {
        printf("排序后：\n");
    }
    for( int i = 0 ; i < 10; i ++ ) {
        printf("%d\t", arr[i]);        
    }
    printf("\n");
}
int main() {
    int arr[NUM] = {1, 9, 20, 3, 58, 52, 99, 131, 22, 79};
    print_test(arr,1);
    Bubble_sort(arr);
    print_test(arr,0);
    return 0;
}
#endif

2.选择排序（六行）

#include <stdio.h>
#define NUM 10
void swap(int * arr, int a, int b) {
    int temp = arr[b];
    arr[b] = arr[a];
    arr[a] = temp;
}
void Select_sort(int * arr) {
    for(int i = 0; i < NUM - 1; i++) {
        int MinIdx = i;
        for(int j = i + 1; j < NUM; j++) {
            if(arr[j] < arr[MinIdx]) {
                MinIdx = j;
            }
        }
        swap(arr, i, MinIdx);
    }
}
void print_test(int * arr, int isfirst) {  
    if(isfirst) {
        printf("排序前：\n");
    } else {
        printf("排序后：\n");
    }
    for( int i = 0 ; i < 10; i ++ ) {
        printf("%d\t", arr[i]);        
    }
    printf("\n");
}
int main() {
    int arr[NUM] = {1, 9, 20, 3, 58, 52, 99, 131, 22, 79};
    print_test(arr,1);
    Select_sort(arr);
    print_test(arr,0);
    return 0;
}

3.插入排序（3行）

#include <stdio.h>
#define NUM 10
int k = 0;
void swap(int * arr, int a, int b) {
    int temp = arr[b];
    arr[b] = arr[a];
    arr[a] = temp;
}
void insert_sort(int * arr) {       //核心代码
    for(int i = 1; i < NUM; i++) {
        for(int k = i; (arr[k] < arr[k - 1]) && k != 0; k--) {
                swap(arr, k, k - 1);
        }
    }

    //上边交换太多,下边这种方式更容易体现出它的精髓
    //可能会有人认为上边那种是冒泡排序，
    //其实不是的，仔细想一想冒泡排序，每次都保证了最后的一位是最大的数字，这里并没有保证，而是一次一次的插入

    // for(int i = 1; i < NUM; i++) {
    //     int tmp = arr[i];
    //     for(k = i; (tmp < arr[k - 1]) && k != 0; k--) {
    //         arr[k] = arr[k - 1];
    //     }
    //     arr[k] = tmp;
    // }
}
void print_test(int * arr, int isfirst) {  
    if(isfirst) {
        printf("排序前：\n");
    } else {
        printf("排序后：\n");
    }
    for( int i = 0 ; i < 10; i ++ ) {
        printf("%d\t", arr[i]);        
    }
    printf("\n");
}
int main() {
    int arr[NUM] = {1, 9, 20, 3, 58, 52, 99, 131, 22, 79};
    print_test(arr,1);
    insert_sort(arr);
    print_test(arr,0);
    return 0;
}

4.希尔排序（7行）

// #include <bits/stdc++.h>
#include <iostream>
using namespace std;

void shell_sort(int *arr, int length){
    int gpa=0,i=0,j=0;
    for(gpa=length/2;gpa>=1;gpa/=2){
        for(i=gpa;i<length;i++){
            int temp=arr[i];
            for(j=i-gpa;j>=0&&temp<arr[j];j=j-gpa){
                arr[j+gpa]=arr[j];
            }
            arr[j+gpa]=temp;
        }
    }
}
int main(){
     int arr[14]={2,-1,4,1,7,6,3,6,9,8,12,7,9,7};
    shell_sort(arr,14);
    for(int i=0;i<14;i++){
        cout<<arr[i]<<" ";
    }

    return 0;

}

5.快速排序

#include <iostream>
#include <string>
#include <cstring>
using namespace std;



void quickSort(int *arr,int start,int end){ 
    if(start>=end){
        return ;
    }
    int l=start,r=end;
    int mid=(arr[(l+r)/2]);
    while(l<=r){
        while(arr[l]<mid){//一定不能用l<r, 必须是l<=r
            l++;
        }
        while(arr[r]>mid){
            r--;
        }
        if(l<=r){           //这个if一定不能少，因为l可能会在mid的右边出现
                            //若交换，可能把小的换到后边，大的换到前边。
            swap(arr[l],arr[r]);
            l++;r--;
        }
    }
    quickSort(arr,start,r);
    quickSort(arr,l,end);
}
int main(){
    // int arr[10]={2,-1,4,9,5,6,12,3,1,7};
    int arr[14]={2,-1,4,1,7,6,3,6,9,8,12,7,9,7};
    quickSort(arr,0,13);
    for(int i=0;i<14;i++){
        cout<<arr[i]<<" ";
    }
    

    return 0;
}

6.归并排序


#include <bits/stdc++.h>
using namespace std;


void MergeTwoIntervals(int *arr,int l1,int r1,int l2,int r2){
    int *temp=(int *)malloc(sizeof(int)*(r2-l1+1));
    int i=l1,j=l2,k=0;
    while(i<=r1||j<=r2){
        if((j>r2)||(i<=r1&&arr[i]<=arr[j])){
            temp[k++]=arr[i++];
        }else{
            temp[k++]=arr[j++];
        }
    }
    for(int i=l1;i<=r2;i++){
        arr[i]=temp[i-l1];
    }
    free(temp);
}
void MergeSort(int* arr,int l,int r){
    if(l >= r){
        return ;
    }
    int mid = (l + r)/2;
    MergeSort(arr,l,mid);
    MergeSort(arr,mid+1,r);
    MergeTwoIntervals(arr,l,mid,mid+1,r);
}
int main(){

     int arr[14]={2,-1,4,1,7,6,3,6,9,8,12,7,9,7};
    MergeSort(arr,0,13);
    for(int i=0;i<14;i++){
        cout<<arr[i]<<" ";
    }
return 0;
}

7.基数排序（9行）

#include <stdio.h>
#include <stdlib.h>
void radix_sort( int *arr, int len, int MaxNum ) {
    int * pattern = (int *)malloc(sizeof(int)*(MaxNum+1));  //因为没有用下标0，所以多开一个空间。
    for( int i = 0 ; i < MaxNum + 1; i ++ ) {
        pattern[i] = -1;
    }
    for( int i = 0; i < len ;i ++ ) {
        pattern[arr[i]] = arr[i];
    }
    int k = 0;
    for( int i = 0 ; i < MaxNum + 1; i ++ ) {
        if( pattern[i] != -1 ) {
        arr[k++] = pattern[i];
        }
    }
}
void print_test(int * arr, int isfirst) {  
    if(isfirst) {
        printf("排序前：\n");
    } else {
        printf("排序后：\n");
    }
    for( int i = 0 ; i < 10; i ++ ) {
        printf("%d\t", arr[i]);        
    }
    printf("\n");
}
int main() {
    int arr[10] = {1, 9, 20, 3, 58, 52, 99, 131, 22, 79};
    print_test(arr,1);
    radix_sort(arr,10, 131);
    print_test(arr,0);
    return 0;
}

8.计数排序（7行）

#include <stdio.h>
#include <stdlib.h>
#define NUM 10

void count_sort(int *arr, int MaxNum) {
    int * pattern = (int *)calloc(sizeof(int), MaxNum + 1);  //calloc分配空间帮你初始化为0
    for(int i = 0; i < NUM; i++) { 
        pattern[arr[i]] ++;
    }
    int k = 0;
    for(int i = 0; i < MaxNum + 1; i++) {
        if(pattern[i] != 0) {
            arr[k++] = i;
        }
    }
}

void print_test(int * arr, int isfirst) {  
    if(isfirst) {
        printf("排序前：\n");
    } else {
        printf("排序后：\n");
    }
    for( int i = 0 ; i < 10; i ++ ) {
        printf("%d\t", arr[i]);        
    }
    printf("\n");
}
int main() {
    int arr[NUM] = {1, 9, 20, 3, 58, 52, 99, 131, 22, 79};
    print_test(arr,1);
    count_sort(arr,131);
    print_test(arr,0);
    return 0;
}

9.桶排序(箱排序)

#include <stdio.h>
#include <stdlib.h>
#define NUM 10 //需要排序的数字个数
#define RANGE 10e3 //需要排序的数字最大的数字的次幂
void bucket_sort(int * arr, int len , int range) {
    int idx = 0;
    for( int i = 1; i < range ; i *= 10 ) {
       
        int * pattern = (int *)malloc (sizeof(int)*len*10);
        for( int i = 0;i < len*10 ; i ++ ) {
            pattern[i] = -1;
        }
        for( int j = 0; j < len ; j ++ ) {
           idx = arr[j]/i%10;
           *(pattern+idx*10+j) = arr[j];
        }
        int k = 0;
        for( int h = 0; h < len*10 ; h ++ ) {
           if(pattern[h] != -1) {
                arr[k++] = pattern[h]; 
           }
        }
    }
}
void print_test(int * arr, int isfirst) {  
    if(isfirst) {
        printf("排序前：\n");
    } else {
        printf("排序后：\n");
    }
    for( int i = 0 ; i < NUM; i ++ ) {
        printf("%d\t", arr[i]);        
    }
    printf("\n");
}
int main() {
    int arr[NUM] = {1, 9, 20, 3, 58, 52, 99, 131, 22, 79};
    print_test(arr,1);
    bucket_sort(arr, NUM, RANGE);
    print_test(arr,0);
    return 0;
}

10.堆排序

#include <stdio.h>
#include <stdlib.h>
int size = 0;
void heap_sort(int * heap, int val) {
    int hole = size ++ ;
    int parent = 0;
    for(; hole > 0 ; hole = parent) {
        parent = (hole - 1) / 2;
        if(heap[parent] < val) {
            break;
        }
        heap[hole] = heap[parent];
    }
    heap[hole] = val;
}
void pop(int * heap) {
    int tmp = heap[0];
    heap[0] = heap[--size];
    heap[size] = tmp;
    tmp = heap[0];  //这步不能少 
    //调整
    int parent = 0;
    int child = 0; 
    for(; (parent * 2 + 1) <= (size - 1); parent = child) {
        child = parent * 2 + 1;
        if((child < size - 1 ) && heap[child + 1] < heap[child]) {
            child += 1;
        }
        if(heap[child] < tmp) {
            heap[parent] = heap[child];
        } else {
            break;
        }
    }
    heap[parent] = tmp;
}
void print_test(int * arr, int isfirst) {  
    if(isfirst) {
        printf("排序前：\n");
    } else {
        printf("排序后：\n");
    }
    for( int i = 0 ; i < 10; i ++ ) {
        printf("%d\t", arr[i]);        
    }
    printf("\n");
}
int main() {
    int arr[10] = {1, 9, 20, 3, 58, 52, 99, 131, 22, 79};
      print_test(arr,1);
    int * heap = (int *)malloc(sizeof(int) * 10);
    for(int i = 0 ; i < 10; i ++ ) {
        heap[i] = -1;
    }
    for( int i = 0; i < 10; i ++ ) {
        heap_sort(heap, arr[i]);        //建堆
    }
    for(int i = 0; i < 10; i ++ ) {
        pop(heap);                       //依次取出，形成有序数组，不过因为这里用的是小顶堆，所以是降序
    }
    print_test(heap,0);     //打印测试
    return 0;
}
江游Infinite
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
冒泡排序和快速排序
cjydsg123的博客
08-23 398
排序算法中重要的两种排序
常见的八种基本排序的代码
tingzs111的博客
07-05 4282
简单的介绍了一下常见的七种排序以及一种非比较排序中的计数排序。
JS代码实现一些常见的排序算法
weixin_44741164的博客
04-14 1268
我根据排序思想，自己使用JavaScript代码实现的这些算法，包括基本的插入排序、冒泡排序、选择排序，以及升级的希尔排序、快速排序。
简单排序算法代码
xiaosutongxue的博客
05-03 1132
以下内容是对所学算法的一个整理 参考了 Runoob与OI WiKi 如有错误 烦请指正！ 插入排序 将无序子序列的元素依次通过比较插入有序子序列中 适用于基本正向有序/n较小的情况 选择排序 第i次选择时 “选择”序列中第i小的记录，并把该记录放到序列的第i个位置上 相当于每一趟都扫描剩余的序列元素 并将最小值放到剩余序列的第一个位置 已选择过的元素不再进行扫描 适用于地址排序 算法稳定性 ​ 假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即
七大排序算法总结
yingjian2215的博客
06-09 336
题记： 直接插入排序（稳定）-->希尔排序 ： 属于插入排序 简单选择排序（稳定）-->堆排序 ：属于选择排序 冒泡排序算法（稳定）-->快速排序 ：属于交换排序 归并排序（稳定）一.直接插入排序----O(n^2)-----稳定的 直接插入排序：是一种将一个记录插入到已经安排好序的有序表中，从而得到一个新的记录数增1的有序表。1.算法流程：1）初始时...
遗传算法的C语言简易实现.zip
最新发布
06-14
【遗传算法的C语言简易实现】是一个非常适合初学者掌握C语言编程技巧以及了解遗传算法的实践项目。遗传算法（Genetic Algorithm，GA）是一种借鉴生物进化理论中的自然选择和遗传机制来解决优化问题的计算方法。它...
Java实现简易排序
10-20
本篇文章将深入探讨Java中实现的三种经典排序算法：快速排序、插入排序和选择排序。 首先，我们来了解**快速排序**。快速排序是由英国计算机科学家C.A.R. Hoare在1960年提出的一种效率较高的排序算法。它的核心思想...
php代码-简易求差集
07-16
实际应用中，这些代码可能会根据具体需求进行调整，比如处理多个数组的差集，或者对差集进行其他操作，如排序、去重等。 总之，PHP中的差集操作是通过`array_diff()`函数或自定义循环逻辑实现的，可以有效地帮助...
js代码-4.1 有序链表的简易合并
07-16
本节将深入探讨如何使用JavaScript实现两个已排序的链表的简单合并。我们将通过分析标题和描述，结合标签“代码”，来解析这个知识点。 首先，有序链表是链表的一种特殊形式，其元素按升序或降序排列。链表由一系列...
c++实现的简易map
04-06
在C++编程语言中，`map`是一种关联容器，它按照...通过查看压缩包内的源代码，我们可以深入了解其实现细节，包括具体的算法、数据结构选择以及性能优化等。这为我们提供了深入理解C++自定义数据结构和容器设计的机会。
数据结构 常用八大排序算法及代码实现
热门推荐
海吹的技术博客
08-13 3万+
一、排序的介绍 1. 排序的分类 按照排序过程中所依据的原则的不同可以分类为: ►插入排序：直接插入排序 希尔排序 ►交换排序：冒泡排序 快速排序 ►选择排序：简单选择排序 堆排序 ►归并排序 ►基数排序 2. 排序算法比较 排序方法 最好时间 平均时间 最坏时间 ...
各种排序算法汇总
weixin_34126557的博客
03-04 318
目录 简介 交换排序 冒泡排序 快速排序 插入排序 直接插入排序 希尔排序 选择排序 简单选择排序 堆排序 归并排序 基数排序 总结 简介 排序是计算机内经常进行的一种操作，其目的是将一组“无序”的记录序列调整为“有序”的记录序列。分内部排序和外部排序。若整个排序过程不需要访问外存便能完成，则称此类排序问题为内部排序。反之，若参加排序的记录数量很大，整个序列的排序...
几种排序算法代码
L色J忆的专栏
07-09 575
选择排序void select(int[] a) { for(int i = 0; i < a.length;i ++) { for(int j = i; j < a.length; j ++) { int ai = a[i]; int aj = a[j]; if(a[i] > a[j]) { a[i]
【数据结构】八大排序算法-代码实现+复杂度分析+稳定性分析+总结
chuxinchangcun的博客
09-27 872
注意：1.对于快速排序:如果加了三数取中 + 三路归并 最坏就不是O(N^2)2.为了绝对的速度选快排，为了省空间选堆排，为了稳定性选归并3.时间复杂度:O(N*logN)，额外空间复杂度低于O(N)，且稳定的基于比较的排序是不存在的。
10种排序算法及代码实现
weixin_45548912的博客
05-27 2039
十大经典排序算法 0、算法概述 0.1 算法分类 十种常见排序算法可以分为两大类： 比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。 非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。 0.2 算法复杂度 0.3 相关概念 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。 不稳定：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b
经典排序算法(附代码)
weixin_48492905的博客
11-13 533
常见的排序算法 有趣的视频：排序舞蹈 一、直接插入排序 /*时间复杂度：最坏情况下：O(n^2) 数组是无序的；最好情况：O(n) 数组有序 * 空间复杂度：O(1) * */ //稳定 //插入排序 特点：越有序，越快 public static void insertSort(int[] array) { for (int i = 1; i <array.length ; i++) { int tmp = arr
排序算法总结
yizhiniu_xuyw的专栏
11-15 2125
前言 查找和排序算法是算法的入门知识，其经典思想可以用于很多算法当中。因为其实现代码较短，应用较常见。所以在面试中经常会问到排序算法及其相关的问题。但万变不离其宗，只要熟悉了思想，灵活运用也不是难事。 一般在面试中最常考的是快速排序和归并排序，并且经常有面试官要求现场写出这两种排序的代码。对这两种排序的代码一定要信手拈来才行。还有插入排序、冒泡排序、堆排序、基数排序、桶排序等。面试官对于这些排序可能会要求比较各自的优劣、各种算法的思想及其使用场景。还有要会分析算法的时间和空间复杂度。通常查找和排序算法的
十大经典排序算法(代码实现)，建议收藏
qq_31716541的博客
07-12 113
十大经典排序算法(代码实现)，建议收藏
常见排序及代码实现
5683的博客
09-17 437
1 冒泡排序 1.1 排序说明 所谓冒泡，说的是每次都是相邻元素进行比较，从开始索引到结束索引，不断冒出的过程。 以升序为例： 第一轮 所有元素都参与，从索引0元素开始，和索引1元素相较，如果索引大的数值小，则互换位置，接着索引1元素继续以同样的方式和索引2元素相较……一直到最后一个元素。 第一轮下来，就能将所有元素中最大的元素冒泡到最后索引的位置。 第二轮 一样从索引0元素开始冒泡，不过第一轮已经确定最后一个为最大元素，所以这次只需要冒泡到倒数第二个元素。 第二轮也一样，可以将这次参与冒泡的元素中的最大
大二数据结构与算法简易地铁售票系统的计划表
06-08
2. 第2-3周：学习数据结构和算法的基础知识，如数组、链表、队列、栈、排序等。 3. 第4-5周：设计数据模型，包括车站、票价、乘客等数据结构，建立数据之间的关联关系。 4. 第6-7周：实现基本功能，包括售票、查询...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值