Bubble, Insertion, Selection, Quick and Heap Sort

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

参考链接

http://www.algorithmist.com/index.php/Sorting