常见排序算法
常见排序算法
编写代码并测试了5种排序算法
有冒泡排序,选择排序,插入排序,堆排序,归并排序.
下面也给出了代码在机器上的运行结果,虽然不同机器结果会不一样,但是仍然能够比较直观地感受到这些算法的区别,以及理论与实现之间的差距.
// sort.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//
#include "pch.h"
#include <iostream>
#include <vector>
#include <limits.h>
#include <time.h>
#include <string>
#include <stack>
#include <algorithm>
using namespace std;
//计时类,调用End将返回经历的秒数
class Timer {
private:
clock_t start;
clock_t finish;
double duration;
public:
Timer() {
start = 0;
finish = 0;
};
void Start() {
start = clock();
}
double End() {
finish = clock();
duration = (double)(finish - start) / CLOCKS_PER_SEC;
start = 0;
finish = 0;
return duration;
}
};
//时间复杂度 平均O(n^2) 最坏(n^2) 最好O(n)
//空间复杂度 O(1)
//稳定性 稳定
namespace bubble_sort {
void sort(vector<int>& v)
{
if (v.size() == 0)return;
for (int j = 0; j < v.size(); j++)
{
for (int i = 0; i < v.size() - 1; i++)
{
if (v[i] > v[j])
{
//swap(i,j)
int tmp = v[j];
v[j] = v[i];
v[i] = tmp;
}
}
}
}
}
//时间复杂度 平均O(n^2) 最坏(n^2) 最好O(n^2)
//空间复杂度 O(1)
//稳定性 不稳定
namespace select_sort {
void sort(vector<int>& v)
{
if (v.size() == 0)return;
for (int j = 0; j < v.size(); j++)
{
int min_pos = j;
for (int i = j; i < v.size(); i++)
{
if (v[i] < v[min_pos]) {
min_pos = i;
}
}
//swap(j,min_pos)
int tmp = v[min_pos];
v[min_pos] = v[j];
v[j] = tmp;
}
}
}
//时间复杂度 平均O(n^2) 最坏(n^2) 最好O(n)
//空间复杂度 O(1)
//稳定性 稳定
namespace insert_sort {
void sort(vector<int>& v)
{
if (v.size() == 0)return;
for (int j = 1; j < v.size(); j++)
{
int i = j;
while (i >= 1 && v[i] < v[i - 1])
{
//swap(i,i-1)
int tmp = v[i - 1];
v[i - 1] = v[i];
v[i] = tmp;
i--;
}
}
}
}
namespace heap_sort_recur {
struct Node {
int val;
Node* lchild;
Node* rchild;
};
Node* head;
int m_i = 0;
vector<int> m_v;
void re_build_heap(Node *node, Node *last_node, int val) {
if (node == NULL) {
Node* new_node = new Node;
new_node->val = val;
new_node->lchild = NULL;
new_node->rchild = NULL;
if (last_node->val > val) {
last_node->lchild = new_node;
}
if (last_node->val <= val) {
last_node->rchild = new_node;
}
return;
}
if (val < node->val)
{
re_build_heap(node->lchild, node, val);
}
if (val >= node->val)
{
re_build_heap(node->rchild, node, val);
}
}
//中序遍历写回vector
void re_write_back(Node* node)
{
if (node->lchild != NULL) {
re_write_back(node->lchild);
}
if (node != NULL)
{
m_v[m_i] = node->val;
m_i++;
}
if (node->rchild != NULL) {
re_write_back(node->rchild);
}
}
void sort(vector<int>& v)
{
if (v.size() == 0)return;
m_v = v;
head = new Node;
head->lchild = NULL;
head->rchild = NULL;
head->val = m_v[0];
for (int i = 1; i < m_v.size(); i++)
{
re_build_heap(head, head, m_v[i]);
}
re_write_back(head);
for (int i = 0; i < v.size(); i++)
{
v[i] = m_v[i];
}
}
}
namespace heap_sort_arr {
vector<int> arr;
void sort(vector<int>& v)
{
/*Build Heap*/
int k = 2;
for (int i = 0; i < v.size(); i++)
{
k *= 2;
}
k--;
arr.resize(k,-1); // 存储树的数组,2^n - 1个元素 , -1 表示无数据
arr[0] = v[0];
for (int i = 1; i < v.size(); i++) {
int j = 0;
while (arr[j] != -1)
{
int left = 2 * j + 1;
int right = 2 * j + 2;
if (v[i] < arr[j]) {
j = left;
}
else {
j = right;
}
}
arr[j] = v[i];
}
stack<int> s;
int ii = 0;
int now = 0;
do {
while (arr[now] != -1) {
s.push(now);
now = 2 * now + 1;
}
now = s.top();
v[ii] = arr[now];
s.pop();
ii++;
now = 2 * now + 2;
} while (s.size() != 0 || arr[now] != -1);
return;
}
}
//时间复杂度 平均O(nlog2n) 最坏(nlog2n) 最好O(nlog2n)
//空间复杂度 O(1)
//稳定性 不稳定
namespace heap_sort_node {
struct Node {
int val;
Node* lchild;
Node* rchild;
};
//Test for print heap
void recur_mid(Node* node) {
if (node == NULL)return;
recur_mid(node->lchild);
cout << node->val << " ";
recur_mid(node->rchild);
}
void sort(vector<int>& v)
{
/*Build Heap*/
Node* head;
head = new Node;
head->val = v[0];
head->lchild = NULL;
head->rchild = NULL;
Node* node;
Node* last_node;
for (int i = 1; i < v.size(); i++) {
node = head;
last_node = head;
while (node != NULL)
{
if (v[i] < node->val) {
last_node = node;
node = node->lchild;
}
else {
last_node = node;
node = node->rchild;
}
}
Node* new_node = new Node;
new_node->val = v[i];
new_node->lchild = NULL;
new_node->rchild = NULL;
if (v[i] < last_node->val) {
last_node->lchild = new_node;
}
else {
last_node->rchild = new_node;
}
}
//Test for print heap
//recur_mid(head);
//cout << endl;
//Use loop for inorder traversal to avoid stack overflow
stack<Node*> s;
int ii = 0;
node = head;
do {
while (node != NULL) {
s.push(node);
node = node->lchild;
}
node = s.top();
v[ii] = node->val;
s.pop();
ii++;
node = node->rchild;
} while (s.size() != 0 || node != NULL);
}
}
//时间复杂度 平均O(nlog2n) 最坏(nlog2n) 最好O(nlog2n)
//空间复杂度 O(n)
//稳定性 稳定
namespace merge_sort {
struct Interval {
int left;
int right;
int state; //记录着递归调用时的步骤
};
void sort(vector<int>& v)
{
int left = 0;
int right = v.size() - 1;
int mid = (right + left) / 2;
Interval _inter;
_inter.left = left;
_inter.right = right;
_inter.state = 0;
//Convert recursion to loop
/*
recur(left,right)
{
if(left>=right)return;
recur(left,mid);
recur(mid+1,right);
merge();
}
*/
stack<struct Interval> s;
s.push(_inter);
while (s.size() != 0)
{
Interval interval = s.top();
s.pop();
left = interval.left;
right = interval.right;
mid = (left + right) / 2;
if (interval.state == 0) {
if (left >= right) {
interval.state = 3; //3 表示不处理这种情况
s.push(interval);
continue;
}
interval.state = 1;
s.push(interval);
Interval inter1;
inter1.left = left;
inter1.right = mid;
inter1.state = 0;
s.push(inter1);
}
else if (interval.state == 1) {
interval.state = 2;
s.push(interval);
Interval inter1;
inter1.left = mid+1;
inter1.right = right;
inter1.state = 0;
s.push(inter1);
}
else if (interval.state == 2) {
vector<int> vec; //Storage sorted data
int i = left;
int j = mid + 1;
while (i <= mid || j <= right) {
//If one out of the limit, the other case is executed
if (j > right) {
vec.push_back(v[i]);
i++;
continue;
}
else if (i > mid) {
vec.push_back(v[j]);
j++;
continue;
}
//Keep the sort stable
if (v[i] <= v[j]) {
vec.push_back(v[i]);
i++;
}
else if (v[i] > v[j]) {
vec.push_back(v[j]);
j++;
}
}
//Copy sorted data to v
for (int i = 0; i < vec.size(); i++)
{
v[left + i] = vec[i];
}
}
}
}
}
enum DATA_TYPE {
RANDOM,
INC,
DEC
};
class TestCase {
Timer timer;
vector<int> v;
vector<int> ch_vec;
public:
/*
size:样例的个数
dtype:生成样例的方式
_sort:排序时调用的方法
print_data:是否打印排序前数据和排序后数据
check:是否进行错误检查
*/
TestCase(int size, DATA_TYPE dtype, void(*_sort)(vector<int>&), bool print_data = false,bool check = false) {
init_vec(size, dtype);
//Sorting original data
if (check) {
ch_vec = v;
std::sort(ch_vec.begin(), ch_vec.end());
}
//Unsorted data
if (print_data) {
print_vec();
}
//Sorting with provided method
timer.Start();
_sort(v);
double duration = timer.End();
cout << "cost time: " << duration << " seconds" << endl;
//Sorted data
if (print_data) {
print_vec();
}
bool error = false;
if (check) {
for (int i = 0; i < v.size(); i++) {
if (v[i] != ch_vec[i]) {
error = true;
break;
}
}
}
if (error) {
cout << "incorrect result" << endl;
}
else {
cout << "corret result" << endl;
}
}
void print_vec()
{
if (v.size() == 0)return;
for (int i = 0; i < v.size(); i++)
{
cout << v[i] << " ";
}
cout << endl;
}
private:
void init_vec(int size, DATA_TYPE dtype) {
v.resize(size);
switch (dtype) {
case INC:
for (int i = 0; i < size; i++)
{
v[i] = i;
}
break;
case DEC:
for (int i = 0; i < size; i++)
{
v[i] = size - i;
}
break;
case RANDOM:
srand(time(0));
for (int i = 0; i < size; i++)
{
v[i] = rand()%9999; //Make it smaller
//v[i] = rand();
}
break;
default:
break;
}
}
};
int main() {
const int SIZE = 30000;
//TestCase testCase1(SIZE,RANDOM,bubble_sort::sort); //SIZE=2000, 3.4s
//TestCase testCase2(SIZE,RANDOM,select_sort::sort); //SIZE=2000, 1.2s
//TestCase testCase3(SIZE,RANDOM,insert_sort::sort); //SIZE=2000, 1.3s
//TestCase testCase4(SIZE, RANDOM, heap_sort_recur::sort); //SIZE=80000, 0.2s 然而SIZE = 100000的时候,malloc failure: Stack overflow
//TestCase testCase5(SIZE, RANDOM, heap_sort_arr::sort); //SIZE=23, 2.0s 由于使用数组存储树,空间利用率低下,特别是当树结构恶化的时候vector将无法申请到足够的内存
//TestCase testCase6(SIZE, RANDOM, heap_sort_node::sort,false,true); //SIZE=100000, 1.0s 最快的一个
//TestCase testCase7(SIZE, RANDOM, merge_sort::sort, false, true); //SIZE=30000, 2.0S 时间主要花在了临时数据的拷贝,存储和释放上面
return 0;
}