利用交换元素的位置进行排序的方法称作交换排序
冒泡排序:
(1)思想(以升序为例):
比较相邻的元素,如果第一个比第二个大,就交换它们,从开始的第一对到结尾最后一对作相同的工作,第一轮下来会将最大的数冒到最右边,然后区间右边减少一个,重复上述步骤,直到区间缩小为1。
(2)图解:
实现4趟冒泡排序就可将下列数组排为有序。
(3)优化思想:
设置标志位,用来判断该次排序有没有进行数据交换,如果没有进行数据交换,表示剩下的元素已经有序了。不需要再进行冒泡了。
(4)复杂度:
冒泡地一趟排序排n-1次,第二趟n-2,第三次n-3….所以最坏情况下(逆序),时间复杂度为O(n*n).
优化后,虽然一定程度减少了数据的比较次数,在最好情况下(有序),时间复杂度是O(n)。
空间复杂度O(1) 冒泡排序是一种稳定的排序算法
代码实现:
//普通版本
void BubbleSort(int* a,int len)
{
assert(a);
assert(len>0);
for(int i = 0;i < len;++i)
{
for(int j = 0;j < len-i-1;++j)
{
if(a[j]>a[j+1])
{
swap(a[j],a[j+1]);
}
}
}
}
优化版本:
void BubbleSort(int* a,int len)
{
assert(a);
assert(len>0);
bool flag = true;//标志用于判断是否有序
for(int i = 0;i < len;++i)//外循环
{
for(int j = 0;j < len-i-1;++j)//内循环,每次循环比较len-i-1次
{
if(a[j]>a[j+1])
{
swap(a[j],a[j+1]);
flag = false;
}
}
if(flag)//如果有序直接跳出
{
break;
}
}
}
int main()
{
int arr[7] = {1,9,7,0,3,6,4};
BubbleSort(arr,7);
Print(arr,7);
}
接下来了解一下分治思想:
分治与递归的关系:
很多用到分治方法的算法都用到了递归,但并不是用到了递归算法就是使用了分治算法,分治法也可以由迭代来实现,递归只是算法的实现手段。
快速排序:
复杂度:
最好情况,每次划分区间都将区间平分成两份,此时的时间复杂度为O(N*logN)
最坏情况,每次划分区间,都导致其中一个区间为空,此时的时间复杂度为O(N*N)
空间复杂度为O(logN)
(1)左右指针法:
//快排左右指针法
void Print(int *a,size_t n)
{
assert(a);
for(size_t i = 0;i<n;i++)
{
cout<<a[i]<<" ";
}
cout<<endl;
}
int PartSort1(int *a,int left,int right)
{
int key = right;
while(left<right)
{
while(left<right && a[left]<=a[key])
++left;
while(left<right && a[right]>=a[key])
--right;
swap(a[left],a[right]);
}
swap(a[left],a[key]);
return left;
}
void QuickSort(int* a,int left,int right)//分治法 子问题求解
{
if(left>=right)
return;
int key = PartSort1(a,left,right);
QuickSort(a,left,key-1);
QuickSort(a,key+1,right);
}
int main()
{
int a[]={1,5,6,2,7,4};
QuickSort(a,0,sizeof(a)/sizeof(a[0])-1);
Print(a,sizeof(a)/sizeof(a[0]));
return 0;
}
(2)挖坑法
代码实现:
//快速排序挖坑法
int Sort2(int *a,int left,int right)
{
int key = a[right];//记录第一个保留的key值
while(left<right)
{
//左指针向右找比key大的值
while(left < right && a[left] <= key)
left++;
a[right]=a[left];//找到后将左指针指向的数填入坑
//右指针向左找比key小的值
while(left < right && a[right] >= key)
right--;
a[left]=a[right];
}
a[left] = key;//将key值放入最后一个坑中
return left;
}
void QuickSort(int arr[],int l,int r)
{
if(l<r)
{
int key = Sort1(arr,left,right);
QuickSort(arr,l,key-1);
QuickSort(arr,key+1,r);
}
}
(3)前后指针法
代码实现:
int PartSort3(int *a,int left,int right)
{
if(left>=right)
return 0;
int key = a[right];
int prev = left-1;
int cur = left;
while(cur<right)
{
//cur没有找到比key大的数就一直向前走
if(a[cur]<key && (++prev)!=cur)
{
swap(a[cur],a[prev]);//cur遇到比key小的值,让prev向前走一步并且和cur交换
}
++cur;
}
swap(a[++prev],a[right]);
return prev;
}
优化:
(1)区间元素少到一定个数,进行直接插入排序
快排采用了递归的算法,递归建立栈帧消耗十分大当对小区间进行排序时,反不如直接插入排序更为高效。
(2)三数取中法取得key值下标的位置
给定左右区间的值,计算出中间下标,返回这三个数中不大不小的那个,将该下标的值与最右侧的值进行交换即可。从而尽可能保证划分后的两个区间大小相差不会很大,从而提高了快排的效率。
int Getmid(int *a,int left,int right)
{
int mid = left+((right-left)>>1);
if(a[left]<a[mid])
{
if(a[right]<a[left])
return left;
else if(a[right]>a[mid])
return mid;
else
return right;
}
else
{
if(a[right]<a[mid])
return mid;
else if(a[left]<a[right])
return left;
else
return right;
}
}
int PartSort1(int *a,int left,int right)
{
int key = right;
swap(a[right],a[Getmid(a,left,right)]);
while(left<right)
{
while(left<right && a[left]<=a[key])
++left;
while(left<right && a[right]>=a[key])
--right;
swap(a[left],a[right]);
}
swap(a[left],a[key]);
return left;
}
(3)非递归实现快速排序
快排的单趟排序都是运用了递归,当数量大的时候可能会遇到栈溢出问题,
递归本就是一种压栈的过程,因此我们可以用库中自带栈来实现非递归的快速排序,从而减少了递归导致的调用函数的开销。
非递归版本的实现:
void QuickSortR(int* a,size_t n)
{
assert(a);
int left = 0;
int right = n-1;
stack<int> s;
s.push(right);
s.push(left);
while(!s.empty())
{
left = s.top();
s.pop();
right = s.top();
s.pop();
int mid = PartSort1(a,left,right);
if(left < mid-1)
{
s.push(mid-1);
s.push(left);
}
if(mid+1 < right)
{
s.push(right);
s.push(mid+1);
}
}
}