绪论
我又回来啦，之前忙了一段时间没有时间把排序算法完善，现在补上2.0，同时也对1.0中的部分排序算法的实现进行了重写，代码基本上都经过测试但是没有实现异常安全。
接下去有时间应该还会把这部分代码用Java重写一遍。
头文件
#pragma once
/*******************************
*关于排序算法
* 在下列中一共列出了十种排序算法
* 分别分析了算法的时间复杂度和稳定性
*
********************************/
template<class T>
class Sort //只是顺手写个类，实际上使用普通模板函数即可
{
private:
void Sweap(T&, T&); //交换两个数的位置（合理性在于由于非常引用，因此只能传入右值）
void heapsort(T a[], int i, int n); //堆排序的辅助函数
void Median3(T a[], int left, int right); //快速排序的辅助函数
void fastsort(T a[], int left, int right); //快速排序函数(这里需要用两个数指示出数组的头尾，用于递归）
void merge(T a[],T middle[], int lpos, int Rpos, int RightEnd); //归并排序辅助函数（来自《Data Structures and Algorithm Analyses in C》
void Msort(T a[], T middle[], int left, int right); //归并排序辅助函数
public:
//这里只是顺手这么写，C语言标准6.2中指出在作为函数参数传递时，数组将退化为指针
void Insertsort(T a[],int n); //插入排序(注意这里不使用引用传递指针，因为实际上我们不需要修改指针本身，因此使用值传递反而是更好的保护）
void Hillsort(T a[], int n); //希尔排序
void Fastsort(T a[], int n); //快速排序
void Bubblesort(T a[], int n); //冒泡排序
void Selectsort(T a[], int n); //选择排序
void Heapsort(T a[], int n); //堆排序
void Mergesort(T a[], int n); //归并排序
void Print(T a[], int n); //用于测试打印
};函数体实现（所有的分析都在注释中）
#include"sort.h"
#include<iostream>
#include<cstring>
/******************************
*插入排序为最简单的排序方法，时间复杂度O(N*N)，当全部为反序的时候达到
* 为稳定排序（相同的数据在排序结束后不会乱序）
*内部排序，空间复杂度O（1）
*插入排序的核心在于调整逆序数
* 每一次循环都会使前k个数变得有序，即循环会消除第k个数与前k-1个数的逆序数
*******************************/
template <class T>
void Sort<T>::Insertsort(T a[],int n) //这里的a[]代表传入的是一个数组（这个表达形式其实和指针是完全一样的),第二个代表数组长度，在C/C++中实际上是不做数组越界检测的，这和malloc申请的空间不同
{
T middle;
for (int i = 1; i < n; i++)
{
middle = a[i];
int j = i; //注意虽然语法上j可以在for中定义，但是考虑for循环之外还要使用j，如果在下面的for循环中定义会导致for之外j生命周期结束出现undefine
for (j ; j > 0 && a[j - 1] > middle; j--) //如果middle比a[j-1]小，那么就将a[j-1]向后移动一位
{
a[j] = a[j - 1];
}
a[j] = middle; //在跳出循环前还会有一次自减
}
}
//直接插入的核心思想在于将数据直接插入到应当在的位置
//如果是链表这样的插入显然是容易的
//但是对于数组来说，数组空间是有限的，因此只能使用移位的方式将所需的空间移出
//对于移位有两种方式1.找到需要的位置，将需要移动的数集中后移
//2.逐渐向前对比，每次对比后将需要移动的数后移
/******************************
*冒泡排序，时间复杂度O(N*N)，平均时间复杂度O（N*N),最好时间复杂度O（N）
*内部排序，空间复杂度O（1）
*为稳定排序（相同的数据在排序结束后不会乱序）
*冒泡排序每一轮循环将会使得最后一位数到达应当到达的位置
*******************************/
template<typename T>
void Sort<T>::Bubblesort(T a[], int n)
{
T middle;
for (int i = n-1; i >0; i--)
{
for (int j = 0; j < i-1; j++)
{
if (a[j] > a[j + 1])
{
middle = a[j];
a[j] = a[j + 1];
a[j + 1] = middle;
}
}
}
}
/******************************
*选择排序，时间复杂度O(N*N)
*内部排序空间复杂度O（1）
*为不稳定排序（相同的数据在排序结束后会乱序）（当然稳定和不稳定是有一定条件的，在数组中是不稳定（如5，5，5，2），链表中是稳定的）
*实际是因为数组的空间是固定的，做的是交换操作，而链表实际上做的是插入操作
*看上述的（5,6,5,2)数组-》（2,5,6,5)做的是一个交换
* 链表（5,6,5,2)-》(2,5,6,5)做的是一个节点的插入
*******************************/
template<class T>
void Sort<T>::Selectsort(T a[], int n) //这里我们寻找最小节点，将最小节点和第一个节点交换
{
T min;
int middle;
for (int i = 0; i < n - 1; i++) //for循环如果判断条件为真先执行代码块内语句再执行语句三（i++） 突然半夜有点迷糊
{
min = a[i];
middle = i;
for (int j = i; j < n; j++)
{
if (a[j] < min)
{
min = a[j];
middle = j;
}
}
a[middle] = a[i];
a[i] = min; //交换两者顺序
}
}
/******************************
*希尔排序是直接插入排序的改进版本
*第一个被发现的时间复杂度小于O（N*N）的算法
*是一种不稳定排序，排序的时间复杂度为O（nlogn*n）
*内部排序空间复杂度O（1）
*希尔排序是记录按下标的一定增量分组
*对每组使用直接插入排序算法排序
*随着增量逐渐减少，每组包含的关键词越来越多
*当增量减至1时，整个文件恰被分成一组，算法便终止。
* 下面的例程中将使用3，2，1来作为排序划分
*******************************/
template<class T>
void Sort<T>::Hillsort(T a[], int n)
{
T middle;
//排序划分等于3时
for (int i = 0; i < 3; i++) //间隔为3一共可以分为三组
{
for (int j = i+3; j < n; j += 3) //每一组独立进行直接插入排序
{
middle = a[j];
int k = j;
for (k; k > 0 && middle < a[k - 3]; k -= 3)
{
a[k] = a[k - 3];
}
a[k] = middle; //丢在外面减少运算量（在跳出循环前还会有一次自减）
}
}
//排序划分为2时
for (int i = 0; i < 2; i++) //间隔为2一共可以分为二组
{
for (int j = i + 2; j < n; j += 2)
{
middle = a[j];
int k = j;
for (k; k > 0 && middle < a[k - 2]; k -= 2)
{
a[k] = a[k - 2];
}
a[k] = middle; //丢在外面减少运算量（在跳出循环前还会有一次自减）
}
}
//当排序划分等于1的时候直接调用选择排序就好
Insertsort(a, n);
}
/************************************
*堆排序，时间复杂度O(1)
*堆排序是按照完全二叉树的形式（节点和满二叉树有一致的序号）
*将数组中的数按照大（小）根堆的形式进行进行排列
*大根堆，即左右子树的大小小于根节点
*将顶端的数与最后一位数交换固定最后一位数，然后将剩余的数再构造成一个大根堆
*一直重复这一操作，直到所有数都被固定
* 这里需要首先对堆这种数据结构有一定的认知
*************************************
*关于堆排序堆的构建方式
* 首先找到最后一个非叶子节点，将这个节点生长的子树变为大/小根堆
* 再向前按逆序（节点插入顺序的反序）使得每一个节点都满足大/小根堆（实际上就是从最后一个非叶子节点开始反向层序遍历）
* 这样可以使得除了当前节点之外从当节点生成的子树是大/小根堆
***************************************
*当然在不考虑麻烦的情况下也是可以用链式的树状实现的
*但是这样的遍历将要借助到队列，同时向上回溯将会变得很麻烦
* 当然可以考虑在节点中加入指向双亲节点的指针
**************************************/
template<class T>
void Sort<T>::heapsort(T data[], int i, int n)
{
int child;
T middle;
for (middle = data[i]; (i * 2 + 1) < n; i = child) //注意在堆数据结构中我们一般从1开始存储数据，但是这里是从0开始的所以公式和那边不太一样
{ //这里的目的是将节点的数据和子节点数据交换，使得满足大/小根堆条件
child = (i * 2 + 1);
if (child != n - 1 && data[child + 1] > data[child])
{
child++;
}
if (middle < data[child])
{
data[i] = data[child];
}
else
{
break;
}
}
data[i] = middle;
}
//n为数据总长度
template<class T>
void Sort<T>::Heapsort(T a[], int n)
{
int i;
T middle;
for (i = (n -1)/ 2; i >= 0; i--)
{
heapsort(a, i, n);
}
for (i = n - 1; i > 0; i--)
{
middle = a[0];
a[0] = a[i];
a[i] = middle;
heapsort(a, 0, i); //交换后,去除最后一个节点，左右子树还是大/小根，要将root节点移动到合适位置重新满足大/小根堆条件
}
}
/***********************************
*快速排序，一直在工程中使用起来最快的排序算法
*实际上快速排序的快是快在平均时间复杂度
* 快速排序平均时间复杂度为（NlogN），时间复杂度为O（N*N）
* 快速排序的思路在于选取一个点作为划分点
* 将小于这个点的数据放在左边，大于这个点的数据放在右边
* 之后再对这两边的数据做快速排序
*************************************/
template<class T>
void Sort<T>::Sweap(T& a, T& b)
{
T middle = a;
a = b;
b = middle;
}
template<class T>
void Sort<T>::Median3(T a[], int left, int right) //这个辅助函数是用于寻找中间，和两侧节点的大小关系再排序（这种设计来自于《数据结构与算法分析》）
{
int center = (int)((left + right) / 2);
if (a[left] > a[center])
{
Sweap(a[left], a[center]);
}
if (a[left] > a[right])
{
Sweap(a[left], a[right]);
}
if (a[center] > a[right])
{
Sweap(a[center], a[right]);
}
Sweap(a[center], a[right - 1]);
}
template<class T>
void Sort<T>::fastsort(T a[], int left, int right)
{
int i;
int j; //用于遍历的时候的指示
if (left + 3 <= right) //判断剩余部分是不是太短，太短用直接选择排序就好
{
int count_1 = 0;
int count_2 = 0;
i = left;
j = right - 1;
Median3(a, left, right);
//下面的循环是一个很巧妙的设计，用尽可能少的步骤完成数据的分离
while(1)
{
while (a[++i] < a[right - 1]); //虽然这是两个循环，但是由于对于这个循环来说ij是外部变量，因此每个位置只被遍历一次
while (a[--j] > a[right - 1]);
if (i < j)
{
Sweap(a[i], a[j]);
}
else
{
break;
}
}
Sweap(a[i], a[right - 1]); //最后需要将中间节点放回自己应该在的位置
fastsort(a, left, i - 1);
fastsort(a, i + 1, right);
}
else
{
//整体这里建议用Insertsort(a+left,right-left+1)，不要自己逞能这么写，很容易丢失角标里的left，而且这种多递归极难调试
Print(a, 10);
for (int k = 1; k < (right - left+1); k++)
{
T middle = a[left + k];
int j = k;
for (j; j > 0 && a[left+j - 1] > middle; j--) //注意一下for循环三个语句的执行顺序
{
Sweap(a[left+j], a[left+j - 1]);
}
//注意这个位置中的角标
}
}
}
template<class T>
void Sort<T>::Fastsort(T a[], int n)
{
fastsort(a, 0, n - 1);
}
/**********************************************
*归并排序，一种巧妙使用递归的外部排序，时间复杂度O（NlogN）
*归并排序的基本思想在于将数分割成两部分
*如果长度都为1，则按大小合并到一个数组
*如果不为1，那么再对这部分做归并排序
*如果完全按照这种做法将会产在每个时刻都会有logN的额外空间在使用
*《Data Structures and Algorithm Analyses in C》提供一种全新的方法
***********************************************/
//这个函数中的lpos是左半边的起点
//Rlops是右半边起点
//RightEnd是终点
template<class T>
void Sort<T>::merge(T a[],T middle[], int lpos, int Rpos, int RightEnd)
{
int leftend = Rpos - 1;
int nummiddle = RightEnd - lpos + 1;
int mid = lpos;
while (lpos <= leftend && Rpos <= RightEnd)
{
if (a[lpos] <= a[Rpos])
{
middle[mid++] = a[lpos++];
}
else
{
middle[mid++] = a[Rpos++];
}
}
while (lpos <= leftend) //在插入结束后总是会有一个数组会有剩，因此需要将后续数据直接写入（由于两个数组本身都是排序好的，所以将剩下数据直接插入不会打破排序）
{
middle[mid++] = a[lpos++];
}
while (Rpos <= RightEnd)
{
middle[mid++] = a[Rpos++];
}
for (int i = 0; i < nummiddle; i++)
{
a[RightEnd] = middle[RightEnd];
RightEnd--;
}
}
template<class T>
void Sort<T>::Msort(T a[], T middle[], int left, int right)
{
int center;
if (right > left)
{
center = (left + right) / 2;
Msort(a, middle, left, center);
Msort(a, middle, center + 1, right);
merge(a, middle, left, center + 1, right);
}
}
template<class T>
void Sort<T>::Mergesort(T a[], int n)
{
T* middle = (T*)malloc(sizeof(T) * n);
Msort(a, middle, 0, n - 1);
}
template<class T>
void Sort<T>::Print(T a[], int n)
{
for (int i = 0; i < n; i++)
{
std::cout << a[i];
}
std::cout << std::endl;
}
int main()
{
Sort<int> test;
int a[10] = { 3,5,7,4,2,1,0,6,9,8};
int a_Insert[10];
int a_Bubble[10];
int a_Select[10];
int a_Hill[10];
int a_HEAP[10];
int a_FAST[10];
int a_MERG[10];
std::memcpy(a_Insert, a, sizeof(int) * 10);
std::memcpy(a_Bubble, a, sizeof(int) * 10);
std::memcpy(a_Select, a, sizeof(int) * 10);
std::memcpy(a_Hill, a, sizeof(int) * 10);
std::memcpy(a_HEAP, a, sizeof(int) * 10);
std::memcpy(a_FAST, a, sizeof(int) * 10);
std::memcpy(a_MERG, a, sizeof(int) * 10);
test.Insertsort(a_Insert, 10);
std::cout << "1.直接插入排序: ";
test.Print(a_Insert, 10);
test.Bubblesort(a_Bubble, 10);
std::cout << "2.冒泡排序: ";
test.Print(a_Bubble, 10);
test.Selectsort(a_Select, 10);
std::cout << "3.选择排序: ";
test.Print(a_Select, 10);
test.Hillsort(a_Hill, 10);
std::cout << "4.希尔排序： ";
test.Print(a_Hill, 10);
test.Heapsort(a_HEAP,10);
std::cout << "5.堆排序: ";
test.Print(a_HEAP,10);
test.Fastsort(a_FAST, 10);
std::cout << "6.快速排序: ";
test.Print(a_FAST, 10);
test.Mergesort(a_MERG, 10);
std::cout << "7.归并排序: ";
test.Print(a_MERG, 10);
}
3548
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
