穩(wěn)定性：假定在待排序的記錄序列中，存在多個具有相同的關鍵字的記錄，若經(jīng)過排序，這些記錄的相對次
序保持不變，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，則稱這種排
序算法是穩(wěn)定的；否則稱為不穩(wěn)定的。內部排序：數(shù)據(jù)元素全部放在內存中的排序。

外部排序：數(shù)據(jù)元素太多不能同時放在內存中，根據(jù)排序過程的要求不能在內外存之間移動數(shù)據(jù)的排序。

排序運用

高校排名：

在這里插入圖片描述

接下來，我會一一介紹幾種常見的排序算法

插入排序

直接插入排序

直接插入排序是一種簡單的插入排序法

基本思想：把待排序的記錄按其關鍵碼值的大小逐個插入到一個已經(jīng)排好序的有序序列中，直到所有的記錄插入完為止，得到一個新的有序序列

代碼的實現(xiàn)

//直接插入排序
void InsertSort(int* a, int n)
{
	assert(a);//傳入數(shù)組不為空指針
	int i;
	for (i = 0; i < n - 1; i++)
		
	{
		int end = i;
		int x = a[end + 1];

		while (end >= 0)
		{
			//升序
			if (a[end] >x)
			{
				a[end + 1] = a[end];
				end--;
			}
			else
			{
				break;
			}
		}
		a[end + 1] = x;
	}
}

希爾排序

解析

希爾排序在直接排序之前，進行預排列，將某些極端數(shù)據(jù)更快的排列到數(shù)列前面，構成一個接近排列好的序列，最后再進行一次直接插入排序
預排列的原理也是插入排列，只不過這里的將數(shù)組分成了gap組，分別對每一個小組進行插入排序

// 希爾排序
void ShellSort(int* a, int n)
{
	int gap = n;
	while (gap > 1)
	{
		gap /= 2;
		for (int i = 0; i < n - gap; i++)
		{
			int end = i;
			int x = a[end + gap];
			while (end >= 0)
			{
				if (a[end] > x)
				{
					a[end + gap] = a[end];
					end-=gap;
				}
				else
					break;
			}
			a[end + gap] = x;
		}
	}
}

當gap > 1時都是預排序，目的是讓數(shù)組更接近于有序。當gap == 1時，數(shù)組已經(jīng)接近有序的了，這樣就會很快。這樣整體而言，可以達到優(yōu)化的效果。我們實現(xiàn)后可以進行性能測試的對比

選擇排序

直接選擇排序

解析

每一次遍歷待排序的數(shù)據(jù)元素從中選出最?。ɑ蜃畲螅┑囊粋€元素，存放在序列的起始（或者末尾）位置，直到全部待排序的數(shù)據(jù)元素排完

代碼的實現(xiàn)

// 選擇排序
void SelectSort(int* a, int n)
{
	int begin = 0, end = n - 1;//記錄下標
	while (begin < end)
	{
		int mini = begin;
		for (int i = begin; i <= end; i++)
		{
			//遍歷找到最小數(shù)據(jù)并記錄下標
			if (a[i] < a[mini])
				mini = i;
		}
		Swap(&a[begin], &a[mini]);//交換
		begin++;//縮小范圍
	}
}

總結

時間復雜度：O(N^2)
空間復雜度：O(1)
穩(wěn)定性：不穩(wěn)定

不推薦使用

堆排序

堆排序是指利用堆（數(shù)據(jù)結構）進行選擇數(shù)據(jù)的一種排序算法

基礎思想：

原則：

先將原數(shù)組建成堆，需要注意的是排升序要建大堆，排降序建小堆
注：以大堆為例

建堆：

一個根節(jié)點與子節(jié)點數(shù)據(jù)如果不符合大堆結構，那么則對根節(jié)點數(shù)據(jù)進行向下調整，而向下調整的前提是左右子樹也符合大堆結構,所以從堆尾數(shù)據(jù)的根節(jié)點位置開始向下調整建大堆

排序：

大堆堆頂數(shù)據(jù)一定是待排數(shù)據(jù)中最大的，將堆頂數(shù)據(jù)與堆尾數(shù)據(jù)交換,交換后將除堆尾數(shù)據(jù)看成新堆，對現(xiàn)堆頂數(shù)據(jù)進行向下調整成大堆,以此循環(huán)直至排列完畢

向下調整：

找到子節(jié)點中的較大數(shù)據(jù)節(jié)點比較，如果父節(jié)點數(shù)據(jù)比大子節(jié)點小則交換，直到不符合則停止向下交換，此時再次構成了一個大堆結構.

代碼的實現(xiàn)

void Adjustdown(int* a, int n,int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		//找到數(shù)據(jù)大的子結點
		if (child + 1 < n && a[child + 1] > a[child])
		{
			child++;
		}
		//父節(jié)點數(shù)據(jù)小于子節(jié)點就交換
		if (a[parent] < a[child])
		{
			Swap(&a[parent], &a[child]);
			//更新下標
			parent = child;
			child = parent * 2 + 1;
		}
		else//否則向下調整完畢
			break;
	}
}

// 堆排序(升序)建大堆
void HeapSort(int* a, int n)
{
	int i;
	//建大堆
	for (i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		Adjustdown(a, n, i);
	}
	//交換調整
	for (i = n - 1; i >= 0; i--)
	{
		Swap(&a[0], &a[i]);//與當前堆尾數(shù)據(jù)交換
		Adjustdown(a, i, 0);//對交換后堆頂數(shù)據(jù)進行向下調整
	}
}

總結：

堆排序使用堆來選數(shù)，效率就高了很多。
時間復雜度：O(N*logN)
空間復雜度：O(1)
穩(wěn)定性：不穩(wěn)定

交換排序之冒泡排序

冒泡排序

每次遍歷數(shù)組，對相鄰數(shù)據(jù)進行比較，不符合排序要求則交換

代碼的實現(xiàn)

// 冒泡排序
void BubbleSort(int* a, int n)
{
	int i, j;
	for (i = 0; i < n - 1; i++)//趟數(shù)
	{
		for (j = 0; j < n - 1 - i; j++)//比較次數(shù)
		{
			if (a[j] > a[j + 1])//滿足條件
				Swap(&a[j], &a[j + 1]);//交換
		}
	}
}