HDU-1040-As Easy As A+B(各种排序)
- 希尔排序
Accepted 1040 0MS 1224K 564 B G++ #include "cstdio" using namespace std; int arr[5000]; int main() { int t, n; scanf("%d", &t); while (t--) { scanf("%d", &n); for (int i = 0; i < n; i++) { scanf("%d", &arr[i]); } // 一开始将增量设置为n的一半,将n个数分成n/2份进行插排，每份大概只有两个数，每次增量减半 for (int i = n >> 1; i > 0; i >>= 1) { for (int j = i; j < n; j++) { int u = arr[j]; int id = j - i; while (id >= 0 && arr[id] > u) { arr[id + i] = arr[id]; id -= i; } arr[id + i] = u; } } printf("%d", arr[0]); for (int i = 1; i < n; i++) { printf(" %d", arr[i]); } puts(""); } return 0; }
希尔排序是优化版的插入排序。
- 快速排序
Accepted 1040 0MS 1372K 1736 B G++ #include "bits/stdc++.h" using namespace std; typedef long long LL; const int INF = 0x3f3f3f3f; int arr[1005]; void quickSort(int l, int r) { /* 注意一种错误写法：if (l == r) 在排序9 8这样的数据时会造成无限循环 */ if (l >= r) { return; } int mid = l + r >> 1, id; // 找arr[l]、arr[r]、arr[mid]三个点中的中位数 if (arr[l] <= arr[mid] && arr[l] <= arr[r]) { id = arr[mid] <= arr[r] ? mid : r; } else { if (arr[mid] <= arr[r]) { id = arr[l] <= arr[r] ? l : r; } else { id = arr[l] <= arr[mid] ? l : mid; } } // 将找到的中位数放在待排序数组的最左端 swap(arr[l], arr[id]); int le = l + 1, gt = r; // 在下面的循环过程中，arr[l + 1]到arr[le]小于等于arr[l],arr[gt]到arr[r]大于arr[l]; while (le < gt) { if (arr[le] <= arr[l]) { le++; } else if (arr[gt] <= arr[l]){ swap(arr[le], arr[gt]); le++; gt--; } else { while (arr[gt] > arr[l] && le < gt) { gt--; } } } if (arr[le] > arr[l]) { le--; } swap(arr[le], arr[l]); /* 注意一个错误写法：quickSort(l, le); 在排序如4 0 2 4这样的数据时会造成无限循环 */ quickSort(l, le - 1); quickSort(le + 1, r); } int main() { int t, n; scanf("%d", &t); while (t--) { scanf("%d", &n); for (int i = 1; i <= n; i++) { scanf("%d", &arr[i]); } quickSort(1, n); for (int i = 1; i < n; i++) { printf("%d ", arr[i]); } printf("%d\n", arr[n]); } return 0; }
这是最常用的一种排序方式，Java里面的Array.sort用的就是这种方式进行排序的，还有就是之前一直说这种排序方式的复杂度为nlogn，但是要注意nlgn是最好情况。一般达不到的，在排序个数小于等于8时用n^2复杂度的插入排序反而更快，所以quickSort函数里还可以进行一个判断if (r - l + 1 <= 8){插排}来进行优化。
- 插入排序
Accepted 1040 0MS 1380K 705 B G++ #include "bits/stdc++.h" using namespace std; typedef long long LL; const int INF = 0x3f3f3f3f; int arr[1005]; int main() { int t, n; scanf("%d", &t); while (t--) { scanf("%d", &n); for (int i = 0; i < n; i++) { scanf("%d", &arr[i]); } for (int i = 1; i < n; i++) { int temp = arr[i], j = i - 1; while (j >= 0 && arr[j] > temp) { arr[j + 1] = arr[j]; j--; } arr[j + 1] = temp; } printf("%d", arr[0]); for (int i = 1; i < n; i++) { printf(" %d", arr[i]); } puts(""); } return 0; }
就是让arr[0]到arr[i - 1]保持有序之后把arr[i]插入到前面的有序数列中去从而使arr[0]到arr[i]有序,逆序转正序的情况下复杂度最高，算法复杂度为O(N^2);
- 归并排序
Accepted 1040 0MS 1376K 1270B G++ #include "bits/stdc++.h" using namespace std; typedef long long LL; const int INF = 0x3f3f3f3f; int arr[1005], help[1005]; void mergeSort(int l, int r) { if (l >= r) { return; } int mid = l + r >> 1; // 递归排序l到mid和mid + 1到r mergeSort(l, mid); mergeSort(mid + 1, r); // 将l到r拷贝到help数组对应位置,此时可将help[l]到help[mid]看成一个数组，help[mid + 1]到help[r]看成另一个数组 memmove(help + l, arr + l, sizeof(int) * (r - l + 1)); int L = l, R = mid + 1, id = l; // 每次取出help[L]和help[R]中值小的填入arr[id]直到一边被取完为止 while (L <= mid && R <= r) { if (help[L] <= help[R]) { arr[id++] = help[L++]; } else { arr[id++] = help[R++]; } } // 如果被取完的是help[l]，那么help[R]后面的数已经存在于arr中对应位置不用移动，否则将help[L]后面的数移到arr数组后面； while (L <= mid) { arr[id++] = help[L++]; } } int main() { int t, n; scanf("%d", &t); while (t--) { scanf("%d", &n); for (int i = 1; i <= n; i++) { scanf("%d", &arr[i]); } mergeSort(1, n); for (int i = 1; i < n; i++) { printf("%d ", arr[i]); } printf("%d\n", arr[n]); } return 0; }
和快速排序一样是O(nlogn)的排序方法，这个方法需要借助辅助空间。
- 堆排序
Accepted 1040 0MS 1372K 1117 B G++ #include "bits/stdc++.h" using namespace std; typedef long long LL; typedef pair<int, int> PII; const int INF = 0x3f3f3f3f; int arr[1005], m; void maxHeapFix(int id) { // mx存左右儿子中比较大的，一开始假设左儿子比右儿子大 int mx = id << 1; // 如果左儿子越界，右儿子肯定越界，id为叶子节点，直接返回 if (mx > m) { return; } // 否则如果右儿子没越界并且右儿子大于左儿子，则mx = 右儿子 if (mx < m && arr[mx | 1] > arr[mx]) { mx |= 1; } if (arr[mx] > arr[id]) { swap(arr[mx], arr[id]); maxHeapFix(mx); } } int main() { int t, n; scanf("%d", &t); while (t--) { scanf("%d", &n); for (int i = 1; i <= n; i++) { scanf("%d", &arr[i]); } m = n; for (int i = n >> 1; i; i--) { maxHeapFix(i); } while (m != 1) { swap(arr[1], arr[m--]); maxHeapFix(1); } for (int i = 1; i < n; i++) { printf("%d ", arr[i]); } printf("%d\n", arr[n]); } return 0; }
就是不断维护大顶堆，大顶堆的堆顶是堆中最大，和最后一个元素交换后将堆的大小减1后继续维护大顶堆，复杂度O(nlgn)
- 基数排序
Accepted 1040 0MS 1416K 1160 B G++ #include "bits/stdc++.h" using namespace std; typedef long long LL; const int INF = 0x3f3f3f3f; // 选取基数,不一定非要选10 const int BASE = 10; vector<int> arr; // 因为涉及负数排序，bucket开基数的两倍，前一半用来存负数 vector<int> bucket[BASE << 1]; int main() { int t, n , m; scanf("%d", &t); while (t--) { arr.clear(); scanf("%d", &n); for (int i = 0; i < n; i++) { scanf("%d", &m); arr.push_back(m); } // 因为int中绝对值最大为 1LL << 31, 所以上限设为1LL << 31 for (LL bit = 1; bit <= 1LL << 31; bit *= BASE) { for (int i : arr) { // 这里可以想象成进制转换，将i转换成BASE进制后求某一位 bucket[i / bit % BASE + BASE].push_back(i); } arr.clear(); for (int i = 1; i < BASE << 1; i++) { arr.insert(arr.end(), bucket[i].begin(), bucket[i].end()); bucket[i].clear(); } } printf("%d", arr[0]); for (int i = 1; i < n; i++) { printf(" %d", arr[i]); } puts(""); } return 0; }
基数排序原理有点像字典序，从右边往左一遍遍扫描，高位补0。其时间复杂度为O (nlog(r)m)，其中r为所采取的基数，而m为堆数。
- 桶排序
Accepted 1040 0MS 1412K 1142 B G++ #include "bits/stdc++.h" using namespace std; typedef long long LL; const int INF = 0x3f3f3f3f; int t, n, m; vector<int> bucket[1005]; int getHash(LL m) { // 减INT_MIN的作用是保证m为非负数，减完后的最大值为(1LL << 32) - 1,为保证哈希值在[0,n)的范围内除1LL << 32 return (m - INT_MIN) * n / (1LL << 32); } void insert(int id, int m) { int j = bucket[id].size(); bucket[id].push_back(m); while (j > 0 && bucket[id][j - 1] > m) { bucket[id][j] = bucket[id][j - 1]; j--; } bucket[id][j] = m; } int main() { scanf("%d", &t); while (t--) { scanf("%d", &n); for (int i = 0; i < n; i++) { scanf("%d", &m); insert(getHash(m), m); } bool flag = true; for (int i = 0; i < n; i++) { for (auto j : bucket[i]) { if (flag) { printf("%d", j); flag = false; } else { printf(" %d", j); } } bucket[i].clear(); } puts(""); } return 0; }
桶排序的适用范围是数据平均分布的情况，这种情况下复杂度很低可达到O(N),所以考虑在一个桶内的数不会太多，用插入排序。但是分布极不均匀的情况下（所有数据在一个桶中）将退化成插入排序；
