Bubble, Insertion, Selection, Quick and Heap Sort
Bubble Sort
冒泡排序是基本的排序算法之一,时间复杂度为
,空间复杂度也为
。该算法不常被使用,因为和插入排序相比较,插入排序的时间复杂度为
,而空间复杂度为
。属于稳定排序。
有三种方法可以改进Bubble Sort,①当一轮比较却没有发生交换时,认为数据已经有序,停止排序。②当进行i轮排序后,数据序列后的N-i个元素已经有序,可以不考虑。③假设Data[i]与Data[i+1]是发生的最后一次交换,则可以肯定i+1到N数据序列已经有序,只用考虑第i个之前的数据序列即可。
/*Bubble Sort*/
void BubbleSort(int *iData, int iLen)
{
if ((NULL == iData) && (iLen < 1))
return;
for (int i=0; i<iLen; i++)
{
for (int j=0; j<iLen-i; j++)
{
if (iData[j] > iData[j+1]){
SwampData(&iData[j], &iData[j+1]);
}
}
}
}
Insertion Sort
插入排序,最简单的排序算法之一,时间复杂度为
,属于稳定排序,适用于少量数据的排序。插入排序的核心思想可以类比为:
“扑克牌”,将摸到的扑克牌按顺序排列。
/*Insertion Sort*/
void InsertionSort(int *iData,int iLen)
{
if ((NULL == iData) && (iLen < 1))
return;
int iTemp;
for (int i=2;i<=iLen;i++)
{
iTemp = iData[i];
for (int j=i; j>0; j--)
{
if (iTemp<iData[j-1]){
iData[j] = iData[j-1];
}
else{
break;
}
}
iData[j] = iTemp;
}
}
Selection Sort
选择排序,假设数据分为两个部分,一部分是排序的0~i,i+1~N-1未排序的,接下来就是从i+1~N-1中选出一个最小的和i+1进行交换。
/*Selection Sort*/
void SelectionSort(int *iData,int iLen)
{
if ((NULL == iData) && (iLen < 1))
return;
for (int i=0;i<iLen;i++)
{
int iMin=i;
for (int j=i;j<iLen;j++)
{
if (iData[j]<iData[iMin]){
iMin = j;
}
}
int iTemp = 0;
iTemp = iData[iMin];
iData[iMin] = iData[i];
iData[i] = iTemp;
}
}
Quick Sort
快速排序,是一个效率较高的排序算法。当数据基本有序时,Quik排序的效率较低!快速排序的核心可以概括为:①选择主元(pivot point),②将数据序列按照pivot point 分成两个部分。
/*Quick Sort*/
int QuickPartition(int *iData, int iLow, int iHigh)
{
int iPivot = iData[iLow];
int iLeftwall = iLow;
int iTemp = 0;
for (int i=iLow+1; i<=iHigh; i++){
if (iData[i]<iPivot){
++iLeftwall;
SwampData(&iData[i],&iData[iLeftwall]);
}
}
SwampData(&iData[iLow],&iData[iLeftwall]);
return iLeftwall;
}
void QuickSort(int *iData, int iLow, int iHigh)
{
if (iLow < iHigh){
int iLeftwall = QuickPartition(iData,iLow,iHigh);
QuickSort(iData, iLow, iLeftwall-1);
QuickSort(iData, iLeftwall+1, iHigh);
}
}
Heap Sort
堆排序是一个效率较高的排序算法,其核心思想是利用堆的定义对数据进行排序处理!对于大顶堆,当对一个数据序列建立堆时,最大的值一定在堆的顶端。排序时,每次将最顶端的数据和序列中的最后一个数据交换,然后只考虑前N个数据即可,直到N=1。
堆排序的核心有两点:①构建堆,②调整树形结构,使其满足堆的性质。/*Heap Sort*/
int iN = 11;
void AdjustHeap(int *iData,int iLen)
{
int iLeft = 2*iLen+1;
int iRight = 2*iLen+2;
int iMin=iLen;
if ((iLeft< iN) && (iData[iLen] > iData[iLeft])){
iMin = iLeft;
}
if ((iRight< iN) && (iData[iMin] > iData[iRight])){
iMin = iRight;
}
if (iMin != iLen){
SwampData(&iData[iLen],&iData[iMin]);
AdjustHeap(iData,iMin);
}
}
void BuildHeap(int *iData,int iLen)
{
int iStart = (int)floor(iLen/2)-1;
for (int i=iStart; i>=0; i--){
AdjustHeap(iData, i);
}
}
void HeapSort(int *iData,int iLen)
{
if ((NULL == iData) && (iLen < 1))
return;
BuildHeap(iData,iLen);
for(int i=iLen; i>0; i--){
SwampData(&iData[0],&iData[i-1]);
iN = i-1;
AdjustHeap(iData,0);
}
}
算法的时间和空间复杂度
- n is the number of elements
- k is the number of distinct objects
Algorithm | Time Complexity | Space Complexity |
Bubble sort | - in place, extra space. | |
Insertion sort | - in place, extra space. | |
Selection sort | - in place, extra space. | |
Merge sort | - extra space. | |
Heap sort | - in place, extra space. | |
Quicksort | - expected, and with high probability. | inplace. |
Timsort | Best case Worst Case |