记一下一些排序算法,有一些算法之后会补充
灰色的表示待排序的数组,白色表示已经排序完成的。
选择排序
选择排序通过找出最大的元素,把它移到a[n-1],然后在余下的n-1个元素中继续找到最大的元素,移到a[n-2],一直循环,直到剩下一个元素。例
第一行是初始数组,第一次对a[0:5]进行循环,先找到最大数字8在a[2],将其移到a[5];然后第二次对a[0:4]进行循环,找到最大的数字6在a[0],将其移到a[4],一直循环到最后只剩下a[0]=1。
程序:
template<class T>
void selectionSort(T a[], int n)
{
//给数组a[0:n-1]的n个元素排序
for(int size=n;size>1;size--)
{
int indexOfMax=0;
//找到a[0:size-1]之间最大的那个数
for(int i=1;i<size;i++)
if(a[indexOfMax]<=a[i])
indexOfMax=i;
swap(a[indexOfMax],a[size-1]);
}
}
优化
选择排序有一个缺点:即使元素已经有序,程序仍然会继续运行。为了去除不必要的迭代,我们可以在查找最大元素时,同时检查数组是否已经有序,用一个标志位即可。
程序:
template<class T>
void selectionSort(T a[], int n)
{
//及时终止的选择排序
bool sorted=false;//标志位
for(int size=n;(size>1) && !sorted;size--)
{
int indexOfMax=0;
sorted=true;//已经有序
//找到a[0:size-1]之间最大的那个数
for(int i=1;i<size;i++)
if(a[indexOfMax]<=a[i])
indexOfMax=i;
else
sorted=false;//无序
swap(a[indexOfMax],a[size-1]);
}
}
我们从a[0:size-1]中查找最大数的下标时,比原来多了个else条件,当我们一直只执行if条件,else条件将无法执行,即数组中每个数都小于它后面的数,就证明了它已经是有序了。
冒泡排序
冒泡排序是一种简单的排序方法,它通过相邻两个值的比较,将最大的元素移到序列最右端
例:
可以看出来,对于同一数组,尽管最后的结果和选择排序一样,但中间的排序过程是不一样的,选择排序只要把最大的数和最右边的数交换位置即可,而冒泡排序是从头开始比较相邻的数来进行“冒泡”。
程序:
template<class T>
void bubble(T a[],int n)
{
//将a[0:n-1]中最大元素移到最右边
for(int i=0;i<n-1;i++)
if(a[i]>a[i+1])
swap(a[i],a[i+1]);
}
template<class T>
void bubbleSort(T a[],int n)
{
//冒泡排序
for(int i=n;i>1;i--)
bubble(a,i);
}
和选择排序一样,第一次要排序的是a[0:n-1],第二次是a[0:n-2],一直到最后只剩下a[0]。
优化
和选择排序同样的缺陷:如果排序中途已经没有发生元素互换,那么已经说明数组已经有序,我们要去除不必要的迭代,提前终止排序。
template<class T>
bool bubble(T a[],int n)
{
//将a[0:n-1]中最大元素移到最右边
bool swapped=false;//未移动
for(int i=0;i<n-1;i++)
if(a[i]>a[i+1])
{
swap(a[i],a[i+1]);
swapped=true;//交换
}
return swapped;
}
template<class T>
void bubbleSort(T a[],int n)
{
//及时终止的冒泡排序
for(int i=n;(i>1) && bubble(a,i);i--)
}
插入排序
一个数组如果只有一个元素,称为单元数组,单元数组肯定是有序数组,所以对n个元素的数组,可以从第一个元素构成的单元数组开始,不断做插入操作。插入第二个元素,得到2个元素的有序数组,一直插入,最终得到n个元素的有序数组。
程序:
template<class T>
void insertionSort(T a[],int n)
{
//插入排序
for(int i=1;i<n;i++)
{
//把a[i]插入a[0:i-1]
T t=a[i];
int j;
for(j=i-1;(j>=0) && t<a[j];j--)
a[j+1]=a[j];
a[j+1]=t;
}
}
第二个循环是在a[0:i-1]中,从第i-1个数开始找,找到刚刚好大于a[i]的值,同时把大于a[i]的值都往后移一位,最后将a[i]插入到合适的位置。
二路归并排序
归并排序是用了分而治之的方法来设计的排序算法,把n个元素按非递减顺序排列,若n为1,则终止;否则,将序列划分为k个子序列(k是不小于2的整数)。先对每个子序列排序,然后将有序子序列归并为一个序列。而二路归并排序首先将两个相邻的大小为1的子序列归并,然后将每个相邻的大小为2的子序列归并,循环直到只剩下一个有序序列。
例子:
初始段:【8】【4】【5】【6】【2】【1】【7】【3】
归并: 【4 8】【5 6】【1 2】【3 7】
归并: 【4 5 6 8】【1 2 3 7】
归并: 【1 2 3 4 5 6 7 8】
程序:
//归并排序
template <class T>
void mergeSort(T a[],int n)
{
T *b=new T[n];//用来装载归并排序好后生成的序列
int segmentSize=1;//子序列的大小,从大小为1的子序列开始归并
while(segmentSize<n)
{
mergePass(a,b,segmentSize);//从a到b的归并
segmentSize*=2;//每次子序列的大小都翻倍,即1,2,4,8...
mergePass(b,a,n,segmentSize);//从b到a的归并
segmentSize*=2;
}
delete[] b;//归并完成后,删除多余的b
}
//把相邻的子序列从x到y归并
template <class T>
void mergePass(T x[],T y[],int n,int segmentSize)
{
int i=0;//下一个子序列的起点
//当序列有超过2个以上的子序列
while(i<=n-2*segmentSize)
{
merge(x,y,i,i+segmentSize-1,i+2*segmentSize-1);
i=i+2*segmentSize;
}
//当序列少于2个满子序列
if(i+segmentSize<n)
//剩下有两个子序列
merge(x,y,i,i+segmentSize-1,n-1);
else
//只剩下一个子序列,复制到y
for(int j=i;j<n;j++)
y[j]=x[j];
}
//把相邻的数据段从c到d归并
template <class T>
void merge(T c[],T d[], int startOfFirst,int endOfFirst,int endOfSecond)
{
int first=startOfFirst;//第一个子序列的索引
int second=endOfFirst+1;//第二个子序列的索引
int result=startOfFirst;//归并序列的索引
//直到有一个子序列归并到d
while((first<=endOfFirst)&&(second<=endOfSecond))
if(c[first]<=c[second])
d[result++]=c[first++];
else
d[result++]=c[second++];
//归并剩余元素
if(first>endOfFirst)
for(int q=second;q<=endOfSecond;q++)
d[result++]=c[q];
else
for(int q=first;q<=endOfFirst;q++)
d[result++]=c[q];
}
快速排序
快速排序也是用了分而治之的思想,把n个元素分为三段:左段left、中间段middle和右段right。中间段只有一个元素。左段的元素都不大于中间段的元素,右段的元素都不小于中间段的元素。然后在左段和右段继续进行快速排序。中间段元素称为支点或分割元素。
程序:
template <class T>
void quickSort(T a[],int leftEnd,int rightEnd)
{
//归并排序
if(leftEnd>=rightEnd) return;
int leftCursor=leftEnd;//从左到右移动的索引
int rightCursor=rightEnd+1;//从右到左移动的索引
T pivot=a[leftEnd];
//将位于左侧不小于支点的元素和位于右侧不大于支点的元素交换
while(true)
{
do
{//寻找左侧不小于支点的元素
leftCursor++;
}while(a[leftCursor]<pivot);
do
{//寻找右侧不大于支点的元素
rightCursor--;
}while(a[rightCursor]>pivot);
if(leftCursor>=rightCursor) break;//没有找到交换的元素对
swap(a[leftCursor],a[rightCursor]);
}
//放置支点
a[leftEnd]=a[rightCursor];
a[rightCursor]=pivot;
quickSort(a,leftEnd,rightCursor-1);//对左侧数段排序
quickSort(a,rightCursor+1,rightEnd);//对右侧的数段排序
}
优化
对快速排序可以进行优化,因为当要排序的序列是个非递增的有序序列时,快速排序就变成了冒泡排序,复杂度为n^2。所以我们可以使用三值取中来对快速排序进行优化。三值取中就是在三个元素a[leftEnd]、a[(leftEnd+rightEnd)/2]和a[rightEnd]中选择大小居中的中指元素作为支点元素。最简单的方法是将中值位置上的元素与元素a[leftEnd]交换,然后继续使用普通的快速排序方法。
各个排序的负责度表
排序算法 | 最坏情况下的性能 | 平均性能 |
冒泡排序 | n^2 | n^2 |
计数排序 | n^2 | n^2 |
插入排序 | n^2 | n^2 |
选择排序 | n^2 | n^2 |
堆排序 | nlogn | nlogn |
归并排序 | nlogn | nlogn |
快速排序 | n^2 | nlogn |