2. 程式人生 > >【演算法】常見的七種排序及其演算法優化

【演算法】常見的七種排序及其演算法優化

阿新 • • 發佈：2019-02-09

1、插入排序

有一個已經有序的資料序列，要求在這個已經排好的資料序列中插入一個數，但要求插入後此資料序列仍然有序，這個時候就要用到一種新的排序方法——插入排序法,插入排序的基本操作就是將一個數據插入到已經排好序的有序資料中，從而得到一個新的、個數加一的有序資料，演算法適用於少量資料的排序，時間複雜度為O(n^2)。是穩定的排序方法。插入演算法把要排序的陣列分成兩部分：第一部分包含了這個陣列的所有元素，但將最後一個元素除外（讓陣列多一個空間才有插入的位置），而第二部分就只包含這一個元素（即待插入元素）。在第一部分排序完成後，再將這個最後元素插入到已排好序的第一部分中。 插入排序的基本思想是：每步將一個待排序的紀錄，按其關鍵碼值的大小插入前面已經排序的檔案中適當位置上，直到全部插入完為止。

大概步驟如上圖，下面實現程式碼

void InsertSort(int* arr,size_t n)//插入排序
{
	assert(arr);
	for(size_t index=1;index<n;index++)
	{
		size_t tmp=arr[index];
		int pos=index-1;
		while (pos>=0&&arr[pos]>tmp)
		{
		arr[pos+1]=arr[pos];
		pos--;
		}
	
			arr[pos+1]=tmp;
		}
}
2、希爾排序 希爾排序(Shell Sort)是插入排序
的一種。也稱縮小增量排序，是直接插入排序演算法的一種更高效的改進版本。希爾排序是非穩定排序演算法。 希爾排序是把記錄按下標的一定增量分組，對每組使用直接插入排序演算法排序；隨著增量逐漸減少，每組包含的關鍵詞越來越多，當增量減至1時，整個檔案恰被分成一組，演算法便終止。
大概過程如上圖，程式碼如下 
void ShellSort(int* arr,size_t n)//希爾排序
{
	int gap=n/3+1;
	for(size_t index=gap;index<n;index++)
	{
		size_t tmp=arr[index];
		int pos=index-gap;
		while(pos>=0&&arr[pos]>tmp)
		{
			arr[pos+gap]=arr[pos];
			pos-=gap;
		}
		arr[pos+gap]=tmp;
	}
}
3、氣泡排序

重複地走訪過要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。

不再做過多解釋，直接上程式碼

void PopSort(int* arr,size_t n)//氣泡排序
{
	for(int i=0;i<n;i++)
	{
		for(int j=i+1;j<n;j++)
		{
			if(arr[i]>arr[i+1])
			{
				int tmp=arr[i];
				arr[i]=arr[i+1];
				arr[i+1]=tmp;
			}
		}
	}
}
4、選擇排序

每一次從待排序的資料元素中選出最小（或最大）的一個元素，存放在序列的起始位置，直到全部待排序的資料元素排完。



程式碼如下

void selectSort(int*arr ,size_t n)
{
	int min;
	int tmp;
	for(int i=0;i<n;i++)
	{
		
		for(int j=0;j<n;j++)
		{
			min=i;
			if(arr[min]>arr[j])
			{
				min=j;
			}
		
			tmp=arr[min];
			arr[min]=arr[j];
			arr[j]=tmp;
		}
	}
}

優化的選擇排序

每次選一個最小值放最前面，選最大一個值放後面


程式碼如下

void SelectSort2(int* arr,int n)
{
	assert(arr);
	int left=0;
	int right=n-1;
    while (left<right)
    {
			int min=left;
			int max=right;
			for (int i=left;i<=right;++i)
			{
				if (arr[min]>=arr[i])
				{
					min=i;
				}
                
				if(arr[max]<=arr[i])
				{
					max=i;
				}
			
				
			}
		    swap(arr[left],arr[min]);
			if (left==max)
			{
				max=min;
			}
			swap(arr[right],arr[max]);
		    left++;
			right--;
    }

	}

5、快速排序

通過一趟排序將要排序的資料分割成獨立的兩部分，其中一部分的所有資料都比另外一部分的所有資料都要小，然後再按此方法對這兩部分資料分別進行快速排序，整個排序過程可以遞迴進行，以此達到整個資料變成有序序列。


挖坑法塊排，選第一數做比較

void FastSort(int* arr,int low,int high)//設定一個低位一個高位，進行快速排序
{
	if(low>=high)
		return;
	int first=low;
	int last=high;
	int mid=ThreeMid(arr,first,last);
	swap(arr[mid],arr[first]);
	int key=arr[first];//用挖坑法
	while (first<last)
	{
		while(first<last&&arr[last]>=key)
		{
			--last;
		}
		arr[first]=arr[last];
		while (first<last&&arr[first]<=key)
		{
			++first;
		}
		arr[last]=arr[first];

	}
	arr[first]=key;
	FastSort(arr,low,first-1);
	FastSort(arr,first+1,high);
}
挖坑法選最後數做比較

單趟：

int PartSort2(int* arr,int first,int last)//挖坑法
{
	int left=first;
	int right=last;
	int key=ThreeMid(arr,first,last);
	swap(arr[key],arr[last]);
	int tmp=arr[last];
	while (left<right)
	{
		while (left<right&&arr[left]<=tmp)
		{
			++left;
		}
			arr[right]=arr[left];
		while(left<right&&arr[right]>=tmp)
		{
			--right;
		}
			arr[left]=arr[right];
	}
	arr[left]=tmp;
	return left;

}
遞迴 
void QuickSort2(int* arr,int first,int last)
{

	if(first<last)
	{
		int key=PartSort2(arr,first,last);
		QuickSort2(arr,first,key-1);
		QuickSort2(arr,key+1,last);
	}
	
}
快排優化

當陣列數超過13個進行快排，否則插入排序

void QuickSort2(int* arr,int first,int last)
{

	if(first<last)
	{
		if ((last-first)>=13)
		{
			int key=PartSort2(arr,first,last);
			QuickSort2(arr,first,key-1);
			QuickSort2(arr,key+1,last);
		}
		else
			InsertSort(arr,sizeof(arr)/sizeof(arr[0]));
		
	}
	
}
前後指標法，陣列前後個一個指標，同時進行排序 
int PartSort(int* arr,int left,int right)
{	
    int mid=ThreeMid(arr,left,right);
	swap(arr[mid],arr[right]);
	int key=arr[right];
	int first=left;
	int last=right-1;
	while(first<last)
	{
		while (first<last&&arr[first]<=key)
		{
			++first;
		}
		while (first<last&&arr[last]>=key)
		{
			--right;
		}
		swap(arr[first],arr[last]);
	}
	if(arr[first]>arr[right]);
	swap(arr[first],arr[right]);
	return first;
}
void QuickSort3(int* arr,int left,int right)
{
	while (left<right)
	{
		int mid=PartSort(arr,left,right);
		QuickSort3(arr,left,mid-1);
		QuickSort3(arr,mid+1,right);
	
	}
}


6、堆排序

堆分為大根堆和小根堆，是完全二叉樹。大根堆的要求是每個節點的值都不大於其父節點的值，即A[PARENT[i]] >= A[i]。在陣列的非降序排序中，需要使用的就是大根堆，因為根據大根堆的要求可知，最大的值一定在堆頂。

建堆

void AdjustDown(int* arr,int index,int n)
{
	int parent=index;
	int child=2*parent+1;
	while (child<n)
	{
		if(child<n&&arr[child]<arr[child+1])
			child++;
	    if (child<n&&arr[child]>arr[parent])
		{
			swap(arr[parent],arr[child]);
			parent=child;
			child=2*parent+1;
		}
		else
			break;
	}
	child=parent;
}
堆排序 
void HeapSort(int* arr,int n)
{
	for(int i=n/2-1;i>=0;--i)
	{
      AdjustDown(arr,i,n);
	}
	for(int j=n-1;j>0;--j)
	{
		swap(arr[j],arr[0]);
        AdjustDown(arr,0,j);
	}
	if(arr[0]>arr[1])
	swap(arr[0],arr[1]); 
}
7、歸併排序

歸併過程為：比較a[i]和a[j]的大小，若a[i]≤a[j]，則將第一個有序表中的元素a[i]複製到r[k]中，並令i和k分別加上1；否則將第二個有序表中的元素a[j]複製到r[k]中，並令j和k分別加上1，如此迴圈下去，直到其中一個有序表取完，然後再將另一個有序表中剩餘的元素複製到r中從下標k到下標t的單元。歸併排序的演算法我們通常用遞迴實現，先把待排序區間[s,t]以中點二分，接著把左邊子區間排序，再把右邊子區間排序，最後把左區間和右區間用一次歸併操作合併成有序的區間[s,t]。



單趟排序

void Merge(int* arr,int* tmp,int first,int mid,int last)//歸併
{
	int i=first;int j=mid+1;int k=first;
	while (i!=mid+1&&j!=last+1)
	{
		if(arr[i]>arr[j])
			tmp[k++]=arr[j++];
		else
			tmp[k++]=arr[i++];
	}
	while(i!=mid+1)
	{
		tmp[k++]=arr[i++];
	}
	while (j!=last+1)
	{
		tmp[k++]=arr[j++];
	}
	for(i=first;i<=last;i++)
		arr[i]=tmp[i];
}
遞迴歸併 
void MergeSort(int* arr,int* tmp,int first,int last)//歸併排序
{
	int mid;
	if (first<last)
	{
		mid= first+((last-first)>>1);          
		MergeSort(arr,tmp,first,mid);
		MergeSort(arr,tmp,mid+1,last);
		Merge(arr,tmp,first,mid,last);
	}
}

三數求中法
int ThreeMid(int* arr,int left,int right)//找首位，末尾和中點中中間的數
{
	int mid=left+((right-left)>>1);
	while (left<right)
	{
		if(arr[left]<arr[right])
		{
			if(arr[mid]<arr[left])
				return left;
			else if(arr[right]<arr[mid])
				return right;
			else
				return mid;
		}
		if(arr[left]>arr[right])
		{
			if(arr[mid]<arr[right])
				return right;
			else if(arr[mid]>arr[left])
				return left;
			else
				return mid;
		}
	}
	return mid;
}
三數中中間值進行比較避免了用最後一位比較時最後一位是最大值或用第一位比較時第一位是最小值，降低了時間複雜度。

測試程式碼

int main()
{
	int arr[]={9,3,5,1,4,7,8,0};
	int tmp[8];
	//int arr[]={2,3,6,5,4,13,56};
	cout<<"原陣列  ： ";
	Print(arr,sizeof(arr)/sizeof(arr[0]));
	InsertSort(arr,sizeof(arr)/sizeof(arr[0]));
	cout<<"插入排序： ";
	Print(arr,sizeof(arr)/sizeof(arr[0]));
	ShellSort(arr,sizeof(arr)/sizeof(arr[0]));
	cout<<"希爾排序： ";
	Print(arr,sizeof(arr)/sizeof(arr[0]));
	PopSort(arr,sizeof(arr)/sizeof(arr[0]));
	cout<<"氣泡排序： ";
	Print(arr,sizeof(arr)/sizeof(arr[0]));
	selectSort(arr,sizeof(arr)/sizeof(arr[0]));
	cout<<"選擇排序： ";
	Print(arr,sizeof(arr)/sizeof(arr[0]));
	FastSort(arr,0,sizeof(arr)/sizeof(arr[0])-1);
	cout<<"快速排序： ";
	Print(arr,sizeof(arr)/sizeof(arr[0]));
	SelectSort2(arr,sizeof(arr)/sizeof(arr[0]));
	cout<<"選擇排序2：";
	Print(arr,sizeof(arr)/sizeof(arr[0]));
	HeapSort(arr,sizeof(arr)/sizeof(arr[0]));
	cout<<"堆排序：   ";
	Print(arr,sizeof(arr)/sizeof(arr[0]));
	QuickSort2(arr,0,sizeof(arr)/sizeof(arr[0])-1);
	cout<<"快速排序2: ";
	Print(arr,sizeof(arr)/sizeof(arr[0]));
	MergeSort(arr,tmp,0,sizeof(arr)/sizeof(arr[0])-1);
	cout<<"歸併排序： ";
	Print(arr,sizeof(arr)/sizeof(arr[0]));
	QuickSort2(arr,0,sizeof(arr)/sizeof(arr[0])-1);
	cout<<"快速排序3：";
	Print(arr,sizeof(arr)/sizeof(arr[0]));
	system("pause");                
	return 0;
}


測試用例

int arr[]={9,3,5,1,4,7,8,0};

測試用例

int arr[]={2,3,6,5,4,13,56};



歡迎補充

相關推薦

【演算法】常見的七種排序及其演算法優化

1、插入排序 有一個已經有序的資料序列，要求在這個已經排好的資料序列中插入一個數，但要求插入後此資料序列仍然有序，這個時候就要用到一種新的排序方法——插入排序法,插入排序的基本操作就是將一個數據插

【觀點】有一種說法，演算法工程師的薪酬只有三檔（附大資料工程師技能圖譜）

本文從當前炙手可熱的演算法工程師就業開始講起，詳細的和朋友們探討一下，普通程式設計師如何轉型成為演算法工程師？ 先談錢。 有一種說法，演算法工程師薪酬區間基本就是三擋： 薪酬範圍 人才背景 能力特徵 15~30W 科班畢業的數學系碩士研究生或有ACM銅獎以上 熟悉通用的模型，知道如

【整理】常見排序演算法及其時間複雜度總結

原文出處： 本篇主要整理了氣泡排序，直接插入排序，直接選擇排序，希爾排序，歸併排序，快速排序，堆排序七種常見演算法，是從上面三篇博文中摘抄整理的，非原創。 一、氣泡排序 主要思路是： 通過交換相鄰的兩個數變成小數在前大數在後，這樣每次遍歷後，最大的數就“沉”到最後面了。重複N次即可以使陣列有序。 氣泡

雜記【2】常見排序演算法-JavaScript

文章目錄 直接插入排序法 希爾排序法 氣泡排序法 快速排序法 選擇排序法 堆排序 二路歸併排序(遞迴版) 直接插入排序法 // 直接插入排序法 function InsertSort

【資料結構】十一種排序演算法C++實現

   練習了十一種排序演算法的C++實現：以下依次為，冒泡、選擇、希爾、插入、二路歸併、快排、堆排序、計數排序、基數排序、桶排序，可建立sort.h和main.cpp將程式碼放入即可執行。如有錯誤，請指出更正，謝謝交流。 // sort.h # include <

七種排序演算法及其複雜度

1.氣泡排序 時間複雜度：平均：O(N^2)，最壞：O(N^2)，最好：O(N) 思想：從後往前開始，相鄰的兩兩進行比較，將小的逐漸移到前面。(也可以從前往後開始兩兩相鄰的進行比較) 程式碼： void BubbleSort(int *a, int N) { if (a

【資料結構】考研 8種排序演算法視覺化解讀

排序(Sorting) 排序(Sorting)是計算機內經常進行的一種操作，其目的是將一組“無序”的記錄序列調整為“有序”的記錄序列。分內部排序和外部排序，若整個排序過程不需要訪問外存便能完成，則稱此類排序問題為內部排序。反之，若參加排序的記錄數量很大，整個序列的排序過程不

【Python排序搜尋基本演算法】之拓撲排序

   拓撲排序是對有向無環圖的一種排序，滿足如下兩個條件： 1.每個頂點出現且只出現一次； 2.若A在序列中排在B的前面，則在圖中不存在從B到A的路徑。 如上的無環有向圖，v表示頂點：v=['a','b','c','d','e']，e表示有向邊：e=[('a

用java實現七種排序演算法。

　很多時候，聽別人在討論快速排序，選擇排序，氣泡排序等，都覺得很牛逼，心想，臥槽，排序也分那麼多種，就覺得別人很牛逼呀，其實不然，當我們自己去了解學習後發現，並沒有想象中那麼難，今天就一起總結一下各種排序的實現原理並加以實現。 　　　　　　　　　　　　　　　　　　　　　　　　-WH 一、文章

【資料結構與演算法】連結串列——遞增排序

今天看書時偶然想到的問題，書上是要求將一個數據插入一個有序連結的線性連結串列中， 所以我想先進行連結串列內的資料排序在進行插入資料。 在這裡我只寫了排序的函式。   函式實現： void Sort(LinkList&list, int &n) { 　　f

【 58沈劍 架構師之路】InnoDB七種鎖——記錄鎖、間隙鎖、臨鍵鎖

MySQL的InnoDB的細粒度行鎖，是它最吸引人的特性之一。   但是，如《InnoDB，5項最佳實踐》所述，如果查詢沒有命中索引，也將退化為表鎖。   InnoDB的細粒度鎖，是實現在索引記錄上的。   一，InnoDB的索引 InnoDB的索引有兩類索引，聚集

【 58沈劍 架構師之路】InnoDB七種鎖——共享/排它鎖、意向鎖、插入意向鎖

今天，將要介紹InnoDB另外三種：共享/排他鎖，意向鎖，插入意向鎖。   一，共享/排它鎖(Shared and Exclusive Locks) 《InnoDB併發為何這麼高？》一文介紹了通用的共享/排它鎖，在InnoDB裡當然也實現了標準的行級鎖(row-level locking)，共

【 58沈劍 架構師之路】InnoDB七種鎖——自增鎖（Auto-inc Locks）

一，案例說明 MySQL，InnoDB，預設的隔離級別(RR)，假設有資料表： t(id AUTO_INCREMENT, name);   資料表中有資料： 1, shenjian 2, zhangsan 3, lisi   事務A先執行，還未提交： inse

【 58沈劍 架構師之路】InnoDB七種鎖——自增鎖（Auto-inc Locks）

一，案例說明 MySQL，InnoDB，預設的隔離級別(RR)，假設有資料表： t(id AUTO_INCREMENT, name);   資料表中有資料： 1, shenjian 2, zhangsan 3, lisi   事務A先

【演算法】合併兩個排序的陣列

合併兩個排序的陣列 對於集合合併這類操作，其實不同的資料量，為了速度或者更小的空間有很多種做法，甚至可使用多執行緒併發處理都可以（下一節會實現該方式）。下面的例子基於單執行緒，且資料量較小的實現。

【轉載】UML類圖畫法及其之間的幾種關係

【轉載】UML類圖畫法及其之間的幾種關係 原文地址： https://blog.csdn.net/wanmeirongyan100/article/details/51601570 UML類圖畫法及其之間的幾種關係 最近做重構專案，需要畫一下類圖，發現類圖的畫法及其之間的幾種關

[資料結構]七種排序演算法小結

氣泡排序 選擇排序 插入排序 歸併排序 堆排序 希爾排序 氣泡排序 時間複雜度o(n2)。下面以一個例子來看什麼是氣泡排序。 例： 第一次取區間[0,7]，通過比較第i個和第i+1個的大小，如果第i+1個數字小於第i個，則互換。

七種排序演算法的簡單分析與實現

{    int nFirst = nLow;    int nMid = (nLow + nHigh) /2;    int nSecond = nMid +1;    int* p = (int*)malloc(sizeof(int) * (nHigh - nLow +1));    int nIndex

用C++實現七種排序演算法，可選擇排序方法，簡單易懂。

       最近學習演算法，先從簡答的開始學起，用C++做了一個實現七種排序演算法的介面，可選擇想要用的選擇演算法，不過，由於時間倉促，沒有來得及優化和程式碼註釋，後期還會加上程式碼註釋，隨便優化一下程式碼，提高執行效率； /***********************

【java】十大經典排序演算法（動圖演示）

0，演算法概述 0.1演算法分類 十種常見排序演算法可以分為兩大類： 非線性時間比較類排序：通過比較來決定元素間的相對次序，由於其時間複雜度不能突破O（nlogn），因此稱為非線性時間比較類排序。 線性時間非比較類排序：不通過比較來決定元素間的相對次序，它可以突