數據結構--排序

這篇博客包含了數據結構中多種的排序算法：

（1）簡單選擇：第一趟在A[0]~A[n-1]之間找到最小的，與A[0]進行交換，以後在A[1]~A[n-1]之間進行。。。第i趟在A[i-1]~A[n-1]之間找到最小的，最後須要通過n-1趟，每次肯定一個元素最終的位置；

（2）冒泡排序：從頭至尾兩兩比較，每次要麼冒一個最大值到最後，要麼冒一個最小值到端頭，可使用last來保存最後交換的元素的前一個，若是爲0，則說明已經徹底有序，無需在進行 下一趟的排序，這種方法最多進行n-1趟，能夠肯定元素的最終的位置；

（3）雙向冒泡排序：一趟排序後最大的元素沉底，最小的元素到最前面，同時避免重複的比較，使用了s和t；

（4）直接插入：認爲第一堂的時候第一個元素是有序的，每一次將剩下的n-1個元素按關鍵字的大小依次插入到有序的隊列，每個元素從後往前找到本身可以插入的位置，最終須要通過n-1趟的排序；

（5）堆排序：構造一個最大堆，採用向下調整的思想，第一次將棧頂A[0]與棧底A[n-1]進行交換，在進行向下調整構造最大堆（排除A[n-1]來構造）。。。如此反覆依次將最大的元素排到棧頂交換到棧底

（6）快速排序：以left爲基準，i向後找大於等於A[left]的元素，j向前走找小於等於A[left]的元素，若是i<j，則進行交換，最後將A[left]和A[j]交換

（7）兩路合併：開始所有當作n個長度爲1的序列，以後進行兩兩的合併，最終獲得結果。。。

 

性能分析

	最好	最壞	平均	空間	穩定性	最終位置
簡單選擇	O(n^2)	O(n^2)	O(n^2)	O(1)	不穩定	能肯定
直接插入	O(n)	O(n^2)	O(n^2)	O(1)	穩定	不能
冒泡	O(n)	O(n^2)	O(n^2)	O(1)	穩定	能
快速排序	O(nlogn)	O(n^2)	O(nlogn)	O(logn)	不穩定	能
兩路合併	O(nlogn)	O(nlogn)	O(nlogn)	O(n)	穩定	不能

代碼：

#include<iostream>
using namespace std;
void swap(int &a, int &b)
{
	int tmp;
	tmp = a;
	a = b;
	b = tmp;
}
void EasySelect(int a[], int n)
{//簡單選擇排序，利用的是循環n-1次，每次找到最小的那個，與當前第一個置換
	int k;
	for (int i = 0; i < n - 1; i++)
	{
		k = i;
		for (int j = i + 1; j < n; j++)
		{
			if (a[k]>a[j])
			{
				k = j;
			}
		}
		swap(a[i], a[k]);
	}
}
void DirectInsert(int a[], int n)
{//直接插入排序，當前第一個元素是有序的，以後的元素從後往前查詢是否比有序元素的某一個元素小，若是小，則不斷的後移元素，而後將最後一個位置插入當前元素
	for (int i = 1; i < n; i++)
	{
		int j = i;//j以前的元素所有是有序的
		int tmp = a[j];//保留當前的元素的值
		while (j>0 && a[j - 1] > tmp)
		{
			a[j] = a[j - 1];
			j--;
		}
		a[j] = tmp;
	}
}
void BubbleSort(int a[], int n)
{//冒泡排序，每次賦值一個last，代表當前一趟排序，最後置換的那一對元素的前一個，若是等於0，只說明沒有發現變化，已是有序的了
	int i = n - 1;
	int last;
	while (i>0)
	{
		last = 0;
		for (int j = 0; j < i; j++)
		{
			if (a[j]>a[j + 1])
			{
				swap(a[j], a[j + 1]);
				last = j;
			}
		}
		i = last;
	}
}
 
 
void QSort(int a[], int left, int right)
{//當left<right的前提下才能夠，賦值i和j，注意j是right+1，其次是在i>=j的時候中止
	if (left < right){
		int i = left;
		int j = right + 1;
		do{
			do{ i++; } while (a[i] < a[left]);
			do{ j--; } while (a[j]>a[left]);
			if (i < j)
				swap(a[i], a[j]);
		} while (i < j);
		swap(a[left], a[j]);
		QSort(a, left, j - 1);
		QSort(a, j + 1, right);
	}
}
void QuickSort(int a[], int n)
{//快速排序
	QSort(a, 0, n - 1);
}
void merge(int a[], int i1, int i2, int j1, int j2)
{
	int i = i1;
	int j = i2;
	int *temp = new int[j2 - i1 + 1];
	int k = 0;
	while (i <= j1&&j <= j2)
	{
		if (a[i] < a[j])
			temp[k++] = a[i++];
		else
		{
			temp[k++] = a[j++];
		}
	}
	while (i <= j1)
		temp[k++] = a[i++];
	while (j <= j2)
		temp[k++] = a[j++];
	for (int i = 0; i < k; i++)
	{
		a[i1++] = temp[i];
	}
	delete[]temp;
}
//兩路合併排序
void MergeSort(int a[], int n)
{
	int i1, i2, j1, j2;
	int size = 1;
	while (size < n)
	{
		i1 = 0;
		while (i1 + size < n)
		{
			i2 = i1 + size;
			j1 = i2 - 1;
			if (i2 + size - 1>n - 1)
			{
				j2 = n - 1;
			}
			else
			{
				j2 = i2 + size - 1;
			}
			merge(a, i1, j1, i2, j2);
			i1 = j2 + 1;
		}
		size = size * 2;
	}
}
 
 
//堆排序，利用的是最大堆
void adjustdown(int a[], int r, int j)
{//表示a[r]以後的元素都已經知足最大堆，
	int child = 2 * r + 1;
	int tmp = a[r];
	while (child <= j)
	{
		if (child < j&&a[child] < a[child + 1])
			child++;
		if (tmp >= a[child])
			break;
		a[(child - 1) / 2] = a[child];
		child = child * 2 + 1;
	}
	a[(child - 1) / 2] = tmp;
}
void HeapSort(int a[], int n)
{
	for (int i = (n - 2) / 2; i > -1; i--)
	{
		adjustdown(a, i, n - 1);//首先構造堆
	}
	for (int i = n - 1; i > 0; i--)
	{//構造出來的最大堆，而後把棧頂的元素與棧底元素交換，以後在進行堆排序
		swap(a[0], a[i]);
		adjustdown(a, 0, i - 1);
	}
}
void DoubleBubbleSort(int a[], int n)
{
	int left = 0;
	int right = n - 1;
	int s, t;
	while (left < right)
	{
		s = left;
		for (int i = left; i < right; i++)
		{
			if (a[i]>a[i + 1])
			{
				swap(a[i], a[i + 1]);
				s = i;//循環結束後s後的元素已經有序
			}
		}
		right = s;
		t = right;
		for (int i = right; i > left; i--)
		{
			if (a[i] < a[i - 1])
			{
				swap(a[i], a[i - 1]);
				t = i;//t以前的元素已經有序
			}
		}
		left = t;
	}
}
int main()
{
	int a[7] = { 48, 36, 68, 72, 12, 48, 02 };
	//HeapSort(a, 7);
	//BubbleSort(a, 7);
	//EasySelect(a, 7);
	//DirectInsert(a, 7);
	//QuickSort(a, 7);
	DoubleBubbleSort(a, 7);
	for (int i = 0; i < 7; i++)
		cout << a[i] << " ";
	cout << endl;
	return 0;
}