8个排序算法

 

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
/*
1、插入排序。稳定
(1)原理:逐个处理待排序记录,每个记录与前面已排序子序列进行比较,将其插入子序列中正确位置
(2)复杂度:O(n)-》O(n^2),O(n^2)
最佳:升序。时间复杂度为O(n)
最差:降序。时间复杂度为O(n^2)
平均:对于每个元素,前面有一半元素比它大。时间复杂度为O(n^2)

注意:如果待排序数据已经“基本有序”,使用插入排序可以获得接近O(n)的性能
*/
void insertsort(int *data, int n)
{
    if (data == nullptr || n <= 1)
        return;
    for (int i = 1; i < n; i++)
    {
        for (int j = i; j >= 1 && data[j] < data[j - 1]; j--) //升序
            swap(data[j],data[j - 1]);
    }
}
/*插入排序优化:设置哨兵保存待排序值,将比其大的都后移一位,最后插入该值*/
void insertsort_optimization(int *data, int n)
{
    if (data == nullptr || n <= 1)
        return;
    for (int i = 1; i < n; i++)
    {
        int j = i;
        int tmp = data[j];
        for (; j >= 1 && tmp < data[j - 1]; j--) //升序
            data[j] = data[j - 1];
        data[j] = tmp;
    }
}

/*
2、冒泡排序。稳定
(1)原理:从数组的底部比较到顶部,比较相邻元素。
           如果下面的元素更小则交换,否则,上面的元素继续往上比较。
           这个过程每次使最小元素像个“气泡”似地被推到数组的顶部。
(2)复杂度(bubsort_optimization):On-》On^2 ,On^2
*/
void bubsort(int *data, int n)
{
    if (data == nullptr || n <= 1)
        return;
    for (int i = 0; i < n - 1; i++)
    {
        for (int j = n - 1; j > i; j--)
        {
            if (data[j] < data[j - 1])//升序
                swap(data[j], data[j - 1]);//#include <algorithm>
        }
    }
}
/*
冒泡排序优化:增加一个变量flag,用于记录一次循环是否发生了交换,如果没发生交换说明已经有序,可以提前结束
              避免因已经有序的情况下的无意义循环判断
*/
void bubsort_optimization(int *data, int n)
{
    if (data == nullptr || n <= 1)
        return;
    bool flag = true;
    for (int i = 0; i < n - 1 && flag; i++)
    {
        flag = false;
        for (int j = n - 1; j > i; j--)
        {
            if (data[j] < data[j - 1])//升序
            {
                swap(data[j], data[j - 1]);//#include <algorithm>
                flag = true;
            }
        }
    }
}

/*
3、选择排序。不稳定
(1)原理:每次从未排序的序列中找到最小元素,放到未排序数组的最前面
(2)复杂度:O(n^2)
不管数组是否有序,在从未排序的序列中查找最小元素时,都需要遍历完最小序列,所以最差好平均都是O(n^2)

(3)优化:每次内层除了找出一个最小值,同时找出一个最大值(初始为数组结尾)。
将最小值与每次处理的初始位置的元素交换,将最大值与每次处理的末尾位置的元素交换。
这样一次循环可以将数组规模减小2,相比于原有的方案(减小1)会更快
*/
void selectsort(int *data, int n)
{
    if (data == nullptr || n <= 1)
        return;
    for (int i = 0; i < n - 1; i++)
    {
        int lowindex = i;
        for (int j = i + 1; j < n; j++)
        {
            if (data[j] < data[lowindex])
                lowindex = j;
        }
        swap(data[i], data[lowindex]);
    }
}

/*
4、希尔排序。不稳定(插入排序的改进版本)
(1)原理:shell排序在不相邻的元素之间比较和交换。
利用了插入排序的最佳时间代价特性,它试图将待排序序列变成基本有序的,然后再用插入排序来完成排序工作

在执行每一次循环时,Shell排序把序列分为互不相连的子序列,并使各个子序列中的元素在整个数组中的间距相同,
每个子序列用插入排序进行排序。每次循环增量是前一次循环的1/2,子序列元素是前一次循环的2倍
最后一轮将是一次“正常的”插入排序(即对包含所有元素的序列进行插入排序)

(2)复杂度:O(n^(1.5))
选择适当的增量序列可使Shell排序比其他排序法更有效,一般来说,增量每次除以2时并没有多大效果,而“增量每次除以3”时效果更好
当选择“增量每次除以3”递减时,Shell排序的 平均 运行时间是O(n^(1.5))
*/
void shellsort(int *data, int n) 
{
    if (data == nullptr || n <= 1)
        return;
    const int incregap = 3;//增量每次除以3
    /*遍历所有增量大小。incre是增量。每次增量变上次的1/incregap,子序列元素变上次的incregap倍*/
    for (int incre = n / incregap; incre > 0; incre /= incregap)
    {
        for (int i = 0; i < incre; i++)//共有incr个子序列需要分别进行插入排序
        {
            /*对子序列进行插入排序,当增量为1时,对所有元素进行最后一次插入排序*/
            for (int j = i + incre; j < n; j += incre)//每次插入排序都从子序列的第二个值开始,因为认为第一个值已经有序
            {
                for (int k = j; k > i&&data[k] < data[k - incre]; k -= incre)
                    swap(data[k], data[k - incre]);
            }
        }
    }
}
/*
5、快速排序。不稳定。快速排序是所有内部排序算法中平均性能最优的排序算法
(1)原理:首先选择一个轴值,小于轴值的元素被放在数组中轴值左侧,大于轴值的元素被放在数组中轴值右侧,
           这称为数组的一个分割(partition)。快速排序再对轴值左右子数组分别进行类似的操作

(2)复杂度:O(nlogn)-》O(n^2),O(nlogn)
最佳情况:O(nlogn)
最差情况:每次处理将所有元素划分到轴值一侧,O(n^2)
平均情况:O(nlogn)   快速排序平均情况下运行时间与其最佳情况下的运行时间很接近,而不是接近其最坏情况下的运行时间。

(3)优化:
(3.1)最明显的改进之处是轴值的选取,如果轴值选取合适,每次处理可以将元素较均匀的划分到轴值两侧:
三者取中法:三个随机值的中间一个。为了减少随机数生成器产生的延迟,可以选取首中尾三个元素作为随机值
(3.2)当n很小时,快速排序会很慢。因此当子数组小于某个长度(经验值:9)时,此时数组已经基本有序,最后调用一次插入排序完成最后处理
  
(4)选择轴值有多种方法:
最简单的方法是使用首或尾元素。但是,如果输入的数组是正序或者逆序时,会将所有元素分到轴值的一边。
较好的方法是随机选取轴值
*/
int partition(int *data, int start, int end)
{
    //选择尾元素为轴值。较好的方法是随机选取轴值,然后和尾元素交换
    int small = start - 1;//分割点
    for (int index = start; index < end; index++)
    {
        if (data[index] < data[end])//选择尾元素为轴值
        {
            ++small;
            if (small != index)
                swap(data[small], data[index]);
        }
    }
    ++small;
    swap(data[small], data[end]);//将轴值从末尾放到分割点
    return small;//返回分割点。其左小于它,右大于它
}
void qsort(int *data, int start, int end)
{
    if (data == nullptr || end <= start)
        return;
    int index = partition(data, start, end);
    qsort(data, start, index - 1);
    qsort(data, index + 1, end);
}

/*
6、归并排序。稳定。
(1)原理:将一个序列分成两个长度相等的子序列,为每一个子序列排序,然后再将它们合并成一个序列。合并两个子序列的过程称为归并
     二路归并:将n个记录分成长度为1的多个子序列,然后两两归并,得到长度为2的子序列,再两两归并,直到得到长度为n的有序序列为止

(2)复杂度:时间:O(nlogn);空间:O(n)
logn层递归中,每一层都需要O(n)的时间代价,因此总的时间复杂度是O(nlogn),
该时间复杂度不依赖于待排序数组中数值的相对顺序。因此,是最佳,平均和最差情况下的运行时间
由于需要一个和带排序数组大小相同的辅助数组,所以空间代价为O(n)
*/
void mergesortcore(int *data, int *temp, int i, int j)
{
    if (i == j) return;
    int mid = (i + j) / 2;
    mergesortcore(data, temp, i, mid);
    mergesortcore(data, temp, mid + 1, j);

    /*二路归并*/
    //data中是两个分别已排序好的子序列,两个归并排序后放入额外空间temp,再用temp更新对应位置的data
    int index1 = i, index2 = mid + 1, current = i;//二路子序列:index1-mid  index2-j(end)
    while (index1 <= mid && index2 <= j)
    {
        if (data[index1] < data[index2])
            temp[current++] = data[index1++];
        else
            temp[current++] = data[index2++];
    }
    while (index1 <= mid)
        temp[current++] = data[index1++];
    while (index2 <= j)
        temp[current++] = data[index2++];
    for (current = i; current <= j; current++)
        data[current] = temp[current];
}
void mergesort(int *data, int size)
{
    if (data == nullptr || size <= 1)
        return;
    int *temp = new int[size]();//new[] 数组,()初始化为0
    mergesortcore(data, temp, 0, size - 1);
    delete[] temp;
}

/*
归并排序优化空间(原地归并排序):O1空间,O(nlogn)时间。
不用额外空间,两个有序子序列归并时,如果后一个子序列的值小,则前一个子序列全部后移一位,将后一个子序列的小值放到前一个子序列前

【arking原链接测试数据交换2和9就错误,即mid大于左半部分就错误。但其交换两部分内容的方法很好:分别翻转左右部分,再整体翻转】
*/
void mergesort_optimization_core(int *data, int start, int end)
{
    if (start == end)
        return;
    int mid = (start + end) / 2;
    mergesort_optimization_core(data, start, mid);
    mergesort_optimization_core(data, mid + 1, end);

    int index1 = start, index2 = mid + 1;
    while (index1 <= mid && index2 <= end)//二路子序列:index1-mid;index2-end
    {
        if (data[index1] > data[index2])//移动第一个子序列:从index1到mid全部后移一位,把原index2处内容放到index1处。更新mid和end
        {
            int index2_tmp = data[index2];
            for (int t = index2; t > index1; t--)
                data[t] = data[t - 1];
            data[index1] = index2_tmp;
            ++mid;
            ++index2;
        }
        ++index1;//无论是否移动第一个子序列都要更新index1
    }
}
void mergesort_optimization(int *data, int size)
{
    if (data == nullptr || size <= 1)
        return;
    mergesort_optimization_core(data,0,size-1);
}

/*
完全二叉树:假设一个二叉树有n层,那么如果第1到n-1层的每个节点都达到最大的个数:2,
            且第n层的排列是从左往右依次排开的,那么就称其为完全二叉树
堆概念:本身是一个完全二叉树,当二叉树的每个节点都大于等于它的子节点的时候,称为大顶堆;
        当二叉树的每个节点都小于它的子节点的时候,称为小顶堆。
        (stl的make_heap默认大顶堆,使用函数对象less<int>(),而一般sort排序默认此函数对象意味着升序)
堆性质:将堆的内容从左往右,从上至下层次遍历放入数组,
        若一个结点在数组中下标为k,那么它的父结点为(k-1)/2,其子节点为2k+1和2k+2

7、堆排序。不稳定。
(1)原理:首先根据数组构建最大堆,然后每次“删除”堆顶元素(将堆顶元素移至末尾),并调整剩余元素为最大堆。
           最后得到的序列就是从小到大排序的序列。

(2)复杂度:Onlogn
           (根据已有数组构建堆需要O(n)的时间复杂度,每次删除堆顶并调整堆需要O(logn)的时间复杂度,对数组n的排序需要取n-1次堆顶记录
            所以总的时间开销为,O(n+nlogn),平均时间复杂度为O(nlogn)

(3)应用:
(3.1)根据已有元素建堆是很快的,如果希望找到数组中第k大的元素,可以用O(n+klogn)的时间,如果k很小,时间开销接近O(n)
(3.2)从10亿个浮点数当中,选出其中最大的10000个:大数据不适宜载入内存,可使用外排,效率低;也可构建topk的最小堆,每次和根比较,替换根后调整堆
*/
void heapsortcore(vector<int> &data, int parent, int size)
{
    int leftchild = 2 * parent + 1;
    if (leftchild < size)//确保有左孩子,否则data[xx]会越界访问
    {
        int rightchild = leftchild + 1;
        int maxchild = leftchild;//左右孩子中大的那个孩子下标    

        //存在右孩子,则需取得左右孩子中大的那个节点,与父节点比较,把最大的放到父节点,
        //如果做了交换,则需继续递归调整后续子树
        if (rightchild < size)
        {
            if (data[leftchild] < data[rightchild])
                maxchild = rightchild;
        }
        if (data[parent] < data[maxchild])
        {
            swap(data[parent], data[maxchild]);
            heapsortcore(data, maxchild, size);//做了交换,继续递归调整后续子树
        }
    }
}
void heapsort(vector<int> &data)
{
    if (data.size() <= 1)
        return;

    //从无序数组开始建堆:从最后一个叶子节点的父节点开始
    for (int i = (data.size() - 2) / 2; i >= 0; i--)
    {
        heapsortcore(data, i, data.size());//从(size - 2) / 2开始
    }

    //循环将 根节点放到尾部,对除尾部外其余元素重新调整为堆 即可调整数组为有序数组
    //(调整则需只从root开始,和其子节点比较并交换,调整后续子树
    for (int j = data.size() - 1; j > 0; j--)
    {
        swap(data[0], data[j]);
        heapsortcore(data, 0, j);//实际是做了交换,继续递归调整后续子树(和插入到头部做调整不同,插入会改变树结构,可能需要调整全部,而此交换树结构不变,还可重用之前结果,只需调整对应子树)
    }
}

/*针对已经构建好的堆,插入一个元素到尾部,再和parent比较调整为新的堆,只需调整子树
(如果插入到头部,后续节点数组坐标改变,有别的本无须调整的分支可能变成不是最小堆,就需要和开始一样从新建堆,复杂度On>Olog)*/
void insert_heapsort(vector<int> &data, int val)
{
    //从无序数组开始建堆:从最后一个叶子节点的父节点开始
    for (int i = (data.size() - 2) / 2; i >= 0; i--)
    {
        heapsortcore(data, i, data.size());//从(size - 2) / 2开始
    }
    //针对已经构建好的堆,插入一个元素到尾部,再调整为新的堆,只需调整子树
    data.push_back(val);
    int valindex = data.size() - 1;//从插入元素往前调整
    int parent = (valindex - 1) / 2;
    while (valindex > 0)
    {
        if (data[parent] < data[valindex])
        {
            swap(data[parent], data[valindex]);
            valindex = parent;//为继续调整子树做准备
            parent = (valindex - 1) / 2;
        }
        else
            break;//调整到已经比parent小了,由于本就是一个最大堆,只是做调整子树,此处表明所有父节点都比它大,直接break
    }
    //堆排序输出
    for (int j = data.size() - 1; j > 0; j--)
    {
        swap(data[0], data[j]);
        heapsortcore(data, 0, j);//实际是做了交换,继续递归调整后续子树
    }
}
/*
STL的堆排序sort_heap(vi.begin(), vi.end());
循环使用pop_heap实现
*/
void stl_heapsort(vector<int> &data)
{
    if (data.size() <= 1)
        return;
    //int end = data.size();
    make_heap(data.begin(), data.end());//最大堆
    for (int i = 0; i < data.size(); i++)
    {
        pop_heap(data.begin(), data.end()-i);//将root元素移到尾部,再对其余元素重新调整堆
        //--end;
    }
}

/*
8、基数排序。稳定。
(1)原理:桶排序扩展。将整数按位数切割成不同的数字,然后按每个位数分别比较。数位较短的数前面补零
           低位是有序的,高位中如果有相同的值,则只需在保持稳定的前提下对高位进行排序,结果自然有序。
(2)复杂度:时间Od(n+k),空间On+k  k为基数
空间On+k,k为基数10
时间:需要进行最大数位数d次分配和收集,一趟分配On,一趟收集Ok,总共Od(n+k)
*/
void radixsortcore(vector<int> &data, int exp)
{
    //data[i]从后往前数的第exp位值(data[i]/exp)%10  为下标的元素个数
    vector<int> valuecount(10, 0);

    for (int i = 0; i < valuecount.size(); i++)//对于较短的数,高位此处计算为0,则后续会排到前面,且相对位置不变
        valuecount[(data[i] / exp) % 10]++;
    
    //valuecount表示data该出现在排序数组中的下标。valuecount[i]表示i之前的数据出现次数,也即当前数本应该在的位置。
    //如果有3个数个位为1,2个数个位为0,则个位为1的3个数下标从3+2-1开始到3+0-1
    for (int i = 1; i < 10; i++)
        valuecount[i] += valuecount[i - 1];

    //从数组尾部开始放入排序数组对应位置(根据上面求出的每个值的个数),确保相对位置稳定
    vector<int> tmpdata(data.size(), 0);
    
    for (int i = data.size() - 1; i >= 0; i--)
    {
        tmpdata[valuecount[(data[i] / exp) % 10] - 1] = data[i];
        --valuecount[(data[i] / exp) % 10];
    }
    data = tmpdata;
}
void radixsort(vector<int> &data)
{
    if (data.size() <= 1)
        return;
    int max = -1;
    for (int i = 0; i < data.size(); i++)
    {//找出最大值
        if (data[i] > max)
            max = data[i];
    }
    for (int exp = 1; max / exp > 0; exp *= 10)//exp从个位到十位到...
        radixsortcore(data, exp);
}



int main() {
#if 0
    //int data[] = { 0,1,5,6,2,9,30,4,7,8 };

    //insertsort(data, 10);//插入排序。稳定。  时间On-》On^2,On^2
    //insertsort_optimization(data, 10);//插入排序优化。设置哨兵,减少交换
    
    //bubsort(data, 10);//冒泡排序。稳定。  时间On-》On^2 ,On^2
    //bubsort_optimization(data, 10);//冒泡排序优化。增加flag,提前结束
    
    //selectsort(data, 10);//选择排序。不稳定。时间O(n^2)
    
    //shellsort(data,10);//希尔排序(在插入排序的基础上)。不稳定。时间On^1.5
    
    //qsort(data, 0, 9);//快速排序。不稳定。时间Onlogn-》On^2,Onlogn

    //mergesort(data, 10);//归并排序。稳定。Onlogn时间,On空间
    //mergesort_optimization(data, 10);//归并排序优化。Onlogn时间,O1空间
    
    for (int i = 0; i < sizeof(data) / sizeof(int); i++)
        cout << data[i] << " ";
    cout << endl;
#endif

//#if 0
    vector<int> data(10,0);
    for (int i = 0; i < 10; i++)
        data[i] = 9-i;
    cout << "排序前: ";
    for (vector<int>::iterator it = data.begin(); it != data.end(); it++)
        cout <<*it << " ";
    cout << endl;

    
    heapsort(data);//堆排序。不稳定。Onlogn
    //stl_heapsort(data);//stl堆排序
    //int val = 10;
    //insert_heapsort(data,val);//插入元素到已经排序好的堆,重新调整为堆,再排序输出

    //radixsort(data);//基数排序,针对非负整数。稳定。时间Od(n+k),空间On+k  k为基数
    cout << "排序后: ";
    for (vector<int>::iterator it = data.begin(); it != data.end(); it++)
        cout << *it << " ";
    cout << endl;

//#endif
    return 0;
}

 

posted @ 2019-05-23 20:15  前进的code  阅读(396)  评论(0编辑  收藏  举报