八大排序算法

#include <iostream>
#include <algorithm>
#include <vector>
#include <ctime>
#include <random>
#include <string>
using namespace std;

// test 打印数组
void test_print_array(vector<int>& src, int left, int right)
{
for (int i = left; i <= right; i++)
{
cout << "x[" << i << "]:" << src[i] << " ";
}

cout << endl;
}

// 打印数组
void print_array(string content,vector<int>& src)
{
cout << content << endl;
for (auto v : src)
{
cout << v << " ";
}

cout << endl;
}

// 利用随机数创建数组
void create_array(vector<int>& src)
{
src.clear();
default_random_engine e(static_cast<int>(time(0))); // 稍微随机些的种子
const int num = 23;
for (size_t i = 0; i < num; i++)
{
// e() “调用”对象来生成下一个随机数
int k = e() % 23;
src.push_back(k);
}

print_array("排序前:", src);
}

 

// 【交换排序】
// 冒泡排序 看j的范围 最好（O(N)）最坏（O(N^2)） 平均（O(N^2)） 辅助存储O(1)
// 前后相等的数据，相对位置不发生变化,所以稳定
void bubble_sort(vector<int>& src)
{
bool sort_flag = false;
size_t index_max = src.size() - 1;

// 使用 < 号，余留最后一位
for (size_t i = 0; i < index_max; ++i)
{
// 后面 i个数已经排好序了
for (size_t j = 0; j < index_max - i; ++j)
{
if (src[j] <= src[j + 1])
{
continue;
}
swap(src[j], src[j+1]);
sort_flag = true;
}
//print_array("-----", src);
// 说明元素已经是排序好的，不需要排序
if (false == sort_flag)
{
break;
}
}
}

// 【交换排序】
// 快速排序 选择基准值，左右递归调用快排
// 最好（O(NlgN)）最坏（O(N^2)） 平均（O(NlgN)） 辅助存储（O(NlgN)）递归的深度，递归的时候使用的栈空间
// 前后相等的数据，相对位置发生变化,所以 不稳定
void quick_sort(vector<int>& src, int left, int right)
{
if (left >= right)
{
return;
}
int base = src[left];
int left_i = left;
int right_i = right;

// 交换数据
while (right_i > left_i)
{
while (right_i > left_i && src[right_i] > base)
{
right_i--;
}

while (right_i > left_i && src[left_i] <= base)
{
left_i++;
}

if (right_i > left_i)
{
swap(src[right_i], src[left_i]);
}

}

// 将基准值留在内部中的某一个位置
swap(src[left], src[left_i]);

// 分别递归左右两侧数据
// left_i 的基准值的位置，该位置是不变了，这里不再参与排序，否则死循环，栈溢出
quick_sort(src, left, left_i-1);
quick_sort(src, left_i + 1, right);
}

// 【插入排序】
// 直接插入
// 最好（O(N)）最坏（O(N^2)） 平均（O(N^2)） 辅助存储（O(1)）不需要递归
// 前后相等的数据，相对位置不发生变化,所以 稳定
// 与冒泡的区别，冒泡是后面排好序，插入是前面排好序
void insert_sort(vector<int>& src)
{
//bool sort_flag = false;
int index_max = src.size() - 1;

// 从第二个元素开始
for (int i = 1; i <= index_max; ++i)
{
// 前面 i - 1 个数已经排好序了
int j = i - 1;
int v = src[i]; // 注意点
for (; j >= 0; --j)
{
if (src[j] < v)
{
break;
}
// 逐渐替换
src[j + 1] = src[j];
}

// 未移动数据，不进行自己给自己赋值
if (j < i - 1)
{
src[j + 1] = v;
}
}
}

 

 

// 【插入排序】
// 折半插入
// 最好（O(N)）最坏（O(N^2)） 平均（O(N^2)） 辅助存储（O(1)）不需要递归
// 前后相等的数据，相对位置不发生变化,所以 稳定
// 与直接插入的区别，在前面排好序的数组中，查找数据的位置时,使用折半查找。
void Binsert_sort(vector<int>& src)
{
int index_max = src.size() - 1;

// 从第二个元素开始
for (int i = 1; i <= index_max; ++i)
{
// 前面 i - 1 个数已经排好序了
int v = src[i]; // 注意点

// 使用折半查找，时间复杂度logN
int mid =1,low = 1, high = i - 1;
while (low <= high)
{
mid = (low + high) / 2;
if (v < src[mid])
{
high = mid - 1;
}
else
{
low = mid + 1;
}
}

int j = i - 1;
for (; j >= (high+1); j--)
{
src[j + 1] = src[j];
}

// 未移动数据，不进行自己给自己赋值
if (j < i - 1)
{
src[j + 1] = v;
}
}
}

 

// 【插入排序】
// shell插入
// 最好（O(NlgN)）最坏（O(N^2)） 平均（O(N^1.3)） 辅助存储（O(1)）不需要递归
// 不稳定
// 与 直接插入排序的区别，使用增量间隔进行直接插入排序，本例使用 Hibbard(希巴德)增量,最坏为O(n^3/2)

// 这个函数只是追加步长的 直接插入排序函数
void shell_insert(vector<int>& src, int step)
{
int index_max = src.size() - 1;

// 从第二个元素开始
for (int i = 1; i <= index_max; i += step)
{
// 前面 i - 1 个数已经排好序了
int j = i - step;
int v = src[i]; // 注意点
for (; j >= 0; j-= step)
{
if (src[j] < v)
{
break;
}
// 逐渐替换
src[j + step] = src[j];
}

// 未移动数据，不进行自己给自己赋值
if (j < i - step)
{
src[j + step] = v;
}
}
}

// 【重:】 求一个数的最大幂
int FastLog2(int x)
{
float fx;
unsigned long ix, exp;

fx = (float)x;
ix = *(unsigned long*)&fx;
exp = (ix >> 23) & 0xFF;
return exp - 127;
}

 

void shell_sort(vector<int>& src)
{
int size = (int)src.size();

// 取得Hibbard 增量
vector<int> Hibbard;
int i = 1;
int lm = 1; // 左移位数
while (true)
{
if (i > size)
{
break;
}
Hibbard.push_back(i);
//cout << i << " ";
i = 1 << lm;
lm++;
}
cout << endl;

// 根据Hibbard 进行shell 排序【略】
int step = 1 << FastLog2(size);

while (step >= 1)
{
shell_insert(src, step);
step >>= 1;
}
}

 

// 【选择排序】
// 直接选择排序
// 最好（O(N^2)）最坏（O(N^2)） 平均（O(N^2)） 辅助存储（O(1)）
// 稳定
// 与插入排序比较像,因为扫描索引，即使是已经排好序的数组，也要 for 两次
// 找最小的数放到最前面
void select_sort(vector<int>& src)
{
for (size_t i = 0; i < src.size(); i++)
{
size_t min_max = i;
for (size_t j = i; j < src.size(); j++)
{
if (src[j] < src[min_max])
{
min_max = j;
}
}
if (min_max > i)
{
swap(src[i], src[min_max]);
}
}
}

// 【选择排序】
// 堆排序
// 最好（O(NlgN)）最坏（O(NlgN)） 平均（O(NlgN)） 辅助存储（O(1)）
// 不稳定
// 利用完全二叉树的性质，参照另一篇文章   小顶堆排序

//当列表第一个是以下标0开始，结点下标为i,左孩子则为2*i+1,右孩子下标则为2*i+2,若下标以1开始，左孩子则为2*i,右孩子则为2*i+１
void heapAdjust(vector<int>& src, int root, int right){
int key = src[root];
for (int j = 2 * root + 1; j <= right; j = 2 * j + 1){
if (j < right && src[j] <= src[j + 1]) ++j; // 左右子节点找最大值
if (src[j] <= key) break;
src[root] = src[j]; // 叶节点与左右子节点中最大的进行互换
root = j; // 换掉节点，子树继续调整为大顶堆
}
src[root] = key; // 把节点的值放到合适的叶节点上面
}
// 大顶堆
void heap_sort(vector<int>& src, int size){
//初始建堆,从最后一个非叶子节点开始
for (int i = size / 2 - 1; i >= 0; --i)
{
heapAdjust(src, i, size - 1);
}
//取堆顶，并且调整,把最大值放到堆底，并调整堆
for (int i = size - 1; i > 0; --i){
swap(src[0], src[i]);
heapAdjust(src, 0, i - 1);
}
}

// 【归并排序】
// 最好（O(NlgN)）最坏（O(NlgN)） 平均（O(NlgN)） 辅助存储（O(n)）
// 思想: 分治法
void merge(vector<int>&src, int left, int mid, int right)
{
vector<int> temp;
int i = left;
int j = mid + 1;

while (i <= mid && j <= right)
{
while (i <= mid && j <= right && src[i] <= src[j])
{
temp.push_back(src[i]);
i++;
}

while (i <= mid && j <= right && src[j] < src[i])
{
temp.push_back(src[j]);
j++;
}
}

// 插入剩余数据
while (i <= mid)
{
temp.push_back(src[i]);
i++;
}
while (j <= right)
{
temp.push_back(src[j]);
j++;
}

for (size_t k = 0; k < temp.size(); k++)
{
src[left + k] = temp[k];
}
}

// 归并排序
void merge_sort(vector<int>& src, int left, int right)
{
if (left >= right)
{
return; // 递归退出
}
int mid = (left + right) / 2;
merge_sort(src, left, mid);
merge_sort(src, mid + 1, right);
merge(src, left, mid, right);
}

 

// 2路归并排序【非递归】
void merge_sort(vector<int>& src, int left, int right)
{
size_t step = 2; // 初始步长为2
// 每次倍数增长 2 4 8 ...
for (; step <= right; step *= 2)
{
// 以步长划分出区间，对区间里的数据进行排序合并
for (int start = 0; start <= right; start += step)
{
int current_right = start + step - 1;

// 不能超过最右侧
if (current_right > right)
{
current_right = right;
}
int mid = (start + current_right) / 2;
merge(src, start, mid, current_right);

}
}

// 最后对整体大区间进行排序合并
if (step != right * 2)
{
int mid = step / 2 - 1; // step正好是中间值，
merge(src, left, mid, right);
}
}

 

 

 

 

// 【桶排序】
// 基数排序
// 最好（O(n)）最坏（O(n)） 平均（O(n)） 辅助存储（O(n)）
// 利用集合映射，数组的下标即为值,数组值为该值出现的次数,将数组打印出即可，比如学生的分数统计
void radix_sort(vector<int>& src, vector<int>& dest)
{
//int size = src.size();
const int num = 1000;
int a[num]; memset(a, 0x00, sizeof(a));
for (auto v:src)
{
a[v]++;
}

for (int i = 0; i < num; i++)
{
if (a[i] <= 0)
{
continue;
}

for (int j = 0; j < a[i]; j++)
{
dest.push_back(i);
}
}
}

int main(int argc, char* argv[])
{
string sort_end = "排序后:";
vector<int> data;

// 冒泡排序
create_array(data);
bubble_sort(data);
sort_end = "bubble_sort:";
print_array(sort_end, data);

// 快速排序
create_array(data);
quick_sort(data, 0, (int)(data.size() - 1));
sort_end = "quick_sort:";
print_array(sort_end, data);

// 直接插入排序
create_array(data);
insert_sort(data);
sort_end = "insert_sort:";
print_array(sort_end, data);

// shell排序
create_array(data);
shell_sort(data);
sort_end = "shell_sort:";
print_array(sort_end, data);

// 选择排序
create_array(data);
select_sort(data);
sort_end = "select_sort:";
print_array(sort_end, data);

// 大顶堆排序
create_array(data);
vector<int> data1 = data;
heap_sort(data, data.size());
sort_end = "heap_sort:";
print_array(sort_end, data);

// 归并排序
create_array(data1);
merge_sort(data1, 0, (int)(data.size()-1));
sort_end = "merge_sort:";
print_array(sort_end, data1);

// 基数排序
create_array(data);
vector<int> dest;
radix_sort(data1, dest);
sort_end = "radix_sort:";
print_array(sort_end, dest);

while (true)
{
string i;
cin >> i;
}

return 0;
}