最全排序代码整理

最新推荐文章于 2022-09-25 21:41:25 发布
最新推荐文章于 2022-09-25 21:41:25 发布
阅读量494 收藏 2
点赞数
分类专栏： 考研
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/REfusing/article/details/107598863
版权

本篇博客部分代码实现参考于天勤数据结构，如果有那块代码出现问题，请指出。

文章目录

插入排序

直接插入排序

#include<stdio.h>
#include<iostream>
using namespace std;

void InsertSort(int *a, int n){
    int i, j, temp;
    for(int i = 1; i < n; i++){
        temp = a[i];
        j = i-1;
        while(j >= 0 && a[j] > temp){
            a[j+1] = a[j];
            j--;
        }
        a[j+1] = temp;
    }
}
int main(){
    int n, a[1000];
    scanf("%d", &n);
    for(int i = 0; i < n; i++)scanf("%d", &a[i]);
    InsertSort(a, n);
    for(int i = 0; i < n; i++){
        if(i != 0)printf(" ");
        printf("%d", a[i]);
    }
    printf("\n");

return 0;
}
/*
8
49 38 65 97 76 13 27 49

*/

2-路插入排序

#include<stdio.h>
#include<iostream>
using namespace std;
//使用循环队列，类似于约瑟夫环
//减少我们正常时候在头部插入的次数
void TwoRoadInsertSort(int *a, int n){
     int front , rear, que[n];
     front = rear = 0;
     que[0] = a[0];
     for(int i = 1; i < n; i++){
        if(a[i] >= a[rear]){
            rear = (rear+1)%n;
            que[rear] = a[i];
        }
        else if(a[i] < a[front]){
            front = (front-1+n)%n;
            que[front] = a[i];
        }
        else{
            int pos = (rear+1)%n;//提前保存ear的下一个位置，因为插入一个数，rear一定向后移动1个位置
            while(a[i] < que[rear]){
                int temp = (rear+1)%n;
                que[temp] = que[rear];
                rear = (rear-1+n) % n;
            }
            rear = (rear+1)%n;
            que[rear] = a[i];
            rear = pos;

        }
     }
     int i = 0;
     while(front != rear){
        a[i++] = que[front];
        front = (front+1)%n;
     }
}


int main(){
    int n, a[1000];
    scanf("%d", &n);
    for(int i = 0; i < n; i++)scanf("%d", &a[i]);
    TwoRoadInsertSort(a, n);
    for(int i = 0; i < n; i++){
        if(i != 0)printf(" ");
        printf("%d", a[i]);
    }
    printf("\n");

return 0;
}
/*
8
49 38 65 97 76 13 27 49

*/

表插入排序

#include<stdio.h>
#include<iostream>
using namespace std;
//类似于链表的使用，只不过这个表用的是静态链表
//为了存储方方便我们把数组的作为头
//所以从1开始存储
//经过不断的思考，我选择尾插法实现，
struct Node{
       int data;
       int next;
};

void TableSort(Node *a, int n){
     a[0].data = INT_MAX;
     a[0].next = 1;
     for(int i = 2; i <= n; i++){
        int p = a[0].next;
        int pre = 0;
        while(a[i].data > a[p].data){
            pre = p;
            p = a[p].next;
            if(p == 0)break;
        }
        a[pre].next = i;
        a[i].next = p;
     }
}

int main(){
    int n;
    Node a[1000];
    scanf("%d", &n);
    for(int i = 1; i <= n; i++)scanf("%d", &a[i].data);
    for(int i = 0; i <= n; i++)a[i].next = 0;
    TableSort(a, n);
    for(int i = a[0].next; i != 0; i = a[i].next){
        printf("%d ", a[i].data);
    }
    printf("\n");

return 0;
}
/*
8
49 38 65 97 76 13 27 49

*/

折半插入排序

#include<stdio.h>
#include<iostream>
using namespace std;

int BinarySearch(int *a, int l, int r, int k) //使用二分确定范围，确定查找的范围，范围是大于等于的后一个位置
{
    while(l < r)
    {
        int mid = l+r >>1;
        if(a[mid] >= k)r = mid;
        else l = mid+1;

    }
    return l;
}



void BinarySort(int *a, int n)
{
    for(int i = 1; i < n; i++)
    {
        int temp = a[i];
        if(temp >= a[i-1])continue;//如果最后当位置大于整体有序的那么就不需要查找了
        int pos = BinarySearch(a, 0, i-1, temp);
        cout<<pos<<endl;
        for(int j = i-1; j >= pos; j--)
        {
            a[j+1] = a[j];
        }
        a[pos] = temp;
    }
}

int main()
{
    int n, a[1000];
    scanf("%d", &n);
    for(int i = 0; i < n; i++)scanf("%d", &a[i]);
    //InsertSort(a, n);

    BinarySort(a,n);
    //int pos = BinarySearch(a, 0, n-1, 39);
    //cout<<pos<<endl;
    for(int i = 0; i < n; i++)
    {
        if(i != 0)printf(" ");
        printf("%d", a[i]);
    }
    printf("\n");

    return 0;
}
/*
8
49 38 65 97 76 13 27 49

*/

希尔排序

#include<stdio.h>
#include<iostream>
using namespace std;

//希尔排序的实现就是利用的之前的插入方法，只不过把之前的i换成了gap,每一次走gap个单位

void ShellSort(int *a, int n){
     for(int gap = n /2; gap > 0; gap /= 2){
        for(int i = gap; i < n; i += gap){
                int j = i;
            while(j-gap >= 0 && a[j] < a[j-gap]){//注意一定是先判断k>= 0 的情况，如果不这么判断如何为－的
//                    a[k+gap] = a[k];     //时候会报错了
//                    k -=   gap;//使用交换的方法更简洁
                    swap(a[j], a[j-gap]);
                    j -= gap;
            }
        }
     }
}

int main()
{
    int n, a[1000];
    scanf("%d", &n);
    for(int i = 0; i < n; i++)scanf("%d", &a[i]);


    ShellSort(a,n);

    for(int i = 0; i < n; i++)
    {
        if(i != 0)printf(" ");
        printf("%d", a[i]);
    }
    printf("\n");

    return 0;
}
/*
8
49 38 65 97 76 13 27 49

*/

交换排序

冒泡排序

#include<stdio.h>
#include<iostream>
using namespace std;
//冒泡排序最外层只需要n-1次，n次也行
//先确定最大的泡在最后一个位置
//然后确定第二大的泡在倒数第二个位置
void BubbleSort(int *a, int n){
     for(int i = 0; i < n-1; i++){
        for(int j = 0; j < n-1-i; j++){
            if(a[j] > a[j+1])swap(a[j], a[j+1]);
           // if(a[i] > a[j])swap(a[i], a[j]);
        }
     }


}

int main()
{
    int n, a[1000];
    scanf("%d", &n);
    for(int i = 0; i < n; i++)scanf("%d", &a[i]);
    BubbleSort(a,n);
    for(int i = 0; i < n; i++)
    {
        if(i != 0)printf(" ");
        printf("%d", a[i]);
    }
    printf("\n");

    return 0;
}
/*
8
49 38 65 97 76 13 27 49

*/

快速排序

#include<stdio.h>
#include<iostream>
using namespace std;
void QuickSort(int *a, int l, int r)
{
    int i = l, j = r;
    if(l < r)
    {
        int temp = a[l];
        while(i < j)
        {
            while(i < j && a[j] >= temp)j--;
            if(i < j)a[i] = a[j], i++;
            while(i < j && a[i] <= temp)i++;
            if(i < j)a[j] = a[i], j--;

        }
        a[i] = temp;
        QuickSort(a, l, i-1);
        QuickSort(a, i+1, r);
    }
}

int main()
{
    int n, a[1000];
    scanf("%d", &n);
    for(int i = 0; i < n; i++)scanf("%d", &a[i]);
    QuickSort(a,0, n-1);
    for(int i = 0; i < n; i++)
    {
        if(i != 0)printf(" ");
        printf("%d", a[i]);
    }
    printf("\n");

    return 0;
}
/*
8
49 38 65 97 76 13 27 49

*/

选择排序

简单选择排序

#include<stdio.h>
#include<iostream>
using namespace std;
void SelectSort(int *a, int n){
     int i, j, k, temp;
     for(int i = 0; i < n; i++){
        k = i;
        for(int j = i+1; j < n; j++){
            if(a[k] > a[j])k = j;
        }
        if(k != i)swap(a[i], a[k]);
     }

}

int main()
{
    int n, a[1000];
    scanf("%d", &n);
    for(int i = 0; i < n; i++)scanf("%d", &a[i]);
    SelectSort(a,n);
    for(int i = 0; i < n; i++)
    {
        if(i != 0)printf(" ");
        printf("%d", a[i]);
    }
    printf("\n");

    return 0;
}
/*
8
49 38 65 97 76 13 27 49

*/

堆排序

#include<stdio.h>
#include<iostream>
using namespace std;
void Sift(int *a, int l, int r){//从1开始
    int i = l, j = i*2;
    int temp = a[i];
    while(j <= r){
        if(j < r && a[j] < a[j+1])j++;
        if(a[j] > temp){
            a[i] = a[j];
            i = j;
            j = i*2;
        }
        else break;
    }
    a[i] = temp;
}
void HeadSort(int *a, int n){
     for(int i = n / 2; i >= 1; i--)Sift(a, i, n);
     for(int i = n; i >= 2; i--){
        swap(a[1], a[i]);
        Sift(a, 1, i-1);
     }

}
int main()
{
    int n, a[1000];
    scanf("%d", &n);
    for(int i = 1; i <= n; i++)scanf("%d", &a[i]);
    HeadSort(a, n);
    for(int i = 1; i <= n; i++)
    {
        if(i != 1)printf(" ");
        printf("%d", a[i]);
    }
    printf("\n");

    return 0;
}
/*
8
49 38 65 97 76 13 27 49

*/

归并排序

二路归并排序
#include<stdio.h>
#include<iostream>
using namespace std;
void Merge(int *a, int l, int m, int r){
     int i = l, j = m+1;
     int temp[r-l+1], k = 0;
     while(i <= m && j <= r){
        if(a[i] > a[j])temp[k++] = a[j++];
        else temp[k++] = a[i++];
     }
     while(i <= m)temp[k++] = a[i++];
     while(j <= r)temp[k++] = a[j++];
     for(int i = 0; i < k; i++){
        a[l+i] = temp[i];
     }
}
void MergeSort(int *a, int l, int r){
   if(l < r){
     int mid = l+r>>1;
     MergeSort(a, l, mid);
     MergeSort(a, mid+1, r);
     Merge(a, l, mid, r);
   }
}
int main()
{
    int n, a[1000];
    scanf("%d", &n);
    for(int i = 0; i < n; i++)scanf("%d", &a[i]);
    MergeSort(a,0, n-1);
    for(int i = 0; i < n; i++)
    {
        if(i != 0)printf(" ");
        printf("%d", a[i]);
    }
    printf("\n");

    return 0;
}
/*
8
49 38 65 97 76 13 27 49

*/

基数排序

基数排序

#include<stdio.h>
#include<iostream>
#include<string.h>
using namespace std;
void RadixSort(int *a, int n){
     int max = a[0], base = 1, bucket[20], temp[n];
     for(int i = 0; i < n; i++)
        if(a[i] > max)max = a[i];
     while(max / base > 0){
        memset(bucket, 0, sizeof bucket);
        for(int i = 0; i < n; i++){
            bucket[a[i]/base%10]++;  //确定桶的中数字的个数
        }
        for(int i = 1; i < 10; i++)bucket[i] += bucket[i-1];
        for(int i = n-1; i >= 0; i--){
            temp[bucket[a[i]/base%10] -1] = a[i];
            bucket[a[i]/base%10]--;
        }
        for(int i = 0; i < n; i++){
            a[i] = temp[i];
        }
        base *= 10;
     }


}

int main()
{
    int n, a[1000];
    scanf("%d", &n);
    for(int i = 0; i < n; i++)scanf("%d", &a[i]);
    RadixSort(a, n);//注意遍历范围[0,n);
    for(int i = 0; i < n; i++)
    {
        if(i != 0)printf(" ");
        printf("%d", a[i]);
    }
    printf("\n");

    return 1;
}
/*
8
49 38 65 97 76 13 27 49

10
278 109 63 930 589 184 505 269 8 83

*/
Re:fused
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
各类排序代码实现
啊奥的博客
07-23 4811
以下各种排序算法是我自己跟着算法描述写的（有参考其他人的），直接贴到VS里就能用，如果要看懂的话还是需要了解一下各种排序算法的实现原理 先随手总结一下各种排序的时间复杂度以及稳定性 排序算法 时间复杂度 辅助空间 稳定性 冒泡排序(交换排序类) O(n^2) ...
常见的八种基本排序的代码
tingzs111的博客
07-05 4189
简单的介绍了一下常见的七种排序以及一种非比较排序中的计数排序。
各种排序算法代码
qq_46595907的博客
11-01 305
1.冒泡排序 /* 冒泡排序算法： 平均时间复杂度： O(n²) 最好情况： O(n) 最坏情况： O(²) 空间复杂度： O(1) 排序方式： In-place 稳定性： 稳定 */ #include <stdio.h> #include <stdlib.h> void bubblingSort(int arr[], int n) {
排序及其代码详解~
m0_64028711的博客
09-25 1095
有七大重要排序及其代码详解~ 此处end表示一组数据有序序列的最后一位，用 i 控制，tmp则表示有序数据之后的一位数据，也就是我们需要插入有序数列中的数。
通讯录排序代码整理与源码
12-27
使用qsort函数来对结构体数组进行快速排序，提高效率和简化代码。 使用atoi函数来将字符串形式的生日转换为整数形式，便于比较和计算年龄。 使用结构体数组来存储通讯录的信息，方便进行排序和输出。 使用qsort函数...
C#实现排序的代码详解
08-25
在本篇文章里小编给大家整理的是关于C#实现排序的代码以及相关知识点，需要的朋友们参考下。
最简单易懂的java数组排序方法整理
08-25
主要给大家整理介绍了最简单易懂的java数组排序方法，文中通过示例代码介绍的非常详细，对大家学习或者使用java具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
最全C语言难点分析整理
11-22
C语言难点分析整理 本文主要是对C语言中的一些重要知识点进行总结和分析，旨在帮助初学者更好地学习和掌握C语言的基本概念和应用。 一、变量的作用域和存储类别 变量是C语言的基本组成部分，了解变量的作用域和...
JavaScript之排序函数_动力节点Java学院整理
01-21
排序算法 排序也是在程序中经常用到的算法。无论使用冒泡排序还是快速排序，排序的核心是比较两个元素的大小。如果是数字，我们可以直接比较，但如果是字符串或者两个对象呢？直接比较数学上的大小是没有意义的，...
外排序完整版代码
03-29
NULL 博文链接：https://zealove.iteye.com/blog/1279549
简单排序算法代码
xiaosutongxue的博客
05-03 1122
以下内容是对所学算法的一个整理 参考了 Runoob与OI WiKi 如有错误 烦请指正！ 插入排序 将无序子序列的元素依次通过比较插入有序子序列中 适用于基本正向有序/n较小的情况 选择排序 第i次选择时 “选择”序列中第i小的记录，并把该记录放到序列的第i个位置上 相当于每一趟都扫描剩余的序列元素 并将最小值放到剩余序列的第一个位置 已选择过的元素不再进行扫描 适用于地址排序 算法稳定性 ​ 假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即
冒泡排序和快速排序
cjydsg123的博客
08-23 381
排序算法中重要的两种排序
数据结构 常用八大排序算法及代码实现
热门推荐
海吹的技术博客
08-13 2万+
一、排序的介绍 1. 排序的分类 按照排序过程中所依据的原则的不同可以分类为: ►插入排序：直接插入排序 希尔排序 ►交换排序：冒泡排序 快速排序 ►选择排序：简单选择排序 堆排序 ►归并排序 ►基数排序 2. 排序算法比较 排序方法 最好时间 平均时间 最坏时间 ...
快速排序(代码通俗易懂，干净整洁)
qq_50723277的博客
03-21 2万+
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、快速排序思路二、快速排序代码三、读入数据总结 前言 快速排序的特点 1、快速排序是对冒泡算法的改进。 2、快速排序的基本思想是对要排序的数组进行划分，使左边的小于某个数，右边的大于某个数。重复执行以上划分，直到有序为止。(这里主要针对递增排序) 提示：以下是本篇文章正文内容，下面案例可供参考 一、快速排序思路 (1)定义两个变量low、high分别标识数组的第一个元素下标和最后一个元素下标。 (2)定义变量key先存储.
排序代码
weixin_44937550的博客
05-09 753
方法一： //对当前数组进行排序 int[] intArray = new int[7] { 45, 96, 212, 23, 109, 78, 36 }; int length = intArray.Length; int i; Console.WriteLine("arra...
各种常见排序代码整理
花花世界
10-28 444
插入、冒泡、选择、快速
排序<简单代码>
其实我是C先生--的博客
07-21 306
排序 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 23610    Accepted Submission(s): 6377 Problem Description 输入一行数字，如果我们把这行数字中的‘5’都看成空格
pycharm 代码整理
最新发布
04-19
在PyCharm中，代码整理是指对代码进行格式化和排版，使其具有良好的可读性和一致的风格。PyCharm提供了多种方式来进行代码整理： 1. 自动代码整理：PyCharm可以根据预设的代码风格规则，自动对代码进行格式化和排版...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值