[算法學習]常用排序算法實現

1.插入排序

   插入排序是最簡單最直觀的排序算法了，它的依據是：遍歷到第N個元素的時候前面的N-1個元素已經是排序好的了，那麼就查找前面的N-1個元素把這第N個元素放在合適的位置，如此下去直到遍歷完序列的元素爲止。
   算法的複雜度也是簡單的，排序第一個需要1的複雜度，排序第二個需要2的複雜度，因此整個的複雜度就是
　1 + 2 + 3 + …… + N = O（N ^ 2）的複雜度。

/*
*插入排序
*/
void InsertSort(int *arr,int n)
{
	int j=0,temp;
	for(int i=1;i<n;i++)
	{
		int j=i;
		temp=arr[i];
		while(j>0)
		{
			if(temp<arr[j-1])//arr[i]<arr[i-1]，則需將arr[i-1]右移一個位置
			{
				arr[j]=arr[j-1];
				j--;
			}else
				break;
		}
		arr[j]=temp;//將數放於合適位置
		print(arr,n);
	}
}

2、shell排序

  shell排序是對插入排序的一個改裝，它每次排序把序列的元素按照某個增量分成幾個子序列，對這幾個子序列進行插入排序，然後不斷縮小增量擴大每個子序列的元素數量，直到增量爲一的時候子序列就和原先的待排列序列一樣了，此時只需要做少量的比較和移動就可以完成對序列的排序了。

/*
*shell排序
*/
void ShellSort(int *arr,int n)
{
	int incre=n/3+1;
	bool tag=true;
	do
	{
		if(incre==1)
			tag=false;
		ShellSortWithIncre(arr,n,incre);
		incre=incre/3+1;
	}while(incre>=1&&tag);
}
/*
根據增量,使用插入排序調整順序
*/
void ShellSortWithIncre(int *arr,int n,int incre)
{
	for(int i=incre;i<n;i++)
	{
		int j=i;
		int temp=arr[i];
		while(j-incre>=0)
		{
			if(temp<arr[j-incre])
			{
				arr[j]=arr[j-incre];
				j-=incre;
			}else
				break;
		}
		arr[j]=temp;
	}
}

3、冒泡排序

   冒泡排序算法的思想：很簡單，每次遍歷完序列都把最大（小）的元素放在最前面，然後再對剩下的序列從父前面的一個過程，每次遍歷完之後待排序序列就少一個元素，當待排序序列減小爲只有一個元素的時候排序就結束了。因此，複雜度在最壞的情況下是O（N ^ 2）

/*
*冒泡排序
*/
void BubbleSort(int *arr,int n)
{
	bool exchanged=true;
	for(int i=0;i<n;i++)
	{
		exchanged=false;
		for(int j=0;j<n-i-1;j++)
		{
			if(arr[j]>arr[j+1])
			{
				std::swap(arr[j],arr[j+1]);
				exchanged=true;
			}
		}
		if(!exchanged)
			return;
	}
}

4、快速排序

快速排序的算法思想： 選定一個樞紐元素，對待排序序列進行分割，分割之後的序列一個部分小於樞紐元素，一個部分大於樞紐元素，再對這兩個分割好的子序列進行上述的過程。

/*
快速排序
*/
void QuickSort(int *arr,int start,int end)
{
	int low=start,high=end-1;
	int pivot;
	if(low<high)
	{
		pivot=Partition(arr,low,high);
		//print(arr,end-start+1);
		QuickSort(arr,low,pivot);
		QuickSort(arr,pivot+1,end);
	}
}
/*
根據pivot將數組分爲兩部分,左邊小於pivot,右邊大於pivot
*/
int Partition(int *arr,int start,int end)
{
	int pivot=getMediumNum(arr,start,end);
	std::swap(arr[start],arr[pivot]);
	int pivotNum=arr[start];
	//std::cout<<"pivot is "<<pivotNum<<std::endl;
	while(start<end)
	{
		while(start<end&&pivotNum<arr[end])
			--end;
		if(start<end)
			arr[start++]=arr[end];
		while(start<end&&arr[start]<=pivotNum)
			++start;
		if(start<end)
			arr[end--]=arr[start];
	}
	arr[start]=pivotNum;
	return start;
}
/*
取頭,中,尾三數的中值
*/
int getMediumNum(int *arr,int start,int end)
{
	int medium=(start+end)/2;
	if(arr[start]<arr[medium])
	{
		if(arr[medium]<arr[end])
			return medium;
		else
			if(arr[start]>arr[end])
				return start;
			else
				return end;
	}else
	{
		if(arr[medium]>arr[end])
			return medium;
		else
			if(arr[start]>arr[end])
				return end;
			else
				return start;
	}
}

另一個分割方法：

int Partition(int *arr,int start,int end)
{
	int x = arr[end];
	int i = start - 1;
	for(int j=start;j<end;j++)
	{
		if(arr[j]<=x)
		{
			++i;
			swap(arr[i],arr[j]);
		}
	}
	swap(arr[i+1],arr[end]);
	return i+1;
}

5、選擇排序

  每次選擇最小的數，放入該數對應的位置。

/*
選擇排序
*/
void SelectSort(int *arr,int n)
{
	for(int i=0;i<n;i++)
	{
		int min=i;
		for(int j=i;j<n;j++)
		{
			if(arr[j]<arr[min])
				min=j;
		}
		if(min!=i)
			std::swap(arr[i],arr[min]);
	}
}

6、堆排序

堆的定義：
　　n個關鍵字序列Kl，K2，…，Kn稱爲堆，當且僅當該序列滿足如下性質（簡稱爲堆性質）：
　　（1） ki≤K2i且ki≤K2i+1 或（2）Ki≥K2i且ki≥K2i+1（1≤i≤）
　　若將此序列所存儲的向量R[1……n]看做是一棵完全二叉樹的存儲結構，則堆實質上是滿足如下性質的完全二叉樹：樹中任一非葉結點的關鍵字均不大於（或不小於）其左右孩子（若存在）結點的關鍵字。
　　堆的這個性質使得可以迅速定位在一個序列之中的最小（大）的元素。
　　堆排序算法的過程如下：1）得到當前序列的最小（大）的元素
　　（2）把這個元素和最後一個元素進行交換，這樣當前的最小（大）的元素就放在了序列的最後，而原先的最後一個元素放到了序列的最前面
　　（3）的交換可能會破壞堆序列的性質（注意此時的序列是除去已經放在最後面的元素），因此需要對序列進行調整，使之滿足於上面堆的性質。重複上面的過程，直到序列調整完畢爲止。

/*
*堆排序
*/
void HeapSort(int *arr,int n)
{
	BuildMaxHeap(arr,n);
	//std::cout<<"構建的大頂堆爲:";
	//print(arr,n);
	for(int i=n-1;i>0;i--)
	{
		std::swap(arr[i],arr[0]);
		HeapAdjust(arr,0,i);
	}
}
/*
構建大頂堆
*/
void BuildMaxHeap(int *arr,int n)
{
	for(int i=n/2-1;i>=0;i--)
	{
		HeapAdjust(arr,i,n);
	}
}
/*
*調整大頂堆
*/
void HeapAdjust(int *arr,int start,int n)
{
	int rightChild=(start+1)*2;
	while(rightChild<n)//左右節點都存在
	{
		if(arr[rightChild]<arr[rightChild-1])
			--rightChild;
		if(arr[start]<arr[rightChild])
		{
			std::swap(arr[start],arr[rightChild]);
			start=rightChild;
			rightChild=(start+1)*2;
		}else
			break;
	}
	if(rightChild==n)//只有左節點,沒有右節點
	{
		if(arr[start]<arr[rightChild-1])
			std::swap(arr[start],arr[rightChild-1]);
	}
}

7、歸併排序

歸併排序的算法思想：把待排序序列分成相同大小的兩個部分，依次對這兩部分進行歸併排序，完畢之後再按照順序進行合併

/*
自底向上歸併排序
*/
void MergeSort(int *arr,int n)
{
	for(int i=1;i<n;i*=2)
	{
		MergePass(arr,i,n);
		std::cout<<i<<"路歸併後的結果:"<<std::endl;
		print(arr,n);
	}
}

/*
功能:將兩個有序數組歸併到一起
*/
void Merge(int *arr,int start,int mid,int end)
{
	int length=end-start;
	int i=start,j=mid,p=0;
	int *arr2=new int[length];
	while(i<mid&&j<end)
	{
		if(arr[i]<arr[j])
		{
			arr2[p++]=arr[i];
			++i;
		}else
		{
			arr2[p++]=arr[j];
			++j;
		}
	}
	while(i<mid)
		arr2[p++]=arr[i++];
	while(j<end)
		arr2[p++]=arr[j++];
	p=0;
	for(i=start;i<end;i++,p++)
	{
		arr[i]=arr2[p];
	}
	delete[] arr2;
}
/*
根據間隔,進行歸併
*/
void MergePass(int *arr,int interval,int n)
{
	int i=0;
	for(;i+2*interval<n;i+=2*interval)
	{
		Merge(arr,i,i+interval,i+2*interval);
	}
	if(i+interval<n)
		Merge(arr,i,i+interval,n);
}
/*
自頂向下二路歸併算法
*/
void MergeSortDC(int *arr,int start,int end)
{
	int low=start,high=end;
	int mid;
	if(low<high-1)
	{
		mid=(low+high)/2;
		MergeSortDC(arr,start,mid);
		MergeSortDC(arr,mid,end);
		Merge(arr,start,mid,end);
	}

}

8、基數排序

//基數排序
void RadixSort(int *arr,int n)
{
	bool isContinue=true;
	vector<int> ivec[10];
	int remainder=0,baseNum=1,p=0;
	while(isContinue)
	{
		isContinue=false;
		for(int i=0;i<n;i++)
		{
			remainder=(arr[i]/baseNum)%10;
			if(remainder)
				isContinue=true;
			ivec[remainder].push_back(arr[i]);
		}
		p=0;
		for(int i=0;i<10;i++)
		{
			int size=ivec[i].size();
			for(int j=0;j<size;j++)
			{
				arr[p++]=ivec[i][j];
			}
			ivec[i].clear();
		}
		baseNum*=10;
	}
}