以下均为个人理解，如有错误请指出，谢谢。
一、冒泡排序
所谓冒泡，就是将较大值往最下面扔，相对应的较小值就会逐步上移。这就会涉及到整个序列中相邻两个元素的比较。
第一轮：共有n 个数值，需要比较(n-1)次，找到了最大值。
第二轮：剩下前(n-1)个数值，需要比较(n-2)次，找到次最大值。
…
第(n-1)轮：剩下前2个数值，需要比较1次，找到最小值。
稳定性： 在以下两段程序中，可以看到v[j] == v[j+1]时，我们并没有交换数据，因此该算法时稳定的。
最差时间复杂度： 1+2+3+…+(n-1)=O(n^2)
vector<int> v{8,2,0,6,9,7,4,7,9};
int n = v.size();
for(int i=0; i<n-1; ++i)
for(int j=0; j<n-1-i; ++j)
if(v[j] > v[j+1])
std::swap(v[j],v[j+1]);
如果我们直接输入一个已经处于排序的序列，会发现只有循环中仅仅执行了比较，而没有交换的动作，因此可以为“交换动作”设置一个标记，如果标记没有触发，说明本身就已经处于有序状态了。直接跳出即可。
最优时间复杂度： O(n)
int swaped = 0;
for(int i=0; i<len-1; ++i)
{
for(int j=0; j<len-1-i; ++j)
{
if(v[j] > v[j+1])
{
std::swap(v[j],v[j+1]);
swaped = 1;
}
}
if(swaped == 0)
break;
}
二、选择排序
选择就是每次都从“待排序”序列中选出最小的一个和第一个位置交换，再选出次小的和第二个位置交换，直到从第N个和第N-1个元素中选出最小的放在第N-1个位置。
第一轮：共有n 个数值，需要比较(n-1)次，找到了最小值。
第二轮：剩下后(n-1)个数值，需要比较(n-2)次，找到次最小值。
…
第(n-1)轮：剩下后2个数值，需要比较1次，找到最大值。
稳定性： 假如输入序列{3，2，3，1，4}，第一轮交换中，3就跑到了3的后面。因此时不稳定的。
时间复杂度： (n-1)+(n-2)+(n-3)+…+2+1=O(n^2)
vector<int> v{8,2,0,6,9,7,4,7,9};
int n = v.size();
int minPos;
for(int i=0; i<n-1; ++i)
{
minPos = i;
for(int j=i+1; j<n; ++j)
if(v[minPos] > v[j])
minPos = j;
std::swap(v[i],v[minPos]);
}
三、快速排序(1)(基于交换)
(1)使用三数中值分割法来找到轴元素；
(2)对三个元素进行排序，并将轴元素与倒数第二位元素交换位置；
(3)从前往后找大于轴元素的值，从后往前找小于轴元素的值，交换位置；
(4)两个游标交错，原数组已经分为了三部分，再分别对左右两部分进行快速排序。
稳定性： 不稳定的。比如：(4,3,3,3,5)
时间复杂度：
#include<iostream>
#include<vector>
using namespace std;
/* 快速排序核心思想：选定枢元素，将数组分为三部分
* 分别对左右两部分进一步快速排序
* 当变为小数组时采用插入排序
*/
//此为快速排序的驱动函数
template<typename Comparable>
class Solution
{
public:
void quickSort(vector<Comparable> & v)
{
if(v.empty())
cerr<<"empty vector";
quickSort(v,0,v.size()-1);
}
void quickSort(vector<Comparable> & v,int left,int right)
{
if(right-left > 10)
{
const Comparable pivot = getPivot(v,left,right);
int i = left;
int j = right-1;
//这里将元数组分为三部分，左侧为小于等于，右侧为大于等于
for( ; ; )
{
//下面需要用到游标i,j锁指向的位置，因此采用前置版本的自增自减
//这里也不需要判断等于的情况，这样会增加交换的次数，因为相等的元素会在剩下的子数组中确定位置
while(v[++i] < pivot) ;
while(v[--j] > pivot) ;
if(i < j)
std::swap(v[i],v[j]);
else
break;
}
//将枢元素放回到它应该在的正确位置
std::swap(v[i],v[right-1]);
//此时，再分别对两侧的子数组进行排序
quickSort(v,left,i-1);
quickSort(v,i+1,right);
}
else
insertSort(v,left,right);
}
//小数组采用插入排序
private:
int getPivot(vector<Comparable> & v,int left,int right)
{
//先将三个数进行排序
int mid = (left+right)/2;
if(v[left] > v[mid])
std::swap(v[left],v[mid]);
if(v[left] > v[right])
std::swap(v[left],v[right]);
if(v[mid] > v[right])
std::swap(v[mid],v[right]);
//将得到的枢元素放在right-1的位置
std::swap(v[mid],v[right-1]);
//cout<<"pivot:"<<v[right-1]<<endl;
return v[right-1];
}
void insertSort(vector<Comparable> & v,int left,int right)
{
if(right == left)
return ;
int i,j;
for(i=left+1;i<=right;++i)
{
//将待排序元素保存
Comparable temp = std::move(v[i]);
int j;
for(j=i; j>left && v[j-1]>temp; --j)
v[j] = std::move(v[j-1]);
v[j] = std::move(temp);
}
}
};
int main(int argc,char** argv)
{
Solution<int> S;
//vector<int> v{};
vector<int> v{8,2,0,6,9,7,4,7,9,1,7,6,3,7,8,1,3,8,4,1,2,9,0,1,8,5,9,2,7,1,3,1,1,9,3,8,5,4,0};
for(auto &x:v)
cout<<x<<" ";
cout<<endl;
S.quickSort(v);
for(auto &x:v)
cout<<x<<" ";
cout<<endl;
return 0;
}
三、快速排序(2)(挖坑填补法)
基于交换法的快速排序使用三数中值分割法来找到轴元素。这里直接把第一个元素当作标准值，先找到该标准值应该在序列中哪个位置，在找标准值位置的同时，将小的数和大的数分别放到标准值的两侧。
以下为找标准值的思路。
第一轮：将第一个元素从序列中挖出并保存，留下一个“坑”；
第二轮：从后往前找小于标准值的数填入坑中，坑的位置变换；
第三轮：再从前往后找大于标准值的数填入坑中，坑的位置变换；
…
循环到最后，坑左边的数都小于标准值，坑右侧的数都大于标准值，再将标准值放入坑中。
至此，坑填补完毕。在分别对标准值两侧的子序列分别进行挖坑填补，直至子序列元素个数为一，结束排序。
稳定性： 不稳定的。
时间复杂度：
#include<iostream>
#include<vector>
using namespace std;
class solution
{
public:
void quickSort(vector<int> & v,int left,int right)
{
if(v.empty() || left >= right)
return;
//找标准值位置
int standardNum;
standardNum = findStandard(v,left,right);
//根据标准值位置 将数组分成两部分 各部分分别执行以上操作
quickSort(v,left,standardNum-1);
quickSort(v,standardNum+1,right);
}
private:
//找到标准值的位置
int findStandard(vector<int> & v,int left,int right)
{
int temp;
temp = v[left];//将第一位设定为标准值
while(left < right)
{
//从后向前找比标准值小的
while(right > left)
{
if(v[right] < temp)
{
v[left] = v[right];//填前面的坑，后面多了一个新坑
left++;
break;
}
right--;
}
//从前向后找比标准值大的
while(left < right)
{
if(v[left] > temp)
{
v[right] = v[left];//填后面的坑，前面多了一个新坑
right--;
break;
}
left++;
}
}
v[left] = temp;//left=right 将标准值放入坑中
return left;
}
};
int main()
{
vector<int> v{46,79,56,38,40,84};
solution s;
s.quickSort(v,0,v.size()-1);
for(auto & i:v)
cout<<i<<" ";
cout<<endl;
return 0;
}
四、堆排序 用于TopK问题：剑指offer30
(1) 首先构建一个大(小)根堆；
(2) 从最后一个父结点开始下滤；直到对根节点下滤结束。
(3) 此时大根堆已经构建完毕，最大值处在根节点上，只需交换根节点和最后一个叶节点位置，最大值就落在了最后一个位置；
(4) 每进行依次交换，都对新的根节点进行下滤操作。
稳定性： 不稳定的。比如：(4,3,3,3,5)
时间复杂度： nlogn
#include<iostream>
#include<vector>
using namespace std;
template<typename Comparable>
class Solution
{
public:
void HeapSort(vector<Comparable> &arr)
{
if(arr.empty())
return ;
//构建大根堆，最后一个父结点开始
for(int i=arr.size()/2-1; i>=0; --i)
{
percDown(arr,i,arr.size());
}
//连续删除k次根节点得到的就是前k个数
//删除并不用真正的删除操作，只需要将最大的根节点和最后一个元素交换位置，
//再令数组大小减一，并对新的根节点进行下滤
for(int j=arr.size()-1; j>0 ; --j)
{
std::swap(arr[0],arr[j]);
percDown(arr,0,j);
}
}
private:
void percDown(vector<Comparable> &arr,int i,int n)
{
Comparable temp;
int child;
for(temp=std::move(arr[i]); getchildChild(i)<n; i=child)
{
child = getchildChild(i);
//判断是否有两个儿子，有就选出最大的那个根自己比较
if (child!=n-1 && arr[child]<arr[child+1])
child += 1;
if (temp < arr[child])
arr[i] = arr[child];//因为儿子大，所以将儿子的位置提升，此时儿子原来的位置就空出来了
else
break;
//arr[i]下滤可能会导致其大儿子的子树失去大根的特性，因此要令i=child，对其儿子再进行下滤
}
arr[i] = temp;//将temp填在空出来的位置
}
int getchildChild(int i)
{
return 2*i+1;
}
};
int main(int argc,char** argv)
{
vector<int> v{8,2,0,6,9,7,4,7,9};
Solution<int> S;
for(auto &i:v)
cout<<i<<" ";
cout<<endl;
S.HeapSort(v);
for(auto &i:v)
cout<<i<<" ";
cout<<endl;
return 0;
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
