常用排序算法的实现（C++实现）

最新推荐文章于 2024-07-06 21:36:26 发布

原创最新推荐文章于 2024-07-06 21:36:26 发布 · 231 阅读

0 ·

CC 4.0 BY-SA版权

数据结构与算法专栏收录该内容

21 篇文章

订阅专栏

摘要：本文主要采用C++语言实现冒泡排序、插入排序、选择排序、归并排序、快速排序、堆排序、桶排序。

class My_Sort   // 实现从小到大的排序
{
public:
    void Bubble_Sort(std::vector<int>& nums); // 冒泡排序
    void Insert_Sort(std::vector<int>& nums); // 插入排序
    void Select_Sort(std::vector<int>& nums); // 选择排序
    void Merge_Sort(std::vector<int>& nums); // 归并排序
    void Partition_Sort(std::vector<int>& nums); // 快速排序
    void Heap_Sort(std::vector<int>& nums);  // 堆排序
    void Bucket_Sort(std::vector<int>& nums); // 桶排序


private:
    void Merge_Sort(std::vector<int>& nums,int L,int R);
    void Merges(std::vector<int>& nums,int L,int mid,int R);
    void Partition_Sort(std::vector<int>& nums,int L,int R);
    std::vector<int> Partions(std::vector<int>& nums,int L,int R);
    void HeapInsert(std::vector<int>& nums,int index);
    void Heapfy(std::vector<int>& nums,int index,int Size);

};

 

/*********************************************
*函数功能： 冒泡排序
*参数说明
*    输入：
*    输出：
*时间复杂度：O(N^2) 空间复杂度 O(1)  稳定
*题目来源：
*作者：guoliang zheng
*日期：2018-12-22-20.25
***********************************************/
void My_Sort::Bubble_Sort(std::vector<int>& nums) // 冒泡排序
{
    if(nums.size()<2) return ;
    bool flag=true;
    int len=nums.size();
    for(int i=0;i<len  && flag;i++)
    {
        flag=false;
        for(int j=len-1;j>i;j--)
        {
            if(nums[j]<nums[j-1])
            {
                flag=true;
                swap(nums[j],nums[j-1]);
            }
        }
    }
}
/*********************************************
*函数功能：插入排序
*参数说明
*    输入：
*    输出：
*时间复杂度：O(N^2) 空间复杂度 O(1)  稳定
*题目来源：
*作者：guoliang zheng
*日期：2018-12-22-20.25
***********************************************/
void My_Sort::Insert_Sort(std::vector<int>& nums) // 插入排序
{
    if(nums.size()<2) return ;
    int len=nums.size();
    for(int i=1;i<len;i++)
    {
        int j=i-1;
        while(j>=0 && nums[j]>nums[j+1])
        {
            swap(nums[j],nums[j+1]);
            j--;
        }
    }
}

/*********************************************
*函数功能：选择排序
*参数说明
*    输入：
*    输出：
*时间复杂度：O(N^2) 空间复杂度 O(1)   不稳定
*题目来源：
*作者：guoliang zheng
*日期：2018-12-22-20.25
***********************************************/
void My_Sort::Select_Sort(std::vector<int>& nums) // 选择排序
{
    if(nums.size()<2) return ;
    int len=nums.size();
    for(int i=0;i<len;i++)
    {
        int temp=i;
        for(int j=i+1;j<len;j++)
        {
            if(nums[j]<nums[temp])
            {
                temp=j;
            }
        }
        swap(nums[i],nums[temp]);
    }
}

/*********************************************
*函数功能：归并排序
*参数说明
*    输入：
*    输出：
*时间复杂度：O(NlogN) 空间复杂度 O(N)  稳定
*题目来源：
*作者：guoliang zheng
*日期：2018-12-22-20.25
***********************************************/
void My_Sort::Merge_Sort(std::vector<int>& nums) // 归并排序
{
    if(nums.size()<2) return ;
    Merge_Sort(nums,0,nums.size()-1);
}
void My_Sort::Merge_Sort(std::vector<int>& nums,int L,int R)
{
    if(L>=R) return ;
    int mid=L+((R-L)>>1);
    Merge_Sort(nums,L,mid);
    Merge_Sort(nums,mid+1,R);
    Merges(nums,L,mid,R);
}
void My_Sort::Merges(std::vector<int>& nums,int L,int mid,int R)
{
    std::vector<int> help(R-L+1,0);
    int i=L;
    int j=mid+1;
    int index=0;
    while(i<=mid && j<=R)
    {
        help[index++]=nums[i]<nums[j]?nums[i++]:nums[j++];
    }
    while(i<=mid)
    {
        help[index++]=nums[i++];
    }
    while(j<=R)
    {
        help[index++]=nums[j++];
    }
    for(int i=0;i<R-L+1;i++)
    {
        nums[L+i]=help[i];
    }
}

/*********************************************
*函数功能：快速排序
*参数说明
*    输入：
*    输出：
*时间复杂度：O(NlogN) 空间复杂度 O(logN)  不稳定
*题目来源：
*作者：guoliang zheng
*日期：2018-12-22-20.25
***********************************************/
void My_Sort::Partition_Sort(std::vector<int>& nums)  // 快速排序
{
    if(nums.size()<2) return ;
    Partition_Sort(nums,0,nums.size()-1);
}

void My_Sort::Partition_Sort(std::vector<int>& nums,int L,int R)
{
    if(L<R)
    {
        swap(nums[L+rand()%(R-L+1)],nums[R]);
        vector<int> res=Partions(nums,L,R);
        Partition_Sort(nums,L,res[0]-1);
        Partition_Sort(nums,res[1]+1,R);
    }
}

std::vector<int> My_Sort::Partions(std::vector<int>& nums,int L,int R)
{
    if(nums.size()<2 || L<0 || L>R) return {};
    int Less=L-1;
    int More=R+1;
    int temp=nums[R];
    while(L<More)
    {
        if(nums[L]<temp)
        {
            swap(nums[L++],nums[++Less]);
        }else if(nums[L]==temp)
        {
            L++;
        }else
        {
            swap(nums[L],nums[--More]);
        }
    }
    vector<int> res(2,0);
    res[0]=Less+1;
    res[1]=More-1;
    return res;
}

/*********************************************
*函数功能：堆排序
*参数说明
*    输入：
*    输出：
*时间复杂度：O(NlogN) 空间复杂度 O(1)  稳定
*题目来源：
*作者：guoliang zheng
*日期：2018-12-22-20.25
***********************************************/
void My_Sort::Heap_Sort(std::vector<int>& nums)   // 堆排序
{
    if(nums.size()<2) return ;
    int len=nums.size();
    for(int i=1;i<len;i++)
    {
        HeapInsert(nums,i);
    }
    swap(nums[0],nums[--len]);
    while(len>0)
    {
        Heapfy(nums,0,len);
        swap(nums[0],nums[--len]);
    }
}

void My_Sort::HeapInsert(std::vector<int>& nums,int index)
{
    while(nums[index]>nums[(index-1)/2])
    {
        swap(nums[index],nums[(index-1)/2]);
        index=(index-1)/2;
    }
}
void My_Sort::Heapfy(std::vector<int>& nums,int index,int Size)
{
    int left=2*index+1;
    while(left<Size)
    {
        int lagest=left+1<Size && nums[left+1]>nums[left]?left+1:left;
        lagest=nums[lagest]>nums[index]?lagest:index;
        if(lagest==index)
        {
            return ;
        }
        swap(nums[lagest],nums[index]);
        index=lagest;
        left=2*index+1;
    }
}

/*********************************************
*函数功能：桶排序 (基于非比较排序）
*参数说明
*    输入：
*    输出：
*时间复杂度：O(N) 空间复杂度 O(N)
*题目来源：
*作者：guoliang zheng
*日期：2018-12-22-21.58
***********************************************/
void My_Sort::Bucket_Sort(std::vector<int>& nums)  // 桶排序
{
    if(nums.size()<2) return ;
    int len=nums.size();
    int L=nums[0];
    int R=nums[0];
    for(int i=1;i<len;i++)
    {
        L=min(L,nums[i]);
        R=max(R,nums[i]);
    }
    vector<int> res(R-L+1,0);
    for(int i=0;i<len;i++)
    {
        res[nums[i]-L]++;
    }
    int index=0;
    for(int i=0;i<=R-L;i++)
    {
        while(res[i]>0)
        {
            nums[index++]=i+L;
            res[i]--;
        }
    }
}