1、簡單的選擇排序n^2

void simple( vector<int> &a)
{
   for (auto it = a.begin(); it != a.end(); it++)
   {
       for (auto it1 = it+1; it1 != a.end(); it1++)
       {
           if (*it1<*it)
           {
               int a = *it;
               *it = *it1;
               *it1 = a;
           }
       }
   }

}

2、冒泡n^2

void bubbleSort(vector<int> &a)
{
   for (auto it = a.begin(); it != a.end()-1; it++)
   {
       for (auto it1 = a.begin(); it1 <a.begin()+( a.end()-it)-1; it1++)
       {
           vector<int>::iterator it2 = it1+1;
           if (*it2<*it1)
           {
               int a = *it1;
               *it1 = *it2;
               *it2 = a;
           }
       }
   }
}

3、插入排序n^2

void insertSort(vector<int> &a)
{
   for (auto it = a.begin()+1; it != a.end(); it++)
   {


           while (a.begin()<it)
           {
               vector<int>::iterator it2 = it - 1;
               if (*it2>*it)
               {
                   int a = *it;
                   *it = *it2;
                   *it2 = a;

               }
               else
               {
                   break;
               }
               --it;
           }


   }
}

4、快速排序N*logN

void quick_sort(int s[], int l, int r)
{
   if (l < r)
   {
       //Swap(s[l], s[(l + r) / 2]); //將中間的這個數和第一個數交換參見注1
       int i = l, j = r, x = s[l];
       while (i < j)
       {
           while (i < j && s[j] >= x) // 從右向左找第一個小於x的數
               j--;
           if (i < j)
               s[i++] = s[j];

           while (i < j && s[i] < x) // 從左向右找第一個大於等於x的數
               i++;
           if (i < j)
               s[j--] = s[i];
       }
       s[i] = x;
       quick_sort(s, l, i - 1); // 遞歸調用
       quick_sort(s, i + 1, r);
   }
}

5、堆排序n*LOGn

堆排序

　　堆排序是利用堆這種數據結構而設計的一種排序算法，堆排序是一種選擇排序，它的最壞，最好，平均時間複雜度均爲O(nlogn)，它也是不穩定排序。首先簡單瞭解下堆結構。

堆

　　堆是具有以下性質的完全二叉樹：每個結點的值都大於或等於其左右孩子結點的值，稱爲大頂堆；或者每個結點的值都小於或等於其左右孩子結點的值，稱爲小頂堆。如下圖：

同時，我們對堆中的結點按層進行編號，將這種邏輯結構映射到數組中就是下面這個樣子

該數組從邏輯上講就是一個堆結構，我們用簡單的公式來描述一下堆的定義就是：

大頂堆：arr[i] >= arr[2i+1] && arr[i] >= arr[2i+2]

小頂堆：arr[i] <= arr[2i+1] && arr[i] <= arr[2i+2]

ok，瞭解了這些定義。接下來，我們來看看堆排序的基本思想及基本步驟：

堆排序基本思想及步驟

　　堆排序的基本思想是：將待排序序列構造成一個大頂堆，此時，整個序列的最大值就是堆頂的根節點。將其與末尾元素進行交換，此時末尾就爲最大值。然後將剩餘n-1個元素重新構造成一個堆，這樣會得到n個元素的次小值。如此反覆執行，便能得到一個有序序列了

步驟一構造初始堆。將給定無序序列構造成一個大頂堆（一般升序採用大頂堆，降序採用小頂堆)。

　　a.假設給定無序序列結構如下

2.此時我們從最後一個非葉子結點開始（葉結點自然不用調整，第一個非葉子結點 arr.length/2-1=5/2-1=1，也就是下面的6結點），從左至右，從下至上進行調整。

4.找到第二個非葉節點4，由於[4,9,8]中9元素最大，4和9交換。

這時，交換導致了子根[4,5,6]結構混亂，繼續調整，[4,5,6]中6最大，交換4和6。

此時，我們就將一個無需序列構造成了一個大頂堆。

步驟二將堆頂元素與末尾元素進行交換，使末尾元素最大。然後繼續調整堆，再將堆頂元素與末尾元素交換，得到第二大元素。如此反覆進行交換、重建、交換。

a.將堆頂元素9和末尾元素4進行交換

b.重新調整結構，使其繼續滿足堆定義

c.再將堆頂元素8與末尾元素5進行交換，得到第二大元素8.

後續過程，繼續進行調整，交換，如此反覆進行，最終使得整個序列有序

再簡單總結下堆排序的基本思路：

　　a.將無需序列構建成一個堆，根據升序降序需求選擇大頂堆或小頂堆;

　　b.將堆頂元素與末尾元素交換，將最大元素"沉"到數組末端;

　　c.重新調整結構，使其滿足堆定義，然後繼續交換堆頂元素與當前末尾元素，反覆執行調整+交換步驟，直到整個序列有序。

常用排序算法的時間複雜度和空間複雜度表格

1.選擇排序

思想：每次找一個最小值。

#include <iostream>
using namespace std;
//從小到大排序
void SelectSort(int a[], int n)
{
int index, temp;
for (int i = 0; i < n - 1; i++) //執行(n-1) 次
{
index = i;
for (int j = i + 1; j<n; j++)//執行(n-1)次每個a[i]都要與a[i+1]至a[n-1]做比較
{
if (a[index] > a[j]) //記錄序列中最小值的位置
{
index = j;
}
}
if (index != i) //如果無序序列中第一個記錄不是最小值，則進行交換
{
temp = a[index];
a[index] = a[i];
a[i] = temp;
}
}
}
int main()
{
int a[10], i, n = 10, num = 10;
for (i = 0; i < n; i++)
a[i] = num--;
cout << "原序列:\n";
for (i = 0; i < n; i++)
cout << a[i] << " ";
SelectSort(a, n); cout << "排序後：\n"; for (i = 0; i < n; i++)cout << a[i] << " ";
return 0;
}
//優化排序
//如果在每一次查找最小值的時候，也可以找到一個最大值，然後將兩者分別放在它們應該出現的位置，這樣遍歷的次數就比較少了，下邊
//給出代碼實現：
void SelectSort2(int a[], int n)

{
int left = 0; int right = n - 1; int min = left;//存儲最小值的下標
int max = left;//存儲最大值的下標
while (left <= right)
{
min = left;
max = left;
for (int i = left; i <= right; ++i)
{
if (a[i] < a[min])
min = i;

			if (a[i] > a[max])

max = i;
}
swap(a[left], a[min]);
if (left == max)
max = min;
swap(a[right], a[max]);
++left;
--right;
}
}
//遞歸版
void RecursiveSelectSort(int a[], int start, int end)
{
if (start < end)
{
int temp = a[start];
int index = start;
for (int i = start + 1; i < end; i++)
{
if (a[index] > a[i])
{
index = i;
}
}
if (start != index)
{
temp = a[start];
a[start] = a[index];
a[index] = temp;
}
start++;
RecursiveSelectSort(a, start, end);
}
}

2.堆排序
思想：一是建立堆，二是堆頂與堆的最後一個元素交換位置。所以堆排序有兩個函數組成。一是建堆的滲透函數，

二是反覆調用滲透函數實現排序的函數。

void swap(int *a, int *b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}
void HeapAdjust(int *a, int i, int size) //調整堆
{
int lchild = 2 * i; //i的左孩子節點序號
int rchild = 2 * i + 1; //i的右孩子節點序號
int max = i; //臨時變量
if (i <= size / 2) //如果i不是葉節點就不用進行調整
{
if (lchild <= size&&a[lchild] > a[max])
{
max = lchild;
}
if (rchild <= size&&a[rchild] > a[max])
{
max = rchild;
}
if (max != i)
{
swap(a[i], a[max]);
HeapAdjust(a, max, size); //避免調整之後以max爲父節點的子樹不是堆
}
}
}
void BuildHeap(int *a, int size) //建立堆
{
int i;
for (i = size / 2; i >= 1; i--) //非葉節點最大序號值爲size/2
{
HeapAdjust(a, i, size);
}
}
void HeapSort(int *a, int size) //堆排序
{
int i;
BuildHeap(a, size);
for (i = size; i >= 1; i--)
{
swap(a[1], a[i]); //交換堆頂和最後一個元素，即每次將剩餘元素中的最大者放到最後面
HeapAdjust(a, 1, i - 1); //重新調整堆頂節點成爲大頂堆
}
}

3.冒泡排序

思想：通過兩兩交換，像水中的泡泡一樣，小的先冒出來，大的後冒出來，每一次都有一個相對的最大值沉底。

void BubbleSort(int a[], int n)
{
int temp;
for (int i = 0; i < n - 1; i++) //執行(n-1)次每一次冒泡都有一個最大值沉底
{
for (int j = 0; j< n - i - 1; j++) //執行(n-1)次冒泡的次數決定冒泡的位置
{
if (a[j]>a[j + 1])
{
temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
}
}
//改進的冒泡排序
//最佳運行時間：O(n)
//最壞運行時間：O(n^2)
void BubbleSort2(int a[], int n)
{
int temp,flag = 0;
for (int i = 0; i < n - 1; i++) //每一次冒泡都有一個最大值沉底
{
for (int j = 0; j<n - i - 1; j++) //冒泡的次數決定冒泡的位置
{
if (a[j]>a[j + 1])
{
flag = 1;
temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
if (flag == 0)
break; //沒有數據交換已經排好序了
}
}
//改進2傳統冒泡排序中每一趟排序操作只能找到一個最大值或最小值,我們考慮利用在每趟排序中進行正向和反向兩遍冒泡的方法一次
//可以得到兩個最終值(最大者和最小者) , 從而使排序趟數幾乎減少了一半。
void Bubble_2(int a[], int n)
{
int low = 0;
int high = n - 1; //設置變量的初始值
int tmp, j;
while (low < high)
{
for (j = low; j< high; ++j) //正向冒泡,找到最大者
if (a[j]> a[j + 1])
{
tmp = a[j];
a[j] = a[j + 1];
a[j + 1] = tmp;
}
--high; //修改high值, 前移一位
for (j = high; j>low; --j) //反向冒泡,找到最小者
if (a[j] < a[j - 1])
{
tmp = a[j];
a[j] = a[j - 1];
a[j - 1] = tmp;
}
++low; //修改low值,後移一位
}
}
//遞歸冒泡排序
void RecursiveBubbleSort(int a[], int start, int end)
{
if (start < end) //循環結束條件一爲start == end
{
int temp = 0;
int length = end - start + 1;
for (int i = start; i < length - 1; i++) //循環結束條件二爲i < length - 1;
{
if (a[i] < a[i + 1])
{
temp = a[i];
a[i] = a[i + 1];
a[i + 1] = temp;
}
}
end--;
RecursiveBubbleSort(a, start, end);
}
}

4.快速排序
思想:選擇一個基準元素,通常選擇第一個元素或者最後一個元素,通過一趟排序講待排序的記錄分割成獨立的兩部分，其中一部分記錄的元素值均比基準元素值小。另一部分記錄的元素值比基準值大。用同樣的方法繼續進行排序，直到整個序列有序。

void Swap(int *p1, int *p2)
{
int temp = *p1;
*p1 = *p2;
*p2 = temp;
}
void QuickSort(int *arr, int ileft, int iright, int length)
{
int i = ileft;//從左邊開始循環
int j = iright + 1;//從右邊開始循環
if (i < j)
{
do
{
do
{
i++;
} while (arr[i] <= arr[ileft] && i <= iright);
do
{
j--;
} while (arr[j] >= arr[ileft] && j > ileft);
if (i < j)
{
Swap(&arr[i], &arr[j]);
}
} while (i < j);
Swap(&arr[ileft], &arr[j]);
QuickSort(arr, ileft, j - 1, 0);
QuickSort(arr, j + 1, iright, 0);
}
}
//改進快排
void Swap(int *p1, int *p2)
{
int temp = *p1;
*p1 = *p2;
*p2 = temp;
}
int partition(int a[], int low, int high)
{
int privotKey = a[low]; //基準元素
while (low < high){ //從表的兩端交替地向中間掃描
while (low < high && a[high] >= privotKey)
--high; //從high 所指位置向前搜索，至多到low+1 位置。將比基準元素小的交換到低端
Swap(&a[low], &a[high]);
while (low < high && a[low] <= privotKey)
++low;
Swap(&a[low], &a[high]);
}
return low;
}
void qsort_improve(int r[], int low, int high, int k)
{
if (high - low > k)
{ //長度大於k時遞歸, k爲指定的數
int pivot = partition(r, low, high); // 調用的Partition算法保持不變
qsort_improve(r, low, pivot - 1, k);
qsort_improve(r, pivot + 1, high, k);
}
}
void quickSort(int r[], int n, int k)
{
qsort_improve(r, 0, n, k);//先調用改進算法Qsort使之基本有序
//再用插入排序對基本有序序列排序
for (int i = 1; i <= n; i++){
int tmp = r[i];
int j = i - 1;
while (tmp < r[j])
{
r[j + 1] = r[j];
j = j - 1;
}
r[j + 1] = tmp;
}
}

5.插入排序
思想：假設待排序的記錄存放在數組R[1..n]中。初始時，R[1]自成1個有序區，無序區爲R[2..n]。從i=2起直至i=n爲止，依次將R[i]插入當前的有序區R[1..i-1]中，生成含n個記錄的有序區。

void InsertSort(int a[], int n)
{
for (int i = 2; i <=n; i++) //外循環（n-1）次
{
int j = i - 1; // 從下標爲1開始
a[0] = a[i]; //每個數都要與a[0](相當於key)比較
while (a[0]<a[j] && j >0) //比a[0]大，則替換
{
a[j + 1] = a[j];
j--; //向前移動一位，再進行比較
}
a[j + 1] = a[0];
}
}
int main()
{
int a[20], i, n =10;
int num = 10;
for (i = 1; i <=10; i++)
a[i] = num--;
cout << "原序列:\n";
for (i = 1; i <=n; i++)
cout << a[i] << " ";
cout << endl;
InsertSort(a, 10);
cout << "排序後：\n";
for (i = 1; i <=n; i++)
cout << a[i] << " ";
return 0;
}

6.希爾排序
思想：先取一個小於n的整數d1作爲第一個增量，把文件的全部記錄分成d1個組。所有距離爲d1的倍數的記錄放///在同一個組中。先在各組內進行直接插入排序；然後，取第二個增量d2<d1重複上述的分組和排序，直至所取的增量dt=1(dt<dt-l<…<d2<d1)，即所有記錄放在同一組中進行直接插入排序爲止。