C++冒泡、快速、基数排序

#include <iostream>
#include <vector>
using namespace std;
void Print(vector<int> &v)
{
    for(auto it:v)
    {
        cout<<it<<" ";
    }
    cout<<endl;
}
//冒泡排序，时间复杂度为n^2
//两两比较，大的放到最后
//[in] v:待排序vector向量,n:参与排序数组元素个数
//[out] 直接对传入vector向量v进行修改，无返回值
void bubble(vector<int> &v,size_t n)
{
    for(size_t i=0;i<n-1;++i)
    {
        for(size_t j=0;j<n-i-1;++j)//内部循环一轮之后最后一个位置的数已经是最大，所以不需要再比较
        //for(size_t j=1;j<n-i;++j)

        {
            if(v[j]>v[j+1])//把最大的元素放到最后
　　　　　　　//if(v[j-1]>v[j])
            {
                int temp=v[j];//交换
                v[j]=v[j+1];
                v[j+1]=temp;
            }
        }
    }
}

void choice(vector<int> &v,size_t n)
{
    for(size_t i=0;i<n-1;++i)
    {
        Print(v);
        for(size_t j=i+1;j<n;++j)
        {
            if(v[i]>v[j])
            {
                int temp=v[i];
                v[i]=v[j];
                v[j]=temp;
            }
        }
    }
}
//快速排序，时间复杂度为O(nlogn)
//选择第一个元素作为基准，用其它变量存储
//从后往前，找到第一个比它小的元素，放在它的位置，
//从前往后，找到第一个比它大的元素，放在它的位置
//[in] v:待排序vector向量,begin:待排序的元素在v中的起始位置，end:待排序的元素在v中结束位置
//[out] 直接对传入vector向量v进行修改，无返回值
void quicksort(vector<int> &v,int begin,int end)
{
    if(begin>end) return;//结束
    int low=begin,high=end;
    int key=v[begin];//基准元素
    while(low<high)//low==high时结束
    {
        while(low<high && v[high] >= key)//从后往前，找到第一个比基准小的数。>=表示跳过相等的数，只找小于key的数
        {
            high--;
        }
        if(low<high) v[low++]=v[high];//将第一个比基准小的数放到前面，if(low<high) 在只有两个数的情况下，避免交换，如6，8，已经有序，如果没有if会被交换成8，6
        while(low<high && v[low]<=key)//从前往后，找到第一个比基准大的数
        {
            low++;
        }
        if(low<high) v[high--]=v[low];//将第一个比基准大的数放到后面

    }
    v[low]=key;//基准元素放到最终位置上
    quicksort(v,begin,low-1);//对基准元素前半部分排序
    quicksort(v,low+1,end);//对基准元素后半部分排序
}

//找到待排列元素中最大元素的位数
//[in] data:待查找的数组，n:数组长度
//[out] d:数组中最大元素的位数
int maxbit(int data[],int n)
{
    int maxData=data[0];
    for(int i=1;i<n;++i)
    {
        if(maxData<data[i])//找到数组中最大的元素
            maxData=data[i];
    }
    int d=1;
    int p=10;
    while(maxData >= p)//计算最大元素的位数
    {
        maxData /=10;
        ++d;
    }
    return d;
}
//基数排序，时间复杂度O(n)
//从最低位开始，对待排序数组进行一次排序，数组中最大元素有几位就进行几次排序
//[in] data:待排序数组data,n:数组中元素个数
//[out] 直接对传入vector向量v进行修改，无返回值
void radixsort(int data[],int n)
{
    int d=maxbit(data,n);//待排列元素中最大元素的位数
    int *tmp = new int[n];//存储临时结果
    int *count = new int [10];//桶数组

    int radix=1;//第一次排序的位数
    for(int i=1; i <= d;++i)//对元素每一位分别进行排序，先从个位开始
    {
        for(int j=0;j < 10;++j)//每次分配前清空桶中原有信息
        {
            count[j]=0;
        }
        for(int j=0;j < n;++j)
        {
            int k=(data[j]/radix)%10;
            ++count[k];//对应的桶加1
        }
        for(int j=1;j<10;++j)//分配tmp中的位置，10表示桶的个数
        {
            count[j]=count[j-1]+count[j];//难点
        }
        for(int j=n-1;j>=0;j--)//将所有桶中的记录依次放到tmp中
        {
            int k=(data[j]/radix)%10;
            tmp[count[k]-1]=data[j];//难点
            count[k]--;
        }
        for(int j=0;j<n;++j)//保存对某一位排序完成后的结果
        {
            data[j]=tmp[j];
        }
        radix=radix*10;//下一次的排序的位数

    }
    delete[] tmp;
    delete[] count;
}


int main() {
    vector<int> v{8,9,1,4,2,3,6,1,5};
    //int shuzu[6]={892,846,821,199,810,700};
    int shuzu[14]={3,44,38,5,47,15,36,26,27,2,46,4,19,50};
    size_t n=v.size();
//    quicksort(v,0,8);
    radixsort(shuzu,14);

    cout<<"fff"<<endl;
    for(auto it:shuzu)
    {
        cout<<it<<" ";
    }

    return 0;
}