#include <vector>
#include <iostream>
using namespace std;
vector<vector<int>> test_dat = {
{ 9, 9, 2, 41, 4, 6, 7, 4, 1, 0 },
{123, 3213, 412, 4, 456, 6, 113, 87, 85},
{1, 3, 4, 5, 6, 12, 12, 34, 100},
{12, 65, 65, 12,95, 78, 13, 52, 53},
{98, 72, 85, 654, 83, 16, 48, 45, 43, 76, 214}
};
//======================================= 插入类排序 =============================
void insertSort(vector<int> &a) {
int n = a.size();
for (int i = 1; i < n; ++i) {
int j = 0;
for (; j < i; ++j) {
if (a[i] < a[j]) {
break;
}
}
if (j != i) {
int k = a[i];
for (int l = i; l > j; --l) {
a[l] = a[l - 1];
}
a[j] = k;
}
}
}
//折半查找
void insertSort2(vector<int> &a) {
int n = a.size();
for (int i = 1; i < n; ++i) {
int j = 0;
int begin = 0, end = i - 1, mid = begin + (end - begin) / 2;
while (end > begin)
{
if (end - begin == 1)
break;
if (a[i] < a[mid]) {
end = mid;
}
else {
begin = mid;
}
mid = begin + (end - begin) / 2;
}
if (a[i] >= a[end]) {
j = end + 1;
}
else if (a[i] < a[begin]) {
j = begin;
}
else if (a[i] < a[end]) {
j = end;
}
if (j != i) {
int k = a[i];
for (int l = i; l > j; --l) {
a[l] = a[l - 1];
}
a[j] = k;
}
}
}
//希尔排序
void shell(vector<int> &a) {
int gap = a.size() / 2;
int n = a.size();
while (gap >= 1) {
for (int i = gap; i < n; i = i + gap ) {
int temp = a[i];
int j = i;
while (j - gap >= 0 && temp < a[j - gap]) {
a[j] = a[j - gap];
j = j - gap;
}
a[j] = temp;
}
gap = gap / 2;
}
}
//============================================================================================
//======================================= 交换类排序 ========================================
//冒泡排序
void bubble(vector<int> &a) {
int flag = 0, n = a.size();
for (int i = 0; i < n; ++i) {
for (int j = n - 1; j > i; j--) {
if (a[j] < a[j - 1]) {
int temp = a[j];
a[j] = a[j - 1];
a[j - 1] = temp;
flag = 1;
}
}
if (flag == 0) break;
}
}
//快速排序
void quick_sort(vector<int> &a, int begin, int end) {
int x = a[begin];
int i = begin, j = end;
while (j > i) {
while (j > i && a[j] >= x) j--;
if (j > i) {
int temp = a[i]; a[i++] = a[j]; a[j] = temp;
}
while (j > i && a[i] <= x) i++;
if (j > i) {
int temp = a[j]; a[j--] = a[i]; a[i] = temp;
}
}
a[i] = x;
if(i - 1 > begin) quick_sort(a, begin, i - 1);
if(i + 1 < end) quick_sort(a, i + 1, end);
}
//=================================== 交换类排序 ==============================
void chooseSort(vector<int> &a) {
int n = a.size();
for (int i = 0; i < n; ++i) {
int min = i;
for (int j = i + 1; j < n; ++j) {
if (a[j] < a[min]) {
min = j;
}
}
if (min != i) {
int temp = a[i]; a[i] = a[min]; a[min] = temp;
}
}
}
void heapSort(vector<int> &a) {
int n = a.size();
int p = n / 2 - 1, index = n - 1;
while (p > 0) {
for (int i = p; i >= 0; --i) {
if (2 * i + 1 <= index && a[i] < a[2 * i + 1]) {
int temp = a[2 * i + 1]; a[2 * i + 1] = a[i]; a[i] = temp;
}
if (2 * i + 2 <= index && a[i] < a[2 * i + 2]) {
int temp = a[2 * i + 2]; a[2 * i + 2] = a[i]; a[i] = temp;
}
}
p = index / 2 - 1;
int temp = a[0]; a[0] = a[index]; a[index--] = temp;
}
}
//=================================== 基数排序
void bucketSort(vector<int> &a) {
vector<int> bucket[10];
int n = a.size();
int flag = 0, dev = 1;
do
{
flag = 0;
//入桶
for (int i = 0; i < n; i++) {
if (a[i] >= dev) {
bucket[ a[i] / dev % 10 ].push_back(a[i]);
flag = 1;
}
else {
bucket[0].push_back(a[i]);
}
}
//出桶
int k = 0;
for (int i = 0; i < 10; ++i) {
for (int j = 0; j < bucket[i].size(); ++j) {
a[k++] = bucket[i][j];
}
bucket[i].clear();
}
dev = dev * 10;
} while (flag);
}
//归并排序
void mergeSort(vector<int> &nums, int begin, int end) {
if (end <= begin)
return;
int mid = begin + (end - begin) / 2;
mergeSort(nums,begin, mid);
mergeSort(nums, mid + 1, end);
vector<int> temps(end - begin + 1);
int i = begin, j = mid + 1, p = 0;
while (i <= mid && j <= end){
temps[p++] = nums[i] < nums[j] ? nums[i++] : nums[j++];
}
while(i <= mid) {
temps[p++] = nums[i++];
}
while(j <= end) {
temps[p++] = nums[j++];
}
p = 0;
for (int i = begin; i <= end; ++i) {
nums[i] = temps[p++];
}
}
vector<int> sortArray(vector<int>& nums) {
mergeSort(nums, 0, nums.size() -1);
return nums;
}
//============================归并 end =====================
void print_vec(vector<int> &a) {
for (int i = 0; i < a.size(); ++i) {
cout << a[i] << " " << ends;
}
cout << endl;
}
void test_sort() {
for (int i = 0; i < test_dat.size(); ++i) {
//insertSort2(test_dat[i]);
//shell(test_dat[i]);
//bubble(test_dat[i]);
//quick_sort(test_dat[i], 0, test_dat[i].size() - 1);
//chooseSort(test_dat[i]);
//heapSort(test_dat[i]);
bucketSort(test_dat[i]);
print_vec(test_dat[i]);
}
return;
}
十大排序
最新推荐文章于 2023-12-26 21:28:09 发布