直接/折半插入排序 希尔排序 冒泡排序 快速排序 简单选择排序 堆排序 归并排序 C++实现

最新推荐文章于 2022-07-13 21:54:55 发布
最新推荐文章于 2022-07-13 21:54:55 发布
阅读量491 收藏 9
点赞数 1
分类专栏： 计算机基础知识 文章标签： 排序算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46250447/article/details/119655024
版权

直接插入排序

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

//直接插入排序（非递减）
void InsertSort(int A[],int n){
    int i,j,temp;
    for(i=1;i<n;i++){//从数组第二个元素开始比较
        if(A[i]<A[i-1]){
            temp=A[i];
            for(j=i-1;j>=0&&A[j]>temp;j--){//移动元素
                A[j+1]=A[j];
            }
            A[j+1]=temp;
        }
    }
}

int main(){
    int A[10]={54,78,35,12,99,3,65,44,32,27};
    int n=sizeof(A)/sizeof(A[0]);//数组长度
    for(int i=0;i<n;i++){
        cout<<"\t"<<A[i];
    }
    cout<<endl;
    InsertSort(A,n);
    for(int j=0;j<n;j++){
        cout<<"\t"<<A[j];
    }
    cout<<endl;
    return 0;
}

在这里插入图片描述

折半插入排序

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

//折半插入排序（非递减）
void InsertSort(int A[],int n){
    int i,j,temp;
    int low,high,mid;
    for(i=1;i<n;i++){//从数组第二个元素开始比较
        temp=A[i];
        low=0;
        high=i-1;
        while(low<=high){//查找插入的位置
            mid=(low+high)/2;
            if(A[mid]>temp){//左半子表
                high=mid-1;
            }
            else{//右半子表
                    /*此处和折半查找有区别，当mid所处的元素小于或等于temp时，保证算法的稳定性
                    比如 50,54,60,60，60，60,87； 60所处位置后面有多个60，保证稳定性*/
                low=mid+1;
            }
        }
        for(j=i-1;j>=0&&j>=high+1;j--){//退出时要插入的位置在high后面，查找要插入的位置，然后移动元素
            A[j+1]=A[j];
            }
        A[high+1]=temp;
    }
}

int main(){
    int A[10]={47,78,50,12,99,3,6,44,32,27};
    int n=sizeof(A)/sizeof(A[0]);//数组长度
    for(int i=0;i<n;i++){
        cout<<"\t"<<A[i];
    }
    cout<<endl;
    InsertSort(A,n);
    for(int j=0;j<n;j++){
        cout<<"\t"<<A[j];
    }
    cout<<endl;
    return 0;
}

在这里插入图片描述

直接插入排序演示

希尔排序

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

//希尔排序
void ShellSort(int A[],int n){
    int d,i,j;
    for(d=n/2;d>=1;d=d/2){//步长的变化
        for(i=1+d;i<=n;++i){//进入当前步长的子表进行直接插入排序，每次处理子表的一个元素(++i)
            if(A[i]<A[i-d]){//子表判断
                //A[0]作为暂存当前比较元素的单元，并不是“哨兵”
                A[0]=A[i];
                for(j=i-d;j>0&&A[0]<A[j];j=j-d){//寻找子表的插入位置，元素后移
                    A[j+d]=A[j];
                }
                A[j+d]=A[0];
            }
        }
    }

}

int main(){
    int A[15]={0,44,25,61,47,17,78,50,12,99,3,6,44,32,27};
    int n=14;//比较的元素个数
    for(int i=1;i<=n;i++){
        cout<<"\t"<<A[i];
    }
    cout<<endl;
    ShellSort(A,n);
    cout<<"希尔排序"<<endl;
    for(int j=1;j<=n;j++){
        cout<<"\t"<<A[j];
    }
    cout<<endl;
    return 0;
}

在这里插入图片描述

希尔排序演示

冒泡排序

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

//交换两个元素位置
void swap(int &a,int &b){
    int temp;
    temp=a;
    a=b;
    b=temp;
}

//冒泡排序
void BubbleSort(int A[],int n){
    bool flag=false;
    for(int i=n-2;i>=0;i--){//n个元素需要n-1此比较
        flag=false;//标志位：在一次冒泡过程中是否进行了元素交换
        for(int j=0;j<=i;j++){//每次比较冒出最大的元素，排在后面，
                //只需要比较到有序部分的前面一个元素
            if(A[j]>A[j+1]){
                swap(A[j],A[j+1]);
                flag=true;
            }
        }
        if(flag==false){//冒泡过程没有进行交换元素，说明已经有序
            return;
        }
    }
}

int main(){
    int A[10]={45,25,86,78,91,3,65,14,36,55};
    int n=sizeof(A)/sizeof(A[0]);//数组长度
    for(int i=0;i<n;i++){
        cout<<"\t"<<A[i];
    }
    cout<<endl;
    BubbleSort(A,n);
    cout<<"冒泡排序"<<endl;
    for(int j=0;j<n;j++){
        cout<<"\t"<<A[j];
    }
    cout<<endl;
    return 0;
}

在这里插入图片描述

冒泡排序演示

快速排序

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

//用第一个元素将数组划分为两个部分
int Partition(int A[],int low,int high){
    int pivot=A[low];//取表的第一个元素作为枢轴
    while(low<high){
        while(low<high&&A[high]>pivot){//从后往前找到high所指元素小于枢轴的元素
            high--;
        }
        A[low]=A[high];//将找到的元素赋值给low所指位置
        while(low<high&&A[low]<pivot){//从前往后找到low所指元素大于枢轴的元素
            low++;
        }
        A[high]=A[low];//将找到的元素赋值给high所指位置
    }
    A[low]=pivot;//退出循环时low等于high，将枢轴元素赋值到low所指位置
                    //此时枢轴左边的元素小于枢轴，右边的大于枢轴
    return low;
}

//快速排序
void QuickSort(int A[],int low,int high){
    if(low<high){
        int pivotposition=Partition(A,low,high);//划分数组
        QuickSort(A,low,pivotposition-1);//快速排序左表
        QuickSort(A,pivotposition+1,high);//右表快排
    }
}

int main(){
    int A[12]={15,27,86,71,91,3,65,14,49,98,36,55};
    int n=sizeof(A)/sizeof(A[0]);//数组长度
    for(int i=0;i<n;i++){
        cout<<"\t"<<A[i];
    }
    cout<<endl;
    QuickSort(A,0,n-1);
    cout<<"快速排序"<<endl;
    for(int j=0;j<n;j++){
        cout<<"\t"<<A[j];
    }
    cout<<endl;
    return 0;
}

在这里插入图片描述

快速排序演示

简单选择排序

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

//交换两个元素位置
void swap(int &a,int &b){
    int temp;
    temp=a;
    a=b;
    b=temp;
}

//简单选择排序
void SelectionSort(int A[],int n){
    for(int i=0;i<n-1;i++){//总共需要进行n-1次寻找最小值
        int min=i;
        for(int j=i+1;j<n;j++){//寻找最小值
            if(A[j]<A[min]){
                min=j;
            }
        }
        if(min!=i){//最小值放在前面，递增有序
            swap(A[min],A[i]);
        }
    }
}

int main(){
    int A[12]={14,24,86,71,88,5,65,14,49,97,36,55};
    int n=sizeof(A)/sizeof(A[0]);//数组长度
    for(int i=0;i<n;i++){
        cout<<"\t"<<A[i];
    }
    cout<<endl;
    SelectionSort(A,n);
    cout<<"简单选择排序"<<endl;
    for(int j=0;j<n;j++){
        cout<<"\t"<<A[j];
    }
    cout<<endl;
    return 0;
}

在这里插入图片描述

简单选择排序演示

堆排序

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

//交换
void swap(int &a,int &b){
    int temp;
    temp=a;
    a=b;
    b=temp;
}

//将以k为根的子树调整为大根堆
void HeadAdjust(int A[],int k,int len){//len是当前需要调整的数组长度
    A[0]=A[k];//k根先保存
    for(int i=2*k;i<=len;i=2*i){//寻找下标k的左右孩子中的最大值，i>len说明k没有左右孩子
        if(i<len&&A[i]<A[i+1]){
            i++;//i值所指的是k左右孩子的最大值,优先和左孩,i<len保证i有右兄弟i+1
        }
        if(A[0]>A[i]){
            break;
        }
        else{
            A[k]=A[i];//将左右孩子最大值赋给根结点
            k=i;//修改k值为i（之前最大值所在结点），以便继续调整“小元素下坠”
        }
    }
    A[k]=A[0];//此时k结点就是可以存放筛选结点的结点
}

//建立大根堆
void BuildMaxHeap(int A[],int len){
    for(int i=len/2;i>0;i--){//调整len/2前的结点，因为只有这些结点有左右孩子；
        HeadAdjust(A,i,len);
    }
}

//堆排序，大根堆最终形成增序序列
void HeapSort(int A[],int len){
    BuildMaxHeap(A,len);//初始建立大根堆
    for(int i=len;i>1;i--){//n-1趟交换和建堆过程
        swap(A[i],A[1]);//交换待筛选和逻辑上未排序的最后一个元素，此时最后一个元素是最大值
        HeadAdjust(A,1,i-1);//交换之后，剩下i-1个未排序的序列元素
    }
}


int main(){
    int A[13]={0,15,27,86,71,91,3,65,14,49,98,36,55};//首结点不存储排序元素
    int n=sizeof(A)/sizeof(A[0]);//数组长度
    for(int i=1;i<n;i++){
        cout<<"\t"<<A[i];
    }
    cout<<endl;
    HeapSort(A,n-1);
    cout<<"根排序"<<endl;
    for(int j=1;j<n;j++){
        cout<<"\t"<<A[j];
    }
    cout<<endl;
    return 0;
}

在这里插入图片描述

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

void swap(int &a,int &b){
    int temp;
    temp=a;
    a=b;
    b=temp;
}

//将以k为根的结点调整为小根堆
void AdjustSmall(int A[],int k,int len){
    A[0]=A[k];
    for(int i=2*k;i<=len;i=2*i){
        if(i<len&&A[i]>A[i+1]){
            i++;
        }
        if(A[k]<A[i]){
            break;
        }
        else{
            A[k]=A[i];
            k=i;
        }
    }
    A[k]=A[0];
}

//建立小根堆
void BuildMinHeap(int A[],int len){
    for(int i=len/2;i>0;i--){
        AdjustSmall(A,i,len);
    }
}

//堆排序，小根堆最终形成降序序列
void HeapSortDec(int A[],int len){
    BuildMinHeap(A,len);
    for(int i=len;i>1;i--){
        swap(A[1],A[i]);
        AdjustSmall(A,1,i-1);
    }
}

int main(){
    int A[13]={0,15,27,86,71,91,3,65,14,49,98,36,55};//首结点不存储排序元素
    int n=sizeof(A)/sizeof(A[0]);//数组长度
    for(int i=1;i<n;i++){
        cout<<"\t"<<A[i];
    }
    cout<<endl;
    HeapSortDec(A,n-1);
    cout<<"小根排序"<<endl;
    for(int j=1;j<n;j++){
        cout<<"\t"<<A[j];
    }
    cout<<endl;
    return 0;
}

在这里插入图片描述

堆排序演示

归并排序

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

//归并
//A[low]...A[mid]和A[mid+1]...A[high]各自有序
void Merge(int A[],int B[],int low,int mid,int high){
    int i,j,k;
    for(k=low;k<=high;k++){
        B[k]=A[k];//复制A的所有元素到辅助数组B
    }
    for(i=low,j=mid+1,k=i;i<=mid&&j<=high;k++){//i指向第一个有序数组，j指向第二个有序数组
        if(B[i]<=B[j]){//从各自第一个元素开始比较，小的元素放入A
            A[k]=B[i++];
        }
        else{
            A[k]=B[j++];
        }
    }
    while(i<=mid){//其中一个数组比较完了，将剩下的数组元素全部复制到A
        A[k++]=B[i++];
    }
    while(j<=high){
        A[k++]=B[j++];
    }
}

//归并排序(递归)
void MergeSort(int A[],int B[],int low,int high){
    if(low<high){
        int mid=(low+high)/2;
        MergeSort(A,B,low,mid);//左序列
        MergeSort(A,B,mid+1,high);
        Merge(A,B,low,mid,high);//归并（直到low=high,划分之后成两个元素，进行归并，逐层退出归并）
    }
}

int main(){
    int A[13]={9,1,24,81,71,91,5,63,14,49,88,63,59};//首结点不存储排序元素
    int n=sizeof(A)/sizeof(A[0]);//数组长度
    //辅助数组
    int *B=(int *)malloc(n*sizeof(int));
    for(int i=0;i<n;i++){
        cout<<"\t"<<A[i];
    }
    cout<<endl;
    MergeSort(A,B,0,n-1);
    cout<<"归并排序"<<endl;
    for(int j=0;j<n;j++){
        cout<<"\t"<<A[j];
    }
    cout<<endl;
    return 0;
}

在这里插入图片描述

归并排序演示

高同学_Luka
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
排序算法（直接插入排序、折半排序、直接选择排序、快速排序与归并排序）
04-04
提供五种排序算法的C++实现方法，输入（待排序元素个数、排序码上界（采用随机生成数组方式）），可选择输出（原始数组、排序后数组、原始数组有序度和无序度、排序过程中数据比较次数与数据移动次数、数组中出现频次最多的元素与排序后数组中前三大元素）。提供源代码（采用面向过程的方式提供源代码与采用面向对象的方式提供一种封装形式）
C++实现常用排序算法（快速排序、冒泡排序、希尔排序、折半插入排序、直接插入排序）
https://github.com/JelinYao
12-18 2366
#ifndef SORT_ALGORITHM_H_ #define SORT_ALGORITHM_H_ #include #include using std::cout; using std::endl; template //T为排序序列元素类型，len为序列元素数目 class CSort { public: CSort(const T* arr); virtual~ CSort()
数据结构排序算法之直接插入、折半插入、希尔排序、冒泡排序、快速排序、简单选择排序、堆排序、归并排序（二路归并排序）C语言实现
c_cjiajia_的博客
06-13 3253
插入：直接插入、折半插入、希尔排序 交换：冒泡排序、快速排序⭐ 选择：简单选择排序、堆排序⭐ 归并：归并排序（二路归并排序）⭐ 快速排序、堆排序和归并排序为时间复杂度较小的排序方法，为O(nlogn); 英语不太好，有些算法就直接用拼音了... 这些算法的输入输出语句用的是cout.cin。（为C++内容，只需将头文件改为#include<iostream> using namespace std;即可兼容C\C++语句。或可直接将cin.cout语句改为scanf\printf语.
排序算法(直接插入、折半插入、希尔排序、冒泡排序、快速排序、简单选择排序、堆排序、归并排序、基数类排序)
热门推荐
xjtuse123的博客
08-16 1万+
目录 一、概述 二、算法复杂度 三、插入类排序 1.直接插入排序 2.折半插入排序 3.希尔排序 四、交换类排序 1.冒泡排序 2.快速排序 五、选择类排序 1.简单选择排序 2.堆排序 六、归并排序 1.二路归并排序 七、基数排序 1.基数...
对于给定的序列实现直接插入、折半插入、冒泡、希尔、快速、选择、堆排序
Laok0413的博客
12-12 2451
1.本代码一共实现7种常见排序，其中直接插入排序和折半插入排序思想相同，只不过在寻找插入位置的时候，折半插入排序采用了二分法，在这一步上较直接插入排序更快。 2.冒泡排序很简单，但是可以进阶一步，在内层循环 j 中加一个flag标识，判断在这一次循环中有没有发生值交换。如果发生了，那么flag的值变化。如果没发生，就直接break循环，节省时间提高效率。 3.希尔排序属于高级排序方法，采用的是缩小增量的思想。在开始正式的排序之前（这个正式的排序可以理解为直接插入排序），先对序列中的一小部分进行排序，这个
C++实现八个常用的排序算法：插入排序、冒泡排序、选择排序、希尔排序等
09-03
主要介绍了C++如何实现八个常用的排序算法：插入排序、冒泡排序、选择排序、希尔排序 、快速排序、归并排序、堆排序和LST基数排序,需要的朋友可以参考下
基于C++实现的各种内部排序算法汇总
12-31
这里就把各种内部排序算法总结归纳了一下，包括插入排序（直接插入排序，折半插入排序，希尔排序）、交换排序（冒泡排序，快速排序）、选择排序（简单选择排序，堆排序）、2-路归并排序。（另：至于堆排序算法，前面...
10种排序算法代码+综合比较代码（直接插入排序、希尔排序、冒泡排序、快速排序、简单选择排序、堆排序、归并排序、基数排序、折半插入排序、2路插入排序）.zip
05-30
10种排序算法代码+综合比较代码（直接插入排序、希尔排序、冒泡排序、快速排序、简单选择排序、堆排序、归并排序、基数排序、折半插入排序、2路插入排序），其中不仅有各种排序算法的代码，还包含10种代码在关键字...
C++多种排序源代码分享
10-23
使用C++语言，编写了插入排序（直接插入排序、折半插入排序）、希尔排序、交换排序（冒泡排序、快速排序）、选择排序（直接选择排序、堆排序）、归并排序
C++实现各种排序算法类汇总
01-20
C++可实现各种排序算法类，比如直接插入排序、折半插入排序、Shell排序、归并排序、简单选择排序、基数排序、对data数组中的元素进行希尔排序、冒泡排序、递归实现、堆排序、用数组实现的基数排序等。 具体代码如下...
归并排序 分治法——C++代码
05-24
课程的随堂作业，C语言的，用dev就能运行，萌新代码，勿喷，仅仅帮助不想写作业的朋友方便一下，反正老师也不会仔细检查的
直接插入、折半插入、冒泡、快速、简单选择等排序方法
kongge123456的博客
12-04 455
//简单选择排序 #include <stdio.h> #include <string.h> //头文件 将数组进行复制 #include <stdlib.h> void Simplechoices(int a[]) { int i; int j; int t; for(i=1;i<=9;i++) for (j=i+1...
【数据结构】排序（直接插入、折半插入、希尔、冒泡、快速、直接选择、堆、归并、基数排序）
Hello World!
07-13 5188
排序：将一组杂乱无章的数据按一定规律顺次排列起来。即，将无序序列的数据节点包含多个数据域，那么排序往往是针对其中某个域而言。 1.按数据存储介质可分为：内部排序：数据量不大、数据在内存，无需内外存交换数据外部排序：数据量较大、数据在外存（文件排序）。外部排序时，要将数据分批调入内存来排序，中间结果还要及时放入外存，显然外部排序要复杂的多。2.按比较器个数可分为：串行排序：单处理机（同一时刻比较一对元素）并行排序：多处理机（同一时刻比较多对元素）3.按主要操作可分为：比较排序：用比较的方法。 插入排序、交换
冒泡排序、简单选择排序、直接插入排序、折半插入排序、快速排序、归并排序、堆排序
QAQ
04-10 427
/** * @author QLBF * @version 1.0 * @date 2021/4/10 15:30 */ //冒泡排序 public class Maopao { public static int[] paixu(int []array){ for (int i = 0; i < array.length; i++) { for (int j = 0; j < array.length - 1-i; j++) {
直接插入排序、折半插入排序、希尔排序、冒泡排序、选择排序、快排、堆排序、归并排序算法效率比较
人工智能的博客
12-16 1266
这里建议使用三万左右的随机数个数进行比较。 这里比较的算法有直接插入排序，折半插入排序，希尔排序，冒泡排序，选择排序，快排，堆排序，归并排序。 #include&lt;stdio.h&gt; #include&lt;time.h&gt; #include&lt;stdlib.h&gt; #include&lt;math.h&gt; #define MAXSIZE 100001 typedef...
排序算法：直接插入排序，折半插入排序，冒泡排序，快速排序，简单选择排序
xiaoyeren_ITRoad的博客
05-24 2747
一、直接插入排序 基本操作是将一条记录插入到已排好序的有序表中，从而得到一个新的、记录数量增1的有序表。 算法步骤： ①设待排序的记录存放在数组r[1...n]中，r[1]是一个有序序列； ②循环n-1次，每次使用顺序查找法，查找r[i](i=2...n)在已排好序的序列r[1...i-1]中的插入位置，然后将r[i]插入表长为i-1的有序序列r[1...i-1]，直到r[n]插入表长为n-1的有序序列r[1...n-1]，最后得到一个表长为n的有序序列。 void insertsort(nod
十种排序算法总结——直接插入排序+折半插入排序+希尔排序+冒泡排序+快速排序+简单选择排序+堆排序（大根堆+小根堆）+归并排序+基数排序+桶排序+数组散列、集合模拟桶排序
qq_42445959的博客
11-07 475
十种常见算法总结+代码
基本常用的排序算法（冒泡、归并、快速、希尔、直接插入、直接选择、折半查找）
Plutogd的博客
03-05 265
这里写自定义目录标题 冒泡排序实现： /// <summary> /// 冒泡排序(时间复杂度为n²) /// </summary> /// <param name="array">要进行排序的数组</param> void MaoPao(int[] array) { for (int i = 0; i < array.Length - 1; i++)
C++实现内部排序算法(包含直接插入排序，折半插入排序，希尔排序，冒泡排序，快速排序，选择排序，堆排序，归并排序，基数排序）
qq_40945306的博客
09-09 945
1.直接插入排序。其中len的值为待排序数的长度+1，数组第一个空间用作辅助。基本思想：直接插入排序其基本操作就是将一条记录插入到已排好的有序表中，从而得到一个新的、记录数量增1的有序表。这里就是将待排序的数插入已排序好的序列中从而实现排序。 void Sort::InsertSort() { int i, j; for (i = 2; i<this->len; i++) { ...
直接插入排序，折半插入排序，希尔排序，冒泡排序，快速排序，简单选择排序，归并排序
最新发布
01-09
快速排序是一种高效的排序算法，它通过选择一个基准元素，将序列分割成两部分，一部分小于基准元素，一部分大于基准元素，然后对两部分递归地进行快速排序。具体步骤如下： ```python def quick_sort(arr): if len...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值