摘要:本文主要采用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]--;
}
}
}