自己整理的八种排序（c/c++）

已于 2022-12-03 13:44:32 修改
阅读量323 收藏
点赞数
文章标签： 算法 c++ 数据结构
于 2022-11-30 22:24:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57741101/article/details/128123615
版权 
//1.直接插入排序
void InsertSort(int A[],int n){
    int i,j;
    for(i = 2;i < n;i++){
        if(A[i-1] > A[i]){
        A[0] = A[i];
        for(j = i-1; jA[j] > A[0];--){
            A[j+1] = A[j];
        }
        A[j+1] = A[0];
        }
    }
}
1.1折半插入排序
void InsertSort(int A[],int n){
    int i,j,left,right,mid;
    for(i = 2;i < n; i++){
        A[0] = A[i];
        left = 1,right = i - 1;
         while(left <= right){
             mid = (left + right)/2;
             if(A[mid] > A[0])    right = mid - 1;
             else                 left = mid + 1; 
         }
         for(j = i - 1;j >= right + 1;j--){
             A[j + 1] = A[j];
         }
         A[j + 1] = A[0];
    }
}

2.冒泡排序
void BubbleSort(int A[],int n){
    int i,j;
    for(i = 0;i < n - 1; i++){
        bool flag = false;
        for(j = n - 1;j > i; j--){
            if(A[j - 1] > A[j]){
                swap(A[j - 1],A[j]);
                flag = true;
            }
        }

3.快速排序
int MAXN = 1000;
int arr[MAXN];

void Partition(int left,int right){
    while(left < right){
        while(left < right && arr[left] < arr[right]){
            right --;
        }
        swap(arr[left],arr[right]);

        while(left < right && arr[left] < arr[right]){
        left++;
        }
        swap(arr[left],arr[right]);
    }
    return left;
}


void QuickSort(int left,int right){
    if(left < right){
        int pos = Partition(left,right);
        QuickSort(left, pos - 1);
        QuickSort(pos + 1, right);
    } 
}


4.简单选择排序
void SelectSort(int A[],int n){
    int i,j,min;
    for(i = 0; i < n - 1; i++){
        min = i;
        for(j = i + 1;j < n; j++){
            if(A[min] > A[j]){
                min = j;
            }
            if(min != i)
            swap(A[min],A[i]);
        }
    }
}
        if(flag == false)  return;
    }
}

//5.归并排序
int arr[MAXN];
int temp[MAXN];

void Combine(int left,int mid,int right){
    int i = left;
    int k = left;
    int j = mid + 1;
    while(i <= mid && j <= right){
        if(arr[i] < arr[j])
        temp[k++] = arr[i++];
        else 
        temp[k++] = arr[j++];
    }    

    while(i <= mid)      temp[k++] = arr[i++];
    while(j <= right)    temp[k++] = arr[j++];

    for(k = left; k <= right; k++){
        arr[k] = temp[k];
    }
}


void MergeSort(int left,int right){
    if(left < right){
        int mid = (left + right)/2;
        MergeSort(left,mid);
        MergeSort(mid + 1,right);
        Combine(left,mid,right);
    }
}





//6.快速排序
#include <iostream>
#include <cstdio>
#include <cstdlib>     //random函数
#include <algorithm>   //交换函数

using namespace std;

const int MAXN = 1000 + 10;

int arr[MAXN];

Partition(int arr[],int left, int right){
    while(left < right){
        while(left < right && arr[left] <= arr[right]){
            right--;
        }
        swap(arr[left],arr[right]);
        while(left < right && arr[left] <= arr[right]){
            left++;
        }
        swap(arr[left],arr[right]);
    }
    return left;
}

void QuickSort(int arr[],int left, int right){
    if(left < right){
        int position = Partition(arr,left, right);
        QuickSort(arr,left, position - 1);
        QuickSort(arr,position + 1,right);
    }
}

int main(){
    int n;
    scanf("%d",&n);
    for(int i=0; i<n; i++){
        scanf("%d",&arr[i]);
    }
    QuickSort(arr,0,n-1);
    for(int i=0; i<n; i ++){
        printf("%d ",arr[i]);
    }
    printf("\n");
    system("pause");
    return 0;
}

#include <iostream>
#include <cstdio>

using namespace std;

const int MAXN = 1000 + 10;

int arr[MAXN];
int temp[MAXN];

void Combine(int arr[],int temp[],int left, int middle, int right){
    int i = left;
    int j = middle + 1;
    int k = left;
    while(i<=middle && j<= right){
        if(arr[i] <= arr[j]){
            temp[k++] = arr[i++];
        }else{
            temp[k++] = arr[j++];
        }
    }
    while(i <= middle){
        temp[k++] = arr[i++];
    }
    while(j<=right){
        temp[k++] = arr[j++];
    }
    for(k = left; k <= right; k++){
        arr[k] = temp[k];
    }
}


void MergeSort(int arr[],int left, int right){
    if(left < right){
        int middle = left +(right - left)/2;
        MergeSort(arr,left,middle);
        MergeSort(arr,middle+1, right);
        Combine(arr,temp,left,middle,right);
    }
}

int main(){
    int n;
    scanf("%d",&n);
    for(int i=0; i<n; i++){
        scanf("%d",&arr[i]);
    }
    MergeSort(arr,0,n-1);
    for(int i=0; i<n; i++){
        printf("%d ",arr[i]);
        }
    return 0;
}
//1.直接插入排序
void InsertSort(int A[],int n){
    int i,j;
    for(i = 2;i < n;i++){
        if(A[i-1] > A[i]){
        A[0] = A[i];
        for(j = i-1; jA[j] > A[0];--){
            A[j+1] = A[j];
        }
        A[j+1] = A[0];
        }
    }
}

1.1折半插入排序
void InsertSort(int A[],int n){
    int i,j,left,right,mid;
    for(i = 2;i < n; i++){
        A[0] = A[i];
        left = 1,right = i - 1;
         while(left <= right){
             mid = (left + right)/2;
             if(A[mid] > A[0])    right = mid - 1;
             else                 left = mid + 1; 
         }
         for(j = i - 1;j >= right + 1;j--){
             A[j + 1] = A[j];
         }
         A[j + 1] = A[0];
    }
}

2.冒泡排序
void BubbleSort(int A[],int n){
    int i,j;
    for(i = 0;i < n - 1; i++){
        bool flag = false;
        for(j = n - 1;j > i; j--){
            if(A[j - 1] > A[j]){
                swap(A[j - 1],A[j]);
                flag = true;
            }
        }


3.快速排序
int MAXN = 1000;
int arr[MAXN];

void Partition(int left,int right){
    while(left < right){
        while(left < right && arr[left] < arr[right]){
            right --;
        }
        swap(arr[left],arr[right]);

        while(left < right && arr[left] < arr[right]){
        left++;
        }
        swap(arr[left],arr[right]);
    }
    return left;
}


void QuickSort(int left,int right){
    if(left < right){
        int pos = Partition(left,right);
        QuickSort(left, pos - 1);
        QuickSort(pos + 1, right);
    } 
}


4.简单选择排序
void SelectSort(int A[],int n){
    int i,j,min;
    for(i = 0; i < n - 1; i++){
        min = i;
        for(j = i + 1;j < n; j++){
            if(A[min] > A[j]){
                min = j;
            }
            if(min != i)
            swap(A[min],A[i]);
        }
    }
}
        if(flag == false)  return;
    }
}

//5.归并排序
int arr[MAXN];
int temp[MAXN];

void Combine(int left,int mid,int right){
    int i = left;
    int k = left;
    int j = mid + 1;
    while(i <= mid && j <= right){
        if(arr[i] < arr[j])
        temp[k++] = arr[i++];
        else 
        temp[k++] = arr[j++];
    }    

    while(i <= mid)      temp[k++] = arr[i++];
    while(j <= right)    temp[k++] = arr[j++];

    for(k = left; k <= right; k++){
        arr[k] = temp[k];
    }
}



void MergeSort(int left,int right){
    if(left < right){
        int mid = (left + right)/2;
        MergeSort(left,mid);
        MergeSort(mid + 1,right);
        Combine(left,mid,right);
    }
}

//6.快速排序
#include <iostream>
#include <cstdio>
#include <cstdlib>     //random函数
#include <algorithm>   //交换函数

using namespace std;

const int MAXN = 1000 + 10;

int arr[MAXN];

Partition(int arr[],int left, int right){
    while(left < right){
        while(left < right && arr[left] <= arr[right]){
            right--;
        }
        swap(arr[left],arr[right]);
        while(left < right && arr[left] <= arr[right]){
            left++;
        }
        swap(arr[left],arr[right]);
    }
    return left;
}

void QuickSort(int arr[],int left, int right){
    if(left < right){
        int position = Partition(arr,left, right);
        QuickSort(arr,left, position - 1);
        QuickSort(arr,position + 1,right);
    }
}

int main(){
    int n;
    scanf("%d",&n);
    for(int i=0; i<n; i++){
        scanf("%d",&arr[i]);
    }
    QuickSort(arr,0,n-1);
    for(int i=0; i<n; i ++){
        printf("%d ",arr[i]);
    }
    printf("\n");
    system("pause");
    return 0;
}

//5.归并排序
#include <iostream>
#include <cstdio>

using namespace std;

const int MAXN = 1000 + 10;

int arr[MAXN];
int temp[MAXN];

void Combine(int arr[],int temp[],int left, int middle, int right){
    int i = left;
    int j = middle + 1;
    int k = left;
    while(i<=middle && j<= right){
        if(arr[i] <= arr[j]){
            temp[k++] = arr[i++];
        }else{
            temp[k++] = arr[j++];
        }
    }
    while(i <= middle){
        temp[k++] = arr[i++];
    }
    while(j<=right){
        temp[k++] = arr[j++];
    }
    for(k = left; k <= right; k++){
        arr[k] = temp[k];
    }
}


void MergeSort(int arr[],int left, int right){
    if(left < right){
        int middle = left +(right - left)/2;
        MergeSort(arr,left,middle);
        MergeSort(arr,middle+1, right);
        Combine(arr,temp,left,middle,right);
    }
}

int main(){
    int n;
    scanf("%d",&n);
    for(int i=0; i<n; i++){
        scanf("%d",&arr[i]);
    }
    MergeSort(arr,0,n-1);
    for(int i=0; i<n; i++){
        printf("%d ",arr[i]);
        }
    return 0;
}

m0_57741101
关注
为各位学弟学妹整理的C语言/C++相关笔试面试题
C语言与CPP编程的博客
04-29 7261
1 变量的声明和定义有什么区别 变量的定义为变量分配地址和存储空间， 变量的声明不分配地址。一个变量可以在多个地方声明， 但是只在一个地方定义。加入extern 修饰的是变量的声明，说明此变量将在文件以外或在文件后面部分定义。 说明：很多时候一个变量，只是声明不分配内存空间，直到具体使用时才初始化，分配内存空间， 如外部变量。 intmain() { externintA; //这是个声明而不是定义，声明A是一个已经定义了的外部变量 //注意：声明外部变量时可以把变量类型去...
蓝桥杯重点（C/C++）
热门推荐
m0_71934846的博客
01-17 5万+
蓝桥杯重点（C/C++）
C/C++最全排序算法汇总，原理+代码
m0_68557563的博客
09-17 1031
排序是计算机内经常进行的一种操作，其目的是将一组“无序”的记录序列调整为“有序”的记录序列。分内部排序和外部排序。若整个排序过程不需要访问外存便能完成，则称此类排序问题为内部排序。反之，若参加排序的记录数量很大，整个序列的排序过程不可能在内存中完成，则称此类排序问题为外部排序。内部排序的过程是一个逐步扩大记录的有序序列长度的过程。将杂乱无章的数据元素，通过一定的方法按关键字顺序排列的过程叫做排序。假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，
C语言/C++学习路线图（2021整理）
weixin_55305220的博客
11-11 8486
C++是C语言的继承，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行以继承和多态为特点的面向对象的程序设计。C++擅长面向对象程序设计的同时，还可以进行基于过程的程序设计，因而C++就适应的问题规模而论，大小由之。 接下来是小编整理过C/C++工程师必备知识的思维导图。 初学者看到这么密集的知识点，是不是有点眼晕呢？的确，C/C++是一门知识面覆盖很广的学科。想学好C/C++的你并不需要慌张，内容虽多，但依然有法可依。只要有足够的耐心和毅力，加上正
C++的几种排序
weixin_57764808的博客
05-30 1236
在C++里面，有个sort函数，这是一个排序； sort函数基本使用。 输出结果：1 3 3 4 4 5 5 6 8 9 Sort(a,a+10);a就是数组a的开头，a+10就是尾节点；可以这么理解； 2.冒泡排序 在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。 冒泡排序基本使用方法 3.选择排序 在要排序的一组数中，选出
八大排序汇总（C++）
TNT_xixixi的博客
02-20 942
目录 认识时间复杂度 排序算法中的稳定性 八大排序性能对比​ 冒泡排序 选择排序 插入排序 归并排序 快速排序 堆排序 希尔排序 认识时间复杂度 常数时间的操作：一个操作如果和数据量没有关系，每次都是固定时间内完成的操作，叫做常数操作。 时间复杂度：时间复杂度为一个算法流程中，在最差情况下，常数操作数量的指标。常用O（读作bigO）来表示。具体来说，在常...
booksmanage.rar_教育系统应用_C/C++_
08-11
C/C++是两种广泛应用于系统开发和软件工程的编程语言。C语言以其简洁、高效和灵活性而闻名，常用于底层系统编程；C++则在C语言基础上增加了面向对象的特性，使得程序设计更加模块化和可重用。在这个图书管理系统中，...
program.rar_嵌入式/单片机/硬件编程_C/C++_
08-12
在IT领域，嵌入式系统、单片机和...总的来说，"program.rar"是一个实用的教育资源，涵盖了嵌入式编程中常见的排序和查找算法，为学习者提供了实践平台，有助于提升C/C++编程技能，特别是针对硬件编程环境的理解和应用。
c.rar_单片机开发_C/C++_
08-12
在IT行业中，单片机开发是一项基础且重要的技能，它涉及到硬件与软件的结合，而C/C++语言是这类开发的常用编程工具。本压缩包“c.rar”聚焦于C语言的经典算法，对于想要深入理解和掌握C语言编程的开发者来说，无疑是...
算法刷题：300. 最长递增子序列、674. 最长连续递增序列、718. 最长重复子数组、1143. 最长公共子序列
qq_61936886的博客
09-12 495
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。但dp[i][0] 和dp[0][j]要初始值，因为 为了方便递归公式dp[i][j] = dp[i - 1][j - 1] + 1;2.递推公式：当A[i - 1] 和B[j - 1]相等的时候，dp[i][j] = dp[i - 1][j - 1] + 1;
算法知识点——常用输入输出数据的方式
5233的博客
09-12 291
除了换行之外，还会清空缓存区，而清空缓存区这件事情会耗时很久，因此为了提高速度，一般直接：cout << “\n”;2、n组输入输出(n不确定）1、n组输入输出(n确定）3、 复杂的输入输出。
Java数据结构（十）——冒泡排序、快速排序
xiaokuer_的博客
09-11 1179
文章介绍了冒泡排序和快速排序，快速排序的内容包括：划分方式、优化策略以及非递归实现
算法基础-约数
qq_65186476的博客
09-11 319
试除法求约数、约数个数、约数之和、最大公约数
【Hot100】LeetCode—64. 最小路径和
weixin_44382896的博客
09-12 475
64. 最小路径和。
算法练习题24——查找杨辉三角中的组合数
hello77的blogggg 祝你得偿所愿
09-12 585
逐项递推法适合处理较小的数据量，计算较为直观，但当杨辉三角行数较大时，效率较低。 二分查找法利用组合数的单调性，显著提高查找效率，适合处理较大的数据范围。这两种解法在不同场景下都可以使用，二分查找法尤其适合大规模数据下的查找问题。
18068 选择排序
huang1xiao1sheng的博客
09-11 434
输入10个整数，编写一个实现对数组进行选择排序的函数 #include int sort(int a[], int n) { int i,j,k,tmp; for(i=0;i
二分系列(二分查找)9/12
2301_78191305的博客
09-12 965
排序数组->使用二分。第一个位置:>=；第二个位置:=(target+1)-1；所以直接写一个>=的函数。
二分系列(二分答案最大值)9/15.16
最新发布
2301_78191305的博客
09-16 592
给你一批机器，及其它制作一块合金所需要的不同种类金属的个数。第一台机器制作一块合金，需要一块A金属、一块B金属、一块C金属。我们对每一类机器所需要的各种种类的金属进行判断，如果仓库里面有，就不需要花钱；如果mid-index<1的，要计算有多少个1。前n项和:(mid-1+1)*(mid-1)/2+leftCount-(mid-1);根据贪心:以index为中心，向两边依次-1，直到减到1为止。如果mid-rightCount<1,先计算多少个1，xxx。
选择排序
shylyly_的博客
09-13 1060
每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完
高效排序算法C/C++实现：鸽巢排序与计数排序
本文主要介绍了三种排序算法的C语言实现：鸽巢排序（Pigeonhole Sort）、计数排序（Counting Sort）以及快速排序的一个基础版本。这些算法的复杂度均小于等于O(n^2)，其中快速排序的平均时间复杂度为O(n log n)。...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值