- #include <iostream>
- using namespace std;
- // 插入排序開始=====================
- void insert_sort(int a[], int n)
- {
- for (int cur = 1; cur < n; ++cur)
- {
- int j = cur - 1;
- int t = a[cur];
- while (j >= 0)
- {
- if (a[j] > t)
- a[j+1] = a[j];
- else
- break;
- --j;
- }
- a[j+1] = t;
- }
- }
- // 插入排序結束=====================
- // 選擇排序開始=====================
- void select_sort(int a[], int n)
- {
- for (int i = 0; i < n - 1; ++i)
- {
- int k = i;
- for (int j = i + 1; j < n; ++j)
- if (a[j] < a[k])
- k = j;
- swap(a[i], a[k]);
- }
- }
- // 選擇排序結束=====================
- // 冒泡排序開始=====================
- void buble_sort(int a[], int n)
- {
- for (int k = 1; k <= n - 1; ++k)
- {
- int noswap = 1; //表示這一次沒有交換
- for (int j = n - 1; j >= k; --j)
- if (a[j] < a[j-1])
- {
- swap(a[j], a[j-1]);
- noswap = 0;
- }
- if (noswap) break;
- }
- }
- // 冒泡排序結束=====================
- // 快速排序開始=====================
- int quick_sort_partion(int a[], int p, int q)
- {
- int i = p - 1;
- for (int j = p; j <= q - 1; ++j)
- {
- if (a[j] < a[q])
- swap(a[j], a[++i]);
- }
- swap(a[++i], a[q]);
- return i;
- }
- void quick_sort_helper(int a[], int b, int e)
- {
- if (b < e)
- {
- int mid = quick_sort_partion(a, b, e);
- quick_sort_helper(a, b, mid - 1);
- quick_sort_helper(a, mid + 1, e);
- }
- }
- void quick_sort(int a[], int n)
- {
- quick_sort_helper(a, 0, n-1);
- }
- // 快速排序結束=====================
- // 歸併排序開始=====================
- void merge_sort_helper(int a[], int copy[], int b, int e)
- {
- if (b < e)
- {
- int mid = (e-b) / 2 + b;
- merge_sort_helper(copy, a, b, mid);
- merge_sort_helper(copy, a, mid + 1, e);
- int i = b, j = mid + 1, k = b;
- while (i <= mid && j <= e)
- {
- a[k++] = (copy[i] < copy[j] ? copy[i++] : copy[j++]);
- }
- while (i <= mid)
- a[k++] = copy[i++];
- while (j <= e)
- a[k++] = copy[j++];
- }
- }
- void merge_sort(int a[], int n)
- {
- int *copy = new int[n];
- memcpy(copy, a, sizeof(a[0])*n);
- merge_sort_helper(a, copy, 0, n-1);
- delete[] copy;
- }
- // 歸併排序結束=====================
- // 堆排序開始=======================
- void heap_sort_adjust(int a[], int n, int i)
- {
- if (i <= n/2 - 1) //判斷是否是葉子結點
- {
- int left = 2*i+1;
- int right = 2*i+2;
- int maxIndex = i;
- if (a[left] > a[maxIndex])
- maxIndex = left;
- if (right < n && a[right] > a[maxIndex])
- maxIndex = right;
- swap(a[i], a[maxIndex]);
- if (i != maxIndex) //一定要判斷,否則死循環
- heap_sort_adjust(a, n, maxIndex);
- }
- }
- void heap_sort_build(int a[], int n)
- {
- for (int i = n/2 -1; i >= 0; --i)
- heap_sort_adjust(a, n, i);
- }
- void heap_sort(int a[], int n)
- {
- heap_sort_build(a, n);
- for (int i = n-1; i >= 1; --i)
- {
- swap(a[i], a[0]);
- heap_sort_build(a, i);
- }
- }
- // 堆排序結束=======================
- // 希爾排序開始=====================
- void shell_sort(int a[], int n)
- {
- int d[3] = {5, 3, 1};
- for (int k = 0; k < 3; ++k)
- {
- for (int cur = d[k]; cur < n; cur += d[k])
- {
- int j = cur - d[k];
- int t = a[min(cur, n-1)];
- while (j >= 0)
- {
- if (a[j] > t)
- a[min(j+d[k], n-1)] = a[j];
- else
- break;
- j -= d[k];
- }
- a[min(j+d[k], n-1)] = t;
- }
- }
- }
- // 希爾排序結束=====================
- // 基數排序開始=====================
- //L表示關鍵碼的個數
- void radix_sort(int a[], int n, int L)
- {
- int *bucket = new int[n];
- int count[10];
- int power = 1;
- for (int k = 1; k <= L; ++k)
- {
- memset(count, 0, sizeof(count[0]) * n);
- //統計每個桶的右邊界
- for (int i = 0; i < n; ++i) ++count[(a[i]/power)%10];
- for (int i = 1; i < 10; ++i) count[i] += count[i-1];
- //裝桶,這裏從後往前掃描是因爲邊界值是從右往左遞減的
- for (int i = n-1; i >= 0; --i) bucket[--count[(a[i]/power)%10]] = a[i];
- //收集
- memcpy(a, bucket, sizeof(a[0]) * n);
- power *= 10;
- }
- delete bucket;
- }
- // 基數排序結束=====================
- int main()
- {
- int a[10]={100,19,222,10,37,83,36,344,576,82};
- radix_sort(a, 10, 3);
- for (int i = 0; i < 10; ++i)
- cout << a[i] << " ";
- cout << endl;
- return 0;
- }
最後,貼出幾大排序的平均時間複雜度和最壞時間複雜度,以供參考
關於排序的穩定性
穩定的排序有
插入排序:(每次插入都是從後往前,兩個數一樣的話不會交換位置)
冒泡排序:(每次冒上去的都是最小的,兩個數相同不會交換)
歸併排序:(如果兩個相等的數在同一個區間,顯然後面的數不會跑到前面去,如果在不同的區間,後半個區間在歸併後顯然也是排在後面,可對照上面的代碼)
基數排序:(兩個數相同,如果從左到右掃描,那麼前面的數肯定先被扔進桶內,如果從右往左掃描,那麼先將右邊的數扔到桶的後面,上面排序過程即是如此)
如果記不住的話,那麼鬼插雞毛,還記得住啊?記住,鬼插雞毛很穩定哦,其他的都不穩定
鬼:歸併排序,插:插入排序,雞:基數排序,毛:冒泡排序
來,和我一起讀,鬼插雞毛很穩定,鬼插雞毛很穩定,鬼插雞毛很穩定……讀個99遍
關於時間複雜度,除了快速排序,其他排序的最低時間複雜度和最壞時間複雜度相同,因爲逆序的數組每次劃分都需要O(i)(i = n, n-1,...)的時間,所以快速排序最壞爲O(n^2)
轉自 http://blog.csdn.net/shen823797837/article/details/11810293