大二用C++写的各种排序算法

最新推荐文章于 2025-03-06 20:57:58 发布

原创最新推荐文章于 2025-03-06 20:57:58 发布 · 435 阅读

0 ·

CC 4.0 BY-SA版权

C/C++ 专栏收录该内容

5 篇文章

订阅专栏

本文总结了多种经典的排序算法，包括冒泡排序、快速排序、基数排序等，详细介绍了每种算法的实现原理及代码实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

最开始这些代码都是扔在QQ空间里的，现在参加工作了，才意识到应该有一个属于自己的正式博客。翻出大二的代码，发现里边对变量的命名都是胡写的，记得当时的上机题还经常写拼音，让助教各种无语，哈哈……

冒泡排序

/**********************冒泡排序************************/
template 
void BubbleSort(T Data[],int n) {
    int i,j;
    for(i=0;i




冒泡排序改进算法


#include 
using namespace std;
/****************冒泡排序的改进算法*******************/
template 
void SuperBubbleSort(T Data[],int n)
{
    int flag=0; //标记每一趟的冒泡排序过程中是否发生了交换
    int i,j;
    for(i=0;i



基数排序

基数排序.h
const int RADIX=10; //定义基数，用于区分不用进制
template 
struct LinkNode {//定义链式结构的结点
    T data;
    LinkNode *next;
};
template 
struct TubNode {//定义队列数组结点
    LinkNode *rear;
    LinkNode *front;
};
/*
            分配操作
输入: data[] 数组,n 元素个数,ith 第i次分配操作
输出：执行分配操作之后的一个队列数组
*/
template 
TubNode *Distribute(T data[],int n,int ith {
    //申请内存
    TubNode *tube=new TubNode[RADIX];
    //执行初始化
    memset(tube,0,sizeof(TubNode) *RADIX);

    LinkNode *t;
    for(int i=0;i; //申请新的链接表结点
        t->data=data[i];
        t->next=NULL;
        if(tube[v].front) { //如果对应的队列不为空，则放到末尾
            tube[v].rear->next=t;
            tube[v].rear=t;
        }
        else {//否则，初始化队列头和尾
            tube[v].front=tube[v].rear=t;
        }
    }
    return tube;
}
/*
收集操作，将tube中数据收集到data 数组中
输入：data 数据数组 ；tube 执行完分配操作之后的队列数组
输出：无
*/
template 
void Collect(T data[],TubNode *tube) {
    LinkNode *t,*p;  //临时变量
    int index=0; //数据下标
    for(int i=0;idata; //复制对应数据
            t=t->next;
            delete p; //释放内存
            p=t;
        }
    }
    delete []tube; //释放内存
}
template 
void RadixSort(T data[],int n,int keys) {//基数排序
    TubNode *tube;
    for(int i=0;i(data,n,i+1);
        Collect(data,tube);
    }
}



堆排序

 /*********最大堆**********/
template 
class MaxHeap {
    public :
        MaxHeap() {
        cout<<"堆排序输出:";
    }
    void BuildHeap(T data[],int n);
    void SiftDown(T data[],int i,int n);
    void HeapSort(T data[],int n);
};
template 
void MaxHeap::SiftDown(T data[],int i,int n) {
    //用来保持以结点i为根的最大堆的性质，n是所有元素的个数
    int l=2*i+1, r=2*i+2,min=i;//找到i结点的两个孩子的下标
    if(l
void MaxHeap::BuildHeap(T data[],int n) {
    int p=n/2-1;  //求出非叶子结点的最大下标
    for(int i=p;i>=0;i--) {
        SiftDown(data,i,n);//调用SiftDown函数，保持最大堆的性质
    }
}
template
void MaxHeap::HeapSort(T data[],int n) {
    BuildHeap(data,n); //首现建立一个最大堆
    for(int i=n-1;i>0;i--) { //进行循环
        T t=data[0]; //每次取出最大元素后不断调整最大堆
        data[0]=data[i];
        data[i]=t;
        SiftDown(data,0,i);
    }
}




希尔排序

#include 
using namespace std;
template 
void shellSort(T Data[],int n) {
    int d=n/2;  //增量初始化为数组大小的一半
    while(d>=1) {//循环遍历增量的所有可能
        for(int k=0;k=k && Data[j]>temp) {
                    Data[j+d]=Data[j];
                    j-=d;
                }
                Data[j+d]=temp;
            }
        }
        d=d/2;  //增量变为上次的一半
    }
} 



归并排序

/*************合并一个序列中的两个有序子序列************/
template 
//函数Merge，参数data是待归并数组，其中对data[start,mid]和data[mid+1,end]之间的数据进行归并
void Merge(T data[],int start,int mid,int end) {
    int len1=mid-start+1, len2=end-mid; //分别表示两个归并区间的长度

    int i,j,k;
    T *left=new T[len1]; //临时数组用来存放data[start,end]数据
    T *right=new T[len2]; //临时数组用来存放data[mid+!,end]数据
    for(i=0;i
void MergeSort(T data[],int start,int end) {
    //对data[start]=data[end]之间的序列进行归并排序
    if(start



快速排序
快速排序.h
/***********************快速排序分割策略一****************************/
template 
int first_Partition(T data[],int left,int right) {
    //实现对data[left]到data[right]的分割操作，并返回划分后轴元素对应的位置
    T pivot=data[left]; //选择最左边的为轴元素
    while(leftpivot) //控制right指针的移动
            right--;
        data[left]=data[right]; //将right指向的数据移动到left位置
        while(left
int second_Partition(T data[],int start,int end) {
    //实现对data[start]到data[end]的分割操作，并返回划分后轴元素对应的位置
    T pivot=data[start];
    int left=start,right=end; //初始化left,right
    while(left<=right) {//外层循环控制遍历数组
        while(left<=right && data[left]<=pivot) //控制left指针的移动
            left++;
        while(left<=right &7 data[right]>pivot)//控制right指针的移动
            right--;
        if(left
void QuickSort1(T data[],int left,int right) {
    //用快速分割策略一实现快速排序算法
    if(left
void QuickSort2(T data[],int left,int right)
{
//用快速分割策略一实现快速排序算法
if(left




折半插入排序
#include 
using namespace std;
template 
void BinaryInsertionSort(T Data[],int n) {//参数，待排序数据和待排序元素个数
    int left,mid,right,p;  //声明一些变量
    for(p=1;ptemp)  //中心点元素值比待插入数据大
                right=mid-1; //更新右区间值
            else
                left=mid+1; //更新左区间值
        }
        for(int i=p-1;i>=left;i--)  //执行移动操作
            Data[i+1]=Data[i];
        Data[left]=temp; //将待插入元素插入到有序表中
    }
}




直接插入排序

#include 
using namespace std;
template 
void InsertionSort(T data[],int n) {
    //利用直接插入排序对于n个数据元素进行不减序排序
    int p,i;
    for(p=1;p=0 && data[i]>temp) {//把比temp大的元素都向后移动
            data[i+1]=data[i];
            i--;
        }
        data[i+1]=temp;
    }
} 



简单选择排序

/*****************简单选择排序*******************/
/*简单选择排序算法就是利用线性查找的方法从一个序列中找到最小的元素，即第i趟的排序操作为：
通过n-i次关键字的比较，从n-i+1个元素中选出关键字最小的元素，并和第i-1（1<=i<=n-1）个元素
交换。简单选择排序算法也称为直接选择排序算法*/
template 
void SelectionSort(T data[],int n) {
    for(int i=1;i



主方法

#include 
#include "直接插入排序.h"
#include "折半插入排序.h"
#include "希尔排序.h"
#include "冒泡排序.h"
#include "冒泡排序改进算法.h"
#include "快速排序.h"
#include "简单选择排序.h"
#include "堆排序.h"
#include "归并排序.h"
#include "基数排序.h"
using namespace std;
int main() {
    /**************************直接插入排序部分********************************/
    int A[15]={11,2,6,8,1,4,9,7,3,5};
    InsertionSort(A,10);
    int i;
    cout<<"直接插入排序输出:";
    for(i=0;i<10;i++)
        cout<