2. 程式人生 > >各種排序演算法詳解C++實現

各種排序演算法詳解C++實現

阿新 • • 發佈：2018-11-09

1.氣泡排序
時間複雜度 O ( n 2 ) O(n^2) ，空間複雜度 O

( 1 ) O(1) 。
a.比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。
b.對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對。在這一點，最後的元素應該會是最大的數。
c.針對所有的元素重複以上的步驟，除了最後一個。
d.持續每次對越來越少的元素重複上面的步驟，直到沒有任何一對數字需要比較。
若為n個數，一共需遍歷n-1次，每次講最大的數放到最後一位。第i次需遍歷前n-i+1個數。

#include<iostream>
#include<thread>
using std::cout;
using std::endl;

void swap(int &a, int &b) {
	a = a + b;
	b = a - b;
	a = a - b;
}

void bubbleSort(int *unsortArray, const int &length) {
	for (int i = 0; i < length; ++i) {
		for (int j = 0; j < length - 1 - i; ++j) {
			if (unsortArray[j] > unsortArray[j + 1]) {
				swap(unsortArray[j], unsortArray[j + 1]);
			}
		}
	}
}

int main() {
	int sort[] = { 9,8,7,6,5,4,3,2,1,0 };
	int length = sizeof(sort) / sizeof(int);
	bubbleSort(sort, length);

	for (int i = 0; i < length; ++i) {
		cout << sort[i] << endl;
	}
	while (1) {
		std::this_thread::sleep_for(std::chrono::microseconds(1000));
	}
}

2.選擇排序
時間複雜度為 O ( n 2 ) O(n^2) ，空間複雜度 O ( 1 ) O(1) 。
第1趟，在待排序記錄r[1]r[n]中選出最小的記錄，將它與r[1]交換；第2趟，在待排序記錄r[2]r[n]中選出最小的記錄，將它與r[2]交換；以此類推，第i趟在待排序記錄r[i]~r[n]中選出最小的記錄，將它與r[i]交換，使有序序列不斷增長直到全部排序完畢。

#include<iostream>
#include<thread>
using std::cout;
using std::endl;

void swap(int &a, int &b) {
	int tem = 0;
	tem = a;
	a = b;
	b = tem;
}

void selectionSort(int *unsortArray, const int &length) {
	int minIndex = -1;
	for (int i = 0; i < length; ++i) {
		minIndex = i;
		for (int j = 0; j < length - i; ++j) {
			if (unsortArray[j + i] < unsortArray[minIndex]) {
				minIndex = j + i;
			}
		}
		swap(unsortArray[i], unsortArray[minIndex]);
	}
}

int main() {
	int sort[] = { 9,8,7,6,5,4,3,2,1,0 };
	int length = sizeof(sort) / sizeof(int);
	selectionSort(sort, length);

	for (int i = 0; i < length; ++i) {
		cout << sort[i] << endl;
	}
	while (1) {
		std::this_thread::sleep_for(std::chrono::microseconds(1000));
	}
}

3.插入排序
時間複雜度 O ( n 2 ) O(n^2) ，空間複雜度 O ( 1 ) O(1) 。
通過掃描前面已排序的子列表，將位置i處的元素定位到從0到i的子列表之內的正確的位置上。

#include<iostream>
#include<thread>
using std::cout;
using std::endl;

void insertSort(int *unsortArray, const int &length) {
	for (int i = 1; i < length; ++i) {
		for (int j = 0; j < i + 1; ++j) {
			if (unsortArray[j] > unsortArray[i]) {
				int tem = unsortArray[i];
				for (int k = 0; k < i - j; ++k) {
					unsortArray[i - k] = unsortArray[i - k - 1];
				}
				unsortArray[j] = tem;
				break;
			}
		}
	}
}

int main() {
	int sort[] = { 9,8,7,6,5,4,3,2,1,0 };
	int length = sizeof(sort) / sizeof(int);
	insertSort(sort, length);

	for (int i = 0; i < length; ++i) {
		cout << sort[i] << endl;
	}
	while (1) {
		std::this_thread::sleep_for(std::chrono::microseconds(1000));
	}
}

4.歸併排序
時間複雜度 O ( N ∗ l o g N ) O(N*logN) ，空間複雜度為 O ( N ) O(N) 。
先將所有數兩個一組排序，再將兩組四個數一起排序為新的一組，迴圈下去每次合併兩組，直到所有數有序。
遞迴法：

#include<iostream>
#include<thread>
#include<vector>
using std::cout;
using std::endl;

void merge_sort(int *unsortArray, const int &start, const int &mid, const int &end) {
	std::vector<int> tempArray;
	int i = start;
	int j = mid + 1;
	int k = end - start + 1;
	while (i<=mid && j<=end)
	{
		if (unsortArray[i] <= unsortArray[j]) {
			tempArray.push_back(unsortArray[i++]);
		}
		else{
			tempArray.push_back(unsortArray[j++]);
		}
	}
	while (i<=mid){
		tempArray.push_back(unsortArray[i++]);
	}
	while (j <= end) {
		tempArray.push_back(unsortArray[j++]);
	}
	for (int i = 0; i < k; ++i) {
		unsortArray[start + i] = tempArray[i];
	}
}

void mergeSort(int *unsortArray, const int &start, const int &end) {
	if (start < end)
	{
		int mid = (start + end) / 2;
		mergeSort(unsortArray, start, mid);
		mergeSort(unsortArray, mid + 1, end);
		merge_sort(unsortArray, start, mid, end);
	}
}


int main() {
	int sort[] = { 9,8,7,6,5,4,3,2,1,0 };
	int length = sizeof(sort) / sizeof(int);
	mergeSort(sort,0,9);

	for (int i = 0; i < length; ++i) {
		cout << sort[i] << endl;
	}
	while (1) {
		std::this_thread::sleep_for(std::chrono::microseconds(1000));
	}
}

非遞迴方法：

#include<iostream>
#include<thread>
#include<vector>
using std::cout;
using std::endl;

void merge(int *unsortArray, const int &start, const int &step, const int &length) {
	const int start2 = start + step;//第二組的起始位置
	int rightLength = -1;//第二組的長度
	int i = 0;
	int j = 0;
	std::vector<int> tempArray;
	if (start2 + step - 1 >= length - 1) {
		rightLength = length - start2;
	}
	else {
		rightLength = step;
	}
	while (i < step && j < rightLength) {
		if (unsortArray[start + i] <= unsortArray[start2 + j]) {
			tempArray.push_back(unsortArray[start + i]);
			++i;
		}
		else {
			tempArray.push_back(unsortArray[start2 + j]);
			++j;
		}
	}
	while (i < step) {
		tempArray.push_back(unsortArray[start + i]);
		++i;
	}
	while (j < rightLength) {
		tempArray.push_back(unsortArray[start2 + j]);
		++j;
	}
	for (i = 0; i < step + rightLength; ++i) {
		unsortArray[start + i] = tempArray[i];
	}

}

void mergeSort(int *unsortArray, const int &length) {//歸併排序，非遞迴方法
	int step = 1;
	while (step < length) {
		for (int i = 0; i <= length - step - 1; i += (step * 2)) {
			merge(unsortArray, i, step, length);
		}
		step *= 2;
	}
}


int main() {
	int sort[] = { 9,8,7,6,5,4,3,2,1,0 };
	int length = sizeof(sort) / sizeof(int);
	mergeSort(sort, 10);

	for (int i = 0; i < length; ++i) {
		cout << sort[i] << endl;
	}
	while (1) {
		std::this_thread::sleep_for(std::chrono::microseconds(1000));
	}
}

5.快速排序
時間複雜度 O ( N ∗ l o g N ) O(N*logN) ，空間複雜度 O ( l o g N )   O ( N ) O(logN)~O(N) 。
a.先從數列中取出一個數作為基準數。
b.分割槽過程，將比這個數大的數全放到它的右邊，小於或等於它的數全放到它的左邊。
c.再對左右區間重複第二步，直到各區間只有一個數。
在每次分割槽的過程中，可以先將選取的比較數放到陣列的最後位置，並設定一個新的區間表示小於比較數的範圍，然後從前到後依次遍歷，若小於比較數則放到新的區間，若大於則不動。
遞迴方法：

#include<iostream>
#include<thread>
#include<vector>
using std::cout;
using std::endl;


void swap(int &a, int &b) {
	int tem = 0;
	tem = a;
	a = b;
	b = tem;
}


void quickSort(int *unsortArray, const int &start, const int &end) {//快速排序，遞迴方法
	if (start < end) {
		swap(unsortArray[start], unsortArray[end]);
		int index = start;
		for (int i = start; i < end; ++i) {
			if (unsortArray[i] < unsortArray[end]) {
				swap(unsortArray[i], unsortArray[index++]);
			}
		}
		swap(unsortArray[index], unsortArray[end]);
		quickSort(unsortArray, start, index - 1);
		quickSort(unsortArray, index + 1, end);
	}
}


int main() {
	int sort[] = { 9,8,7,6,5,4,3,2,1,0 };
	int length = sizeof(sort) / sizeof(int);
	quickSort(sort, 0, 9);

	for (int i = 0; i < length; ++i) {
		cout << sort[i] << endl;
	}
	while (1) {
		std::this_thread::sleep_for(std::chrono::microseconds(1000));
	}
}

非遞迴方法：

#include<iostream>
#include<thread>
#include<vector>
#include<stack>
using std::cout;
using std::endl;
void swap(int &a, int &b) {
	int tem = 0;
	tem = a;
	a = b;
	b = tem;
}

int quick_sort(int *unsortArray, const int &start, const int &end) {//快速排序劃分區間部分
	int index = 0;
	if (start < end) {
		swap(unsortArray[start], unsortArray[end]);
		index = start;
		for (int i = start; i < end; ++i) {
			if (unsortArray[i] < unsortArray[end]) {
				swap(unsortArray[i], unsortArray[index++]);
			}
		}
		swap(unsortArray[index], unsortArray[end]);
	}
	return index;
}


void quickSort(int *unsortArray, const int &length) {//
	std::stack<int> st;
	st.push(0);
	st.push(length - 1);
	while (!st.empty()) {
		int end = st.top();
		st.pop();
		int start = st.top();
		st.pop();
		int tempIndex = quick_sort(unsortArray, start, end);
		if (start < tempIndex-1) {
			st.push(start);
			st.push(tempIndex - 1);
		}
		if (end > tempIndex+1) {
			st.push(tempIndex + 1);
			st.push(end);
		}
	}	
}


int main() {
	int sort[] = { 9,8,7,6,5,4,3,2,1,0 };
	int length = sizeof(sort) / sizeof(int);
	quickSort(sort, 10);

	for (int i = 0; i < length; ++i) {
		cout << sort[i] << endl;
	}
	while (1) {
		std::this_thread::sleep_for(std::chrono::microseconds(1000));
	}
}

6.堆排序
時間複雜度 O ( N ∗ l o g N ) O(N*logN) ，空間複雜度 O ( 1 ) O(1) 。
每次講大根堆的堆頂元素從後往前排列，然後將最後元素放到堆頂，對堆重新序列化，然後再取出堆頂元素。

#include<iostream>
#include<thread>

using std::cout;
using std::endl;

template <typename T>void swap(T &a, T &b) {
	T tem =a;
	a = b;
	b = tem;
}


template <typename T> class PQ_ComplHeap {
public:
	T * sortArray;
	int length;
	PQ_ComplHeap(const int &len);
	~PQ_ComplHeap() {
		delete[] sortArray;
		cout<<"我被析構了！！！"<<endl;
	}
	void display();
	void heapify();
	bool inHeap(const int &i,const int &len) {
		return (i > (-1)) && (i < len);
	}
	int lChild(const int &i) {
		return (2 * i + 1);
	}
	int rChild(const int &i) {
		return 2 * (i + 1);
	}
	bool lChildValid(const int &i, const int &len) {//判斷是否有左孩子
		return inHeap(lChild(i), len);
	}
	bool rChildValid(const int &i, const int &len) {  //判斷是否有右孩子
		return inHeap(rChild(i), len);
	}
	int bigger(const int &i, const int &j) {  //判斷哪個節點大
		if (sortArray[i]>=sortArray[j])
		{
			return i;
		}
		else
		{
			return j;
		}
	}
	int percolateDown(const int &aimIndex,const int &len);
	int properParent(const int &father,const int &len);
	void heapSort();

};
template <typename T> int PQ_ComplHeap<T>::properParent(const int &father,const int &len) {  //判斷一個節點以及他的子節點哪個適合做為大根堆頂節點
	if (rChildValid(father,len)) {
		return bigger(father, bigger(lChild(father), rChild(father)));
	}
	else if (lChildValid(father,len)) {
		return bigger(father, lChild(father));
	}
	else
	{
		return father;
	}
}
template <typename T> int PQ_ComplHeap<T>::percolateDown(const int &aimIndex,const int &len) {  //堆元素的下濾
	int temp = aimIndex;
	int j;
	while (temp != (j = properParent(temp,len))) {
		swap(sortArray[temp], sortArray[j]);
		temp = j;
	}
	return temp;
}
template <typename T> void PQ_ComplHeap<T>::heapify() {       //大根堆化
	for (int i = length - 1; inHeap(i,length); --i) {
		percolateDown(i,length);
	}
}

template <typename T> PQ_ComplHeap<T>::PQ_ComplHeap(const int &len) {   //建構函式
	sortArray = new T[length = len];
	for (int i = 0; i < len; ++i) {
		sortArray[i] = i;
	}
}

template <typename T> void PQ_ComplHeap<T>::display() {    //依次列印堆中元素
	for (int i = 0; i < length; ++i) {
		cout << sortArray[i] << endl;
	}
}

template <typename T> void PQ_ComplHeap<T>::heapSort() {  //堆排序
	heapify();
	display();
	cout << "start::" << endl;
	for (int i = 0; i < length; ++i) {
		swap(sortArray[0], sortArray[length - 1 - i]);
		percolateDown(0,length-i-1);
	}
}

int main() {

	PQ_ComplHeap<int> heapSort(10);
	heapSort.heapSort();
	heapSort.display();
	while (1) {
		std::this_thread::sleep_for(std::chrono::milliseconds(1000));
	}
	return 1;
}

7.希爾排序，空間複雜度 O ( 1 ) O(1) 。
時間複雜度 O ( N ∗ l o g N ) O(N*logN) ，時間複雜度依賴於步長的選擇。

#include<iostream>
#include<thread>
#include<vector>
#include<stack>
using std::cout;
using std::endl;
void swap(int &a, int &b) {
	int tem = 0;
	tem = a;
	a = b;
	b = tem;
}


void shellSort(int *unsortArray, const int &length, int step) {
	while (step > 0) {
		for (int i = step; i < length; ++i) {
			int tem = i;
			while (tem >= step) {
				if (unsortArray[tem] < unsortArray[tem - step]) {
					swap(unsortArray[tem], unsortArray[tem - step]);
				}
				tem -= step;
			}
		}
		--step;
	}
}

int main() {
	int sort[] = { 9,8,7,6,5,4,3,2,1,0 };
	int length = sizeof(sort) / sizeof(int);
	shellSort(sort, 10, 1);

	for (int i = 0; i < length; ++i) {
		cout << sort[i] << endl;
	}
	while (1) {
		std::this_thread::sleep_for(std::chrono::microseconds(1000));
	}
}

8.基數排序
時間複雜度為O(N)，空間複雜度為 O ( M ) O(M) ，M為桶的數量。
不是基於比較的排序，基於桶排序的思想。先將個位桶排序再依次倒出，然後十位。。。

#include<iostream>
#include<thread>
#include<vector>
#include<stack>
#include<queue>
using std::cout;
using std::endl;



int pickNumber(const int &number, const int &loc) {  //返回一個十進位制數的第幾位，個位為0
	int tem = number;
	if (loc > 0) {
		tem = number / (loc * 10);
	}
	return tem % 10;
}

void radixSort(int *unsortArray, const int &length) {  //基數排序
	std::queue<int> bucket[10];
	for (int i = 0; i < 2; ++i) {
		for (int j = 0; j < length; ++j) {
			
			int k = pickNumber(unsortArray[j], i);
			bucket[k].push(unsortArray[j]);
		}
		int k = 0;
		for (int j = 0; j < length; ++j) {
			while (!bucket[j].empty())
			{
				unsortArray[k++] = bucket[j].front();
				bucket[j].pop();
			}
		}
	}
}

int main() {
	int sort[] = { 39,8,27,6,45,4,33,2,41,20 };
	int length = sizeof(sort) / sizeof(int);
	radixSort(sort, 10);

	for (int i = 0; i < length; ++i) {
		cout << sort[i] << endl;
	}

	while (1) {
		std::this_thread::sleep_for(std::chrono::microseconds(1000));
	}
}

排序演算法複雜度總結

時間複雜度

1. O ( N 2 ) O(N^2) ：氣泡排序，選擇排序，插入排序
2. O ( N l o g N ) O(NlogN) ：歸併排序，快速排序，希爾排序，堆排序
3. O ( N ) O(N) ：計數排序，基數排序

空間複雜度

1. O ( 1 ) O(1) ：氣泡排序，選擇排序，插入排序，希爾排序，堆排序
2. O ( l o g N ) − O ( N ) O(logN)-O(N) ：快速排序
3. O ( N ) O(N) ：歸併排序
4. O ( M ) O(M) ：桶排序

排序演算法的穩定性

穩定性：相同元素，元素順序在排序前與排序後保持不變。
不穩定排序：選擇排序，快速排序，希爾排序，堆排序。
穩定排序：氣泡排序，插入排序，歸併排序，計數排序，基數排序，桶排序。

工程應用

工程上的排序是綜合排序
陣列較小時，是插入排序
陣列較大時，快速排序或者其他 O ( N l o g N ) O(NlogN) 的排序。

題目一

已知一個幾乎有序的陣列，幾乎有序是指，如果把陣列排好序的話，每個元素移動的距離不超過k，並且k相對於陣列長度來說很小。請問選擇什麼方法對其排序比較好。
分析：
時間複雜度為 O ( N ) O(N) 的計數與基數排序，因為不知道是否連續，不考慮。
時間複雜度為 O ( N 2 ) O(N^2) ，氣泡排序與選擇排序的複雜度與原始順序無關，插入排序可以考慮時間複雜度為 O ( N ∗ K ) O(N*K) 。
時間複雜度為 O ( N ∗ l o g N ) O(N*logN) ，歸併排序與快速排序的複雜度與原始順序無關。
答案：改進後的堆排序。每次建立k個元素的小根堆，然後取堆頂元素。時間複雜度為 O ( N ∗ l o g K ) O(N*logK) 。

題目二

判斷陣列中是否有重複值，必須保證額外空間複雜度為 O ( 1 ) O(1) .
分析： 若沒有空間複雜度限制，使用雜湊表。
先排序，後判斷。
希爾排序，或堆排序。

題目三

把兩個有序數組合併為一個數組，第一個陣列空間正好可以容納兩個陣列的元素。
分析：從後往前比較，可以避免第一個陣列的元素往後平移。

題目四

荷蘭國旗問題。只包含0,1,2的整數陣列進行排序，要求使用交換，原地排序，而不是利用計數進行排序。
分析：調整過程與快排劃分過程類似，時間複雜度為 O ( N ) O(N) ，額外空間複雜度為 O ( 1 ) O(1) 。
遍歷陣列之前，在陣列兩邊設立0區，與2區，每次將0,2分別放入各自對應區域。噹噹前位置與2區位置重合時，停止。

題目五

在行與列都有序的二維陣列中找數。
分析：時間複雜度為 O ( M + N ) O(M+N) ，M行，N列，空間複雜度為 O ( 1 ) O(1) 。
從左下角或者右上角開始找。

題目六

找出需要排序的最短子陣列長度。例如[1,5,4,3,2,6,7]，返回4，因為只有[5,4,3,2]需要排序。
分析：最優解時間複雜度為 O ( N ) O(N) ，額外空間複雜度為 O ( 1 ) O(1) 。
首先從左到右遍歷陣列，用一個max變數記錄遍歷過的最大值，若遍歷過的最大值大於當前數，則為反序，此時只記錄出現反序的最右位置。
然後從右往左遍歷陣列，用一個min變數記錄遍歷過的最小值，若遍歷過的最小值小於當前數，則為反序，此時只記錄出現反序的最左位置。
最右與最左位置中間的範圍（包括最右最左）為需要排序的範圍。

int minSortLength(const int *unsortArray, const int &length) {
	int max = unsortArray[0];
	int rightFlag = 0;
	int min = unsortArray[length - 1];
	int leftFlag = length;
	for (int i = 0; i < length; ++i) {
		if (unsortArray[i] >= max) {
			max = unsortArray[i];
		}
		else{
			rightFlag = i;
		}
	}
	for (int i = length - 1; i >= 0; --i) {
		if (unsortArray[i] <= min) {
			min = unsortArray[i];
		}
		else {
			leftFlag = i;
		}
	}
	return (rightFlag - leftFlag) > 0 ? (rightFlag - leftFlag + 1) : 0;
}

題目七

給定一個整數陣列，返回排序之後，相鄰兩個數的最大差值。例如[1,2,3,7,8]，返回4。
分析：最優解時間複雜度為 O ( N ) O(N) ，空間複雜度為 O ( N ) O(N) 。首先遍歷一遍陣列，選出最大值與最小值，然後將最大最小之間劃分為N個桶，代表N個區間，然後將最大值放到第N+1個桶中。然後將所有數放到桶中，比較當前桶的最大值與下一個非空桶的最小值之間的差，選出最大的差值。

int maxDifference(const int *unsortArray, const int &length) {
	int max = unsortArray[0];
	int min = unsortArray[0];
	int len = length + 1;
	std::stack<int> *st = new std::stack<int>[len];
	for (int i = 0; i < length; ++i) {
		if (unsortArray[i] > max) {
			max = unsortArray[i];
		}
		if (unsortArray[i] < min) {
			min = unsortArray[i];
		}
	}
	double intervel = (max - min) / static_cast<double>(length);
	for (int i = 0; i < length; ++i) {
		if (unsortArray[i] < max) {
			int k = (unsortArray[i] - min) / intervel;
			st[k].push(unsortArray[i]);
		}
	}
	int lastMax = min;
	int nowMax = min;
	int nowMin = max;
	int maxLength = 0;
	for (int i = 0; i < len; ++i) {
		nowMin = max;
		lastMax = nowMax;
		while (!st[i].empty()){
			int tem = st[i].top();
			st[i].pop();
			if (tem < nowMin) {
				nowMin = tem;
			}
			if (tem > nowMax) {
				nowMax = tem;
			}
		}
		int temp = nowMin - lastMax;
		if (temp > maxLength) {
			maxLength = temp;
		}
	}
	delete[] st;
	return maxLength;
}

相關推薦

各種排序演算法詳解C++實現

1.氣泡排序 時間複雜度 O ( n

堆排序演算法詳解及實現-----------c語言

堆排序原理：   堆排序指的是將大堆（小堆）堆頂（即下標為0）元素與堆的最後一個（即下標為hp->size - 1）元素交換，hp->size–,將其餘的元素再次調整成大堆（小堆），再次將堆頂（即下標為0）元素與堆的最後一個（即下標為hp->s

各種排序演算法詳解&時間、空間複雜度

排序演算法經過了很長時間的演變，產生了很多種不同的方法。對於初學者來說，對它們進行整理便於理解記憶顯得很重要。每種演算法都有它特定的使用場合，很難通用。因此，我們很有必要對所有常見的排序演算法進行歸納。排序大的分類可以分為兩種：內排序和外排序。在排序過程中，全部記錄存放在記憶體，則稱為內排序，如果排序過程中需

氣泡排序演算法詳解C++程式

（1）氣泡排序演算法：（Bubble Sort）首先肯定是一種簡單的排序演算法，它重複地走訪過要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。 走訪數列的工作是重複地進行直到沒有

各種排序演算法學習整理 C++實現

感謝網上各位大神的講解，參考了網上多位大神的部落格，做出了這次整理。 排序演算法中用到的函式： void Swap(int* a, int* b) { int tmp = *a;

C語言實現八大排序演算法詳解及其效能之間的

概述 排序是資料結構中的重要一節，也是演算法的重要組成部分。主要分為內部排序以及外部排序，今天我們講內部排序，也就是八大排序。 插入排序 直接插入排序 演算法思想 演算

插入排序演算法詳解（C++實現）

插入排序 輸入：n個數（a1,a2,...,an）。 輸出：輸入序列的一個排列（a1',a2',...,an'），使得a1'到an'為有序序列。 待排序的數稱為關鍵字key。 插入排序與平時生活中打牌時，整理手中牌的順序相似。最開始手中沒有牌，我們從桌上摸起一張牌，將它

快速排序演算法詳解（原理、實現和時間複雜度）

快速排序是對氣泡排序的一種改進，由 C.A.R.Hoare（Charles Antony Richard Hoare，東尼·霍爾）在 1962 年提出。 快速排序的基本思想是：通過一趟排序將要排序的資料分割成獨立的兩部分，其中一部分的所有資料比另一部分的所有資料要小，再按這種方法對這兩部分資料分別進行快速排

必須知道的八大種排序演算法【java實現】（三） 歸併排序演算法、堆排序演算法詳解

一、歸併排序演算法 基本思想： 　　歸併（Merge）排序法是將兩個（或兩個以上）有序表合併成一個新的有序表，即把待排序序列分為若干個子序列，每個子序列是有序的。然後再把有序子序列合併為整體有序序列。 歸併排序示例：   合併方法： 設r[i…n]由兩個有序子表r[i…m]和r[m+1…n]組

常見9大排序演算法詳解及python3實現

穩定：如果a原本在b前面，而a=b，排序之後a仍然在b的前面； 不穩定：如果a原本在b的前面，而a=b，排序之後a可能會出現在b的後面； 內排序：所有排序操作都在記憶體中完成； 外排序：由於資料太大，因此把資料放在磁碟中，而排序通過磁碟和記憶體的資料傳輸才能進行；

PHP實現各種經典演算法詳解

<? //-------------------- // 基本資料結構演算法 //-------------------- //二分查詢（數組裡查詢某個元素） function bin_sch($array, $low, $high, $k){

各種排序演算法總結及C#程式碼實現

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

常用的排序演算法詳解（C#版）

只要是搞程式設計的演算法、資料結構、作業系統、計算機組成原理這些東西都會有用到，就像醫生給人治病一樣，只有瞭解了人的內部機理、運作機制，才能很好的做到對症下藥，藥到病除。而上面所說的那些計算機理論課就好像人的內部機理一樣，我們往往都把這些東西給忽略了，而把更多的精力放在具體的程式語言實現上，當然我也是這樣，

C++ 幾種排序演算法詳解

排序的演算法有很多種，其關鍵在於根據待排序序列的特性選擇合適的排序方式。下面將介紹不同的排序方式。 基本排序演算法 基本排序演算法主要包括插入排序，快速排序，氣泡排序等三種排序方式，下面將對這三種排序演算法分別進行分析 插入排序 假定待排序陣列序列為：data[5,2

資料結構 7 基礎排序演算法詳解 雞尾酒排序法、瞭解鐘擺排序實現

## 前言 上節，我們已經通過對冒泡演算法的優化、能夠達到我們預想的結果。比較次數的減少、本節將繼續在氣泡排序的基礎上進行優化、能夠達到剛好的效果。 ## 雞尾酒排序

資料結構 8 基礎排序演算法詳解、快速排序的實現、瞭解分治法

## 快速排序 快速排序與氣泡排序一樣，同樣是屬於`交換排序` 叫做快速排序也是有原因的。因為它採用了**分治法的概念** ![image.png](https://file.chaobei.xyz/blogs/image_1588862421197.png_imagess) 其中最重要的一個概念就是

經典排序演算法（1）——氣泡排序演算法詳解

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

經典排序演算法（4）——折半插入排序演算法詳解

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

常用Java排序演算法詳解

  一、最小堆排序(MinHeapSort) 基本原理：對於給定的n個記錄，初始時把這些記錄看作一顆順序儲存的二叉樹，然後將其調整為一個小頂堆，然後將堆的最後一個元素與堆頂元素進行交換後，堆的最後一個元素即為最小記錄；接著講前(n-1)個元素重新調整為一個小頂堆，再將堆頂元素與當前

常見排序演算法彙總（C++實現）

插入排序 #include<iostream> using namespace std; /* 插入排序的細節講解與複雜度分析 時間複雜度O(N ^ 2)，額外空間複雜度O(1) */ void InsertSort(int *arr, int length) { int i,