幾種常見的排序（比較）
氣泡排序
這裡就按照下面的兩步模擬氣泡排序： 後面的類似，就不展示。
Code:
#include <iostream>
using namespace std;
const int ARRAY_SIZE = 10;
int BubbleSort(int a[], int size)
{
for(int i=0; i<size; i++)
for(int j=0; j<size - i - 1; j++) // 下面每一次迴圈少1
if(a[j] > a[j + 1])
{
int tmp = a[j];
a[j] = a[j + 1];
a[j + 1] = tmp;
}
}
int main()
{
int arr[ARRAY_SIZE] = {49,38,65,1,2,97,76,13,27,49};
BubbleSort(arr, ARRAY_SIZE);
for(int i=0; i<ARRAY_SIZE; i++)
{
cout<< arr[i] << ' ';
}
return 0;
}
選擇排序
選擇排序演算法是每次選擇最小的元素和交換元素來達到排序目的，主要的排序流程：
（1）從原始陣列中選最小的元素，將其和位於第1個位置的元素交換。
（2）接著從剩下的n-1個資料中選擇次小的1個元素，將其和第2個位置的資料交換
（3）然後，這樣不斷重複，直到最後兩個資料完成交換。最後，便完成了對原始陣列的從小到大的排序。
Code
#include <iostream>
using namespace std;
const int ARRAY_SIZE = 10;
void SelectSort(int a[], int size)
{
for (int i = 0; i < size; i++) {
int idx = i;
for (int j = i; j < size; j++)
if (a[idx] > a[j]) idx = j;
if (idx != i) swap(a[i], a[idx]);
}
}
int main()
{
int arr[ARRAY_SIZE] = {49,38,65,1,2,97,76,13,27,49};
SelectSort(arr, ARRAY_SIZE);
for(int i=0; i<ARRAY_SIZE; i++)
{
cout<< arr[i] << ' ';
}
return 0;
}
插入排序
**插入排序的關鍵點：
（1）前面的是已經排好序的陣列， 最後一個數字是待插入的資料。
（2）將待插入的資料插入到前面正確的位置**
Code:
#include <iostream>
using namespace std;
const int ARRAY_SIZE = 10;
void InsertSort(int a[], int size)
{
for (int i = 0; i < size; i++)
for (int j = i; j > 0; j--)
if (a[j] < a[j-1])
swap(a[j], a[j - 1]);
}
int main()
{
int arr[ARRAY_SIZE] = {49,38,65,1,2,97,76,13,27,49};
InsertSort(arr, ARRAY_SIZE);
for(int i=0; i<ARRAY_SIZE; i++)
{
cout<< arr[i] << ' ';
}
return 0;
}
希爾排序
希爾排序 通常也被叫做三個for，一個if。 但是時間複雜度並不是 O（n^3），不清楚的可以看上面。
希爾排序主要的是對待排序陣列進行分組， 然後將組間距一步一步縮小，達到最後一步為1，就完成排序。
Code
void ShellSort(int a[], int size)
{
for(int gap = size/2; gap >=1; gap /= 2)
for(int i = gap; i<size; i++)
for(int j = i - gap; j>=0; j -= gap)
if(a[j] > a[i]) // 小的在前面才交換
swap(a[i], a[j]);
}
快速排序
利用雙指標演算法，進行的快速排序。
原理：
- 先找一個哨兵， 然後利用左指標，發現如果比它小的，直接向後移動指標；
- 如果發現比哨兵大的元素， 交換位置， 然後在跟右指標元素比較，
- 如果發現右指標的元素大的，右指標向前移動，如果小於哨兵，交換位置，在跟左指標比較
- 重複上面的操作，知道左右指標重合。
- 然後將哨兵左邊的元素和右邊的元素進行上面的操操作即可。
Code
#include <iostream>
using namespace std;
const int N = 100010;
int f[N];
int n;
void quick_sort(int q[], int l, int r)
{
int i = l-1, j=r+1, x = q[l+r>>1];
if (l >= r) return ;
while(i<j)
{
do i++; while(q[i] < x);
do j--; while(q[j] > x);
if(i < j) swap(q[i], q[j]);
}
quick_sort(q,l,j);
quick_sort(q,j+1,r);
}
int main()
{
cin >> n;
for(int i=0; i<n; i++) cin >> f[i];
quick_sort(f, 0, n-1);
for(int i=0; i<n; i++) cout << f[i] << " ";
return 0;
}
歸併排序
歸併相對比上面的快排， 類似將分治寫在前面了。
Code
#include <iostream>
using namespace std;
const int N = 100010;
int q[N], tmp[N];
int n;
void merge_sort(int q[], int l, int r)
{
if(l >= r) return ;
int mid = l + r >> 1;
merge_sort(q, l, mid), merge_sort(q, mid + 1, r);
int k = 0, i = l ,j = mid + 1;
while(i <= mid && j <= r)
{
if(q[i] <= q[j]) tmp[k++] = q[i++];
else tmp[k++] = q[j++];
}
while(i <= mid) tmp[k++] = q[i++];
while(j <= r) tmp[k++] = q[j++];
for(int i=l,j=0; i<=r; i++) q[i] = tmp[j++];
}
int main()
{
cin >> n;
for(int i=0; i<n; i++) cin >> q[i];
merge_sort(q, 0, n-1);
for(int i=0; i<n; i++) cout << q[i] << ' ';
return 0;
}
堆排序
堆：完全二叉樹 + 滿足某種條件（小根堆： 父親結點比左右兒子小，大根堆： 父親結點比左右兒子大）
堆和佇列有相似地方，在堆底插入元素，在堆頂取出元素，但是堆中元素的排列不是按照到來的先後順序，而是按照一定的優先順序排列的
下面講解小根堆：
root節點是最小的 == 堆頂是最小的元素。 每個點都滿足小於左右兩個節點的值。
我們想要的堆最好擁有下面幾個功能。
-
插入一個數
-
求集合中的最小值
-
刪除最小值
-
刪除集合中任意一個數
-
修改集合中任意一個數
C++ 中的STL中的priority_queue已經有功能 1,2,3
思考：
如何儲存堆？
- 使用一維陣列，下標存1到n （這樣可以根據資料關係找左右兒子）
- 根結點下標index為1 （不建議從0開始）
- x的左兒子下標為2x
- x的右兒子下標為2x+1
有了上面的思考，我們定義一個down 操作（向下移）和up操作（向上移）， 基本就可以完成上面幾種操作。 上面的down 操作和up操作都和樹的高度成正比， 因此時間複雜度是O（logn）的。
有了上面的思路: 我們看上面5點，是如何實現的。
cnt 表示堆中元素的個數
-
插入一個數 heap[++ cnt ] = x; up (cnt); // 將插入的最後一個元素上移
-
求集合中的最小值 heap[1]
-
刪除最小值 heap[1] = heap[cnt] ; cnt -- ; down(1);
-
刪除集合中任意一個數 heap[k] = heap[cnt] ; cnt -- ; down(k), up(k);
-
修改集合中任意一個數 heap[k] = x; down(k), up(k);
問題：
為什麼從1 開始？
因為從0 開始，陣列就不滿足左右兒子中的數學公式性質了， 當x = 0， 的話左兒子按照數學公式算的話，就是本身了，這個不符合情況。所以陣列下標從1 開始。
為什麼刪除元素需要 將尾節點 覆蓋頭結點呢？
因為一維陣列中，刪除頭結點非常困難，刪除尾節點的話， 十分容易，利用這性質，我們只需要尾節點覆蓋頭節點後，向下進行diwn操作就可以了。
Code:
我們在排序過程中可以看上面不需要進行up操作， 在下面的我給出將陣列進行排序，並輸出前m小的元素。
#include <iostream>
using namespace std;
const int N = 100010;
int n,m;
int h[N], cnt;
void down(int u)
{
int t = u; // 用t儲存 最小的數字
if(u * 2 <= cnt && h[u * 2] < h[t]) t = u * 2; // 保證左兒子存在， 並且左兒子小於父親
if(u *2 + 1<= cnt && h[u * 2 + 1] < h[t] ) t = u * 2 + 1; // 保證右兒子存在， 並且右兒子小於當前的小的點
if(u != t) // 說明根節點不是最小值， 需要交換
{
swap(h[t], h[u]); // 交換使得最小值在上面
down(t);
}
}
int main()
{
cin >> n >> m;
for(int i = 1; i<=n; i++) cin >> h[i];
cnt = n;
for(int i = n/2; i; i--) down(i); // 初始化堆，從n / 2開始
while(m--) // 取出前m個小的數字
{
cout << h[1] << ' '; // 取出小根堆的最小數字
h[1] = h[cnt]; // 將堆底元素（最後一個）放在第一位置
cnt --; // 總的個數 - 1
down(1); // 向下調整堆，維護使得最上面元素是最小的元素
}
return 0;
}
kmp演算法
在面試中的應用
暴力做法
首先我們思考暴力做法的是如何的？
思路： 我們在長的字串中從前往後遍歷的，然後在短的字串中從前往後遍歷，逐個比較，這樣就可以找出在長串中是否包含子串了。
Code
這裡的時間複雜度就為 O（n*m）了
// s[N] 長串
// p[M] 短串
for(int i = 1; i <= n; i++) {
bool flag = true;
for(int j = 1; j <= m；j++)
if(s[i+j-1] != p[j])
{
flag = false;
break;
}
}
優化做法 ： KMP 演算法
kmp演算法就是三位大牛級別的人針對上面的演算法做的一個優化，將時間複雜度轉換為了O(n + m).
下面是kmp 的基本比較思路。
kmp 中 next陣列的一個重要的理解點
next 陣列是關鍵；
先看下面的這個 字首和字尾的定義:
在下面給大家看看 next資料表示的字串的陣列裡面的值的例子：
下面是手繪的，自己定義 比較字串 s[i] 和 p[j + 1] .如果不同的話， j應該移動到哪。
Code
kmp 匹配過程程式碼
#include <iostream>
using namespace std;
const int N = 10010, M = 100010;
int n,m;
char s[M], p[N]; // s大串， p 小串
int ne[N]; // 小串的next陣列
int main()
{
cin >> n >> p+1 >> m >> s + 1;
// kmp 匹配過程 i從大串1 開始， j從0開始， 比較i 和 j + 1
for(int i= 1,j = 0; i<=m; i++)
{
// 表示j 沒有退回起點， 如果s的i個位置和p的j+1位置不匹配 ，直接進行ne陣列調到指定位置
while(j && s[i] != p[j + 1]) j = ne[j];
if(s[i] == p[j+1] ) j++; // 如果匹配， j就向後移動
if(j == n)
{
// 匹配成功
}
}
return 0;
}
kmp next 陣列構造過程
// next 從2開始， 1如果失敗了，直接從0開始算。
for(int i = 2, j = 0; i<=n; i++) // 因為p陣列都是從1開始賦值的 這裡的i = 1
{
while(j && p[j+1] != p[i]) j = ne[j]; // 這裡的j > 0, 如果不滿足相等， 就需要跳
if(p[i] == p[j + 1] ) j++;
ne[i] = j;
}
全部程式碼
輸入樣例：
3
aba
5
ababa
輸出樣例：
0 2
#include <iostream>
using namespace std;
const int N = 10010, M = 100010;
int n,m;
char s[M], p[N]; // s大串， p 小串
int ne[N]; // 小串的next陣列
int main()
{
cin >> n >> p+1 >> m >> s + 1;
// next陣列構造過程
/*
P = abababab ne陣列中的值表示最大公共元素的長度
ne[0] = -1
ne[1] = 0 a
ne[2] = 0 ab
ne[3] = 1 aba a = a(字首 = 字尾)
ne[4] = 2 abab ab = ab
ne[5] = 3 ababa aba = aba
ne[6] = 4 ababab abab = abab
ne[7] = 5 abababa ababa = ababa
ne[8] = 6 abababab ababab = ababab
*/
// next 從2開始， 1如果失敗了，直接從0開始算。
for(int i = 2, j = 0; i<=n; i++) // 因為p陣列都是從1開始賦值的 這裡的i = 1
{
while(j && p[j+1] != p[i]) j = ne[j]; // 這裡的j > 0, 如果不滿足相等， 就需要跳
if(p[i] == p[j + 1] ) j++;
ne[i] = j;
}
// 匹配過程
for(int i= 1,j = 0; i<=m; i++)
{
// 表示j 沒有退回起點， 如果s的i個位置和p的j+1位置不匹配 ，直接進行ne陣列調到指定位置
while(j && s[i] != p[j + 1]) j = ne[j];
if(s[i] == p[j+1] ) j++;
if(j == n)
{
// 匹配成功
printf("%d ", i - n);//我們按照座標從1開始的，但題目中的是從0開始的， 這裡有一個減1 和+1 相抵消
j = ne[j]; // 輸出所有可能匹配的位置， 所以匹配好了需要繼續向右比較
}
}
return 0;
}
程式碼中的 s[i] != p[j + 1] 後的轉移思路。
