【算法】排序算法及其应用总结

最新推荐文章于 2024-04-26 10:11:20 发布
最新推荐文章于 2024-04-26 10:11:20 发布
阅读量3.8k 收藏 30
点赞数 6
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuxiao214/article/details/78526692
版权

2017/11/21
更新基数排序
添加在博客最后面

2017/11/13

最近重温了几大排序算法，包括冒泡排序、插入排序、选择排序、随机快排、归并排序、堆排序、桶排序（后续还会补充）。

另外添加了几个与排序相关的扩展应用。

比如求小和问题、逆序对问题，可以用归并排序解决。
最大差值问题可以用桶排序解决。
后面具体解释一下每个问题为什么这样做，以及如何做。

0、交换函数

void myswap(int &a, int &b)
{
    a = a^b;
    b = a^b;
    a = a^b;
}
void myswap1(int &a, int &b)
{
    int temp = a;
    a = b;
    b = temp;
}
void myswap2(vector<int>&a,int i, int j)
{
    int temp = a[i];
    a[i] = a[j];
    a[j] = temp;
}

1、冒泡排序

时间复杂度：O(N^2)
额外空间复杂度：O(1)
是否可实现稳定性：是

从前依次向后比较，碰到比其大的就进行交换，直到到达此次比较的末尾，则得到此次比较的全局最大值，比较限界的末尾向前滑动。然后重复此过程。

eg:

5 3 1 9 7
第一次排序：
3 5 1 9 7  （5比3大，交换）
3 1 5 9 7  （5比1大，交换）
3 1 5 9 7  （5比9小，不交换）
3 1 5 7 9  （9比7大，交换）
此时，全局最大值9已经到达末尾。除去9，从第一个3再进行第二次比较即可。

代码：

class Bubble
{
public:
    void BubbleSort(vector<int>&a)
    {
        if (a.size() < 2)
            return;
        for (int i = a.size() - 1; i > 0; i--)
        {
            for (int j = 0; j < i; j++)
            {
                if (a[j]>a[j + 1])
                    myswap(a[j], a[j + 1]);
            }
        }
    }
};

2、插入排序

时间复杂度：O(N^2)
额外空间复杂度：O(1)
是否可实现稳定性：是

每次从未排好序的数列中拿第一个p，往已排好序的数列中插入，插入的过程是从已排好序的数列末尾向前依次比较，如果p比其小，则交换后继续往前比较，否则，不交换，此次排序结束。类似摸扑克牌。

eg:

1 3 7 9 5
1 3 7 9 已排好序，将5插入：
1 3 7 5 9  （9比5大，交换）
1 3 5 7 9  （7比5大，交换）
1 3 5 7 9  （5比3大，不交换）

代码：

class Insert
{
public:
    void InsertSort(vector<int>&a)
    {
        if (a.size() < 2)
            return;
        for (int i = 1; i < a.size(); i++)
        {
            for (int j = i - 1; j >= 0; j--)
            {
                if (a[j + 1] < a[j])
                    myswap(a[j], a[j + 1]);
            }
        }
    }
};

3、选择排序

时间复杂度：O(N^2)
额外空间复杂度：O(1)
是否可实现稳定性：否

从未排好序的数列中找到最小的值，将这个值放在已排好序的数列末尾，即与未排好序的首个值交换即可。找最小值只要依次比较即可。

eg:

5 3 1 9 7
排序：
1 3 5 9 7  （找到1是最小值，与5交换）
1 3 5 9 7  （找到3是最小值，与3交换）
1 3 5 9 7  （找到5是最小值，与5交换）
1 3 5 7 9  （找到7是最小值，与9交换）
此时，未排序数列只剩一个数值，而这个数值定是全局最大值，此时排序已完成。

代码：

class Select
{
public:
    void SelectSort1(vector<int>&a)
    {
        if (a.size() < 2)
            return;
        for (int i = 0; i < a.size() - 1;i++)
        {
            for (int j = i + 1; j < a.size();j++)
            {//边比较边交换
                if (a[j] < a[i])
                    myswap(a[j], a[i]);
            }
        }
    }
    void SelectSort2(vector<int>&a)
    {
        if (a.size() < 2)
            return;
        for (int i = 0; i < a.size() - 1; i++)
        {//找到最小值的下标再交换
            int temp = i;
            for (int j = i + 1; j < a.size(); j++)
                temp = a[j] < a[temp] ? j : temp;
            myswap1(a[i], a[temp]);
            //此处有问题，i有可能等于temp,此时用异或交换有问题了
            //如果不用异或交换，正常交换还是对的。
        }
    }
};

4、随机快速排序

时间复杂度：O(Nlog(N))
额外空间复杂度：O(log(N))
是否可实现稳定性：否

1、将数列划分为3个区域，小于区、等于区、大于区。

2、随机选取一个值，作为比较的基准，将其与数列末尾交换。

3、设置小于区指针less（起始时less=-1，因为此时小于区还不存在）
设置大于区指针more（起始时more==基准值的位置，因为此时大于区也不存在）

4、取指针l进行遍历，依次比较数列：

5、比这个值小的，放在小于区末尾，即a[++less]与a[l++]交换，并且l指针++向前移动。

6、等于这个值的，小于区、大于区的指针都不需要移动，遍历指针l++即可。

7、比这个值大的，放在大于区开头，即a[–more]与a[l]交换，此时的l指针并不移动。

8、当l指针到达大于区的位置时，比较结束。

9、此时的less+1是等于区首位置，more是等于区末位置。

10、基准值与大于区第一个值进行交换，这样，数列完成了小于区、等于区、大于区的分区。

11、然后递归在小于区、大于区进行上述过程即可。

eg:

5 3 1 9 7
第一次排序：随机选取5作为基准值，
7 3 1 9 5  （5与末尾7交换）
9 3 1 7 5  （7比5大，与9交换）
1 3 9 7 5  （9比5大，与1交换）
1 3 9 7 5  （1比5小，与1交换）
1 3 9 7 5  （3比5小，与3交换）
此时，到达大于区位置，停止比较。将大于区第一个值9与5交换。
1 3 5 7 9

代码：

class Quick
{
public:
    void QuickSort(vector<int>&a)
    {
        if (a.size() < 2)
            return;
        QuickSort(a, 0, a.size() - 1);
    }
    void QuickSort(vector<int>&a, int l, int r)
    {
        if (l < r)
        {
            srand((int)time(NULL));
            int temp = rand() % (r - l + 1);
            myswap1(a[l + temp], a[r]);
            //myswap2(a, l + temp, r);
            vector<int>p = pattern(a, l, r);
            QuickSort(a, l, p[0] - 1);
            QuickSort(a, p[0] + 1, r);
        }
    }
    vector<int> pattern(vector<int>&a,int l,int r)
    {
        vector<int>p;
        int less = l - 1;
        int more = r;
        while (l<more)
        {
            if (a[l] < a[r])
                myswap1(a[++less], a[l++]);
            //myswap2(a, ++less, l++);
            else if (a[l]>a[r])
                myswap1(a[--more], a[l]);
                //myswap2(a, --more, l);
            else
                l++;
        }
        myswap1(a[r], a[more]);
        //myswap2(a, r, more);
        p.push_back(less + 1);
        p.push_back(more);
        return p;
    }
};

5、归并排序

时间复杂度：O(Nlog(N))
额外空间复杂度：O(N)
是否可实现稳定性：是

二划分和合并的过程。

1、首先划分划分划分，一直划分到不能划分，即每个组都只有一个数值。

2、然后合并，合并的过程就是每个二划分排序的过程。

3、在合并的时候，开辟一个辅助数组，其大小等于这两个合并数列的大小。

4、设置两个指针分别指向每个数列的首部，然后比较得到其中较小的值，并将这个值放入辅助数组中。然后取出小值的那个数列的指针可以继续向前走，与另一个数列的指针所指向的值继续比较。

5、这样比较完成后，如果两个数列中有个数列的数值有剩余，即其指针没有走到末尾，则将这个数列直接赋到辅助数组末尾即可。

6、然后将辅助数组中的值拷贝回原数组中刚才合并的那两个数列的位置上。

eg:

3 7        5 9
合并：
设置辅助数组：
3  （5比3大，3放入数组中）
3 5  （7比5大，5放入数组中）
3 5 7   （9比7大，7放入数组中）
3 5 7 9  （数列1结束，直接将数列2放入辅助数组末尾，即9放入数组中）
完成一次合并排序。
下一次，3 5 7 9 可以和 1 4 6 8进行合并排序。

代码：

class Merge
{
public:
    void MergeSort(vector<int>&a)
    {
        if (a.size() < 2)
            return;
        MergeSort(a, 0, a.size() - 1);
    }
    void MergeSort(vector<int>&a, int l, int r)
    {
        if (l == r)
            return;
        int mid = l + (r - l) / 2;
        MergeSort(a, l, mid);
        MergeSort(a, mid + 1, r);
        merge(a, l, mid, r);
    }
    void merge(vector<int>&a, int l, int mid, int r)
    {
        vector<int>help(r - l + 1);
        int i = 0;
        int p1 = l;
        int p2 = mid + 1;
        while (p1<=mid && p2<=r)
            help[i++] = a[p1] < a[p2] ? a[p1++] : a[p2++];
        while (p1 <= mid)
            help[i++] = a[p1++];
        while (p2 <= r)
            help[i++] = a[p2++];
        for (i = 0; i < help.size(); i++)
            a[l + i] = help[i];
    }
};

6、堆排序

时间复杂度：O(Nlog(N))
额外空间复杂度：O(1)
是否可实现稳定性：否

主要依据一个大根堆。

1、首先建立大根堆。建立大根堆的过程就是依次插入比较，当插入到i时，比较其是否比父节点（i-1）/2的值大，如果大，则交换两个节点，i节点更新为其父节点（i-1）/2，继续比较。直到该节点不再大于父节点，表示此时的大根堆已经完成。继续下一个节点的插入建立。

2、当建立好大根堆后，就可以开始排序。首先设置一个size值，用来表示未排序的范围。将堆顶与未排序的末尾交换，则此时未排序的末尾与已排好序的数列已经形成有序。交换后，堆顶不再是最大元素，需要进行调整使其保持大根堆。排序的过程就是堆顶与未排序的末尾不断交换，交换后调整使其仍为大根堆。

3、在交换后如何调整使其仍为大根堆，首先找到此时i的左节点，如果左节点未超过未排序范围size，则进入循环，如果右节点存在，且右节点的值比左节点的值大，则i与其右节点交换，否则与左节点交换。交换后i更新为交换后的子节点，继续与其子节点比较，直到到达size。

eg:

这里写图片描述

代码：

class Heap
{
public:
    void HeapSort(vector<int>&a)
    {
        if (a.size() < 2)
            return;
        for (int i = 1; i < a.size(); i++)
            HeapInsert(a, i);
        int size = a.size();
        myswap1(a[0], a[--size]);
        while (size>0)
        {
            Heapify(a, 0, size);
            myswap1(a[0], a[--size]);
        }
    }
    void Heapify(vector<int>&a,int index,int size)
    {
        int left = 2 * index + 1;
        while (left<size)
        {
            int largest = left + 1 < size && a[left]<a[left + 1] ? left + 1 : left;
            largest = a[largest] > a[index] ? largest : index;
            if (index == largest)
                break;
            myswap1(a[largest], a[index]);
            index = largest;
            left = 2 * index + 1;
        }
    }
    void HeapInsert(vector<int>&a,int index)
    {
        while (a[index] > a[(index - 1) / 2])
        {
            myswap(a[index], a[(index - 1) / 2]);
            index = (index - 1) / 2;
        }       
    }
};

7、桶排序

时间复杂度：O(N)
额外空间复杂度：O(N)
是否可实现稳定性：是

桶排序不是基于比较的排序，其排序与数的个数无关，但对于数据的位数和范围有限制。

1、首先基于数据的范围创建相应大小的辅助数组help。即遍历找到数组的最大值，则辅助数组的大小即为最大值+1，且初始化为0。

2、辅助数组的每个位置i放置原数组中i的个数。

3、遍历辅助数组，根据位置i中的值，依次向原数组填入help[i]个i值。

eg:

5 3 1 9 7 5
得到最大值9，则辅助数组大小为10.
0 0 0 0 0 0 0 0 0 0  （初始化为0）
0 1 0 1 0 2 0 1 0 1  （1有1个，3有1个，5有两个，7、9各有一个）
填入原数组，
1 3 5 5 7 9

代码：

class Bucket
{
public:
    void BucketSort(vector<int>&a)
    {
        if (a.size() < 2)
            return;
        int imax = INT_MIN;
        for (int i = 0; i < a.size(); i++)
            imax = a[i]>imax ? a[i] : imax;
        vector<int>buckets(imax + 1, 0);
        for (int i = 0; i < a.size(); i++)
            buckets[a[i]]++;
        int j = 0;
        for (int i = 0; i < buckets.size();i++)
        {
            while (buckets[i]-->0)
                a[j++] = i;
        }
    }
};

8、总代码

1、头文件mysort.h

#include <iostream>
#include <vector>
#include<time.h> 
#include <math.h>
#include <stdlib.h>
using namespace std;

/*
2017/11/11
冒泡排序、插入排序、选择排序、随机快排
2017/11/12
归并排序、堆排序、桶排序
*/

#define Random(x) (rand() % x)

void myswap(int &a, int &b)
{
    a = a^b;
    b = a^b;
    a = a^b;
}
void myswap1(int &a, int &b)
{
    int temp = a;
    a = b;
    b = temp;
}
void myswap2(vector<int>&a,int i, int j)
{
    int temp = a[i];
    a[i] = a[j];
    a[j] = temp;
}
class Bubble
{
public:
    void BubbleSort(vector<int>&a)
    {
        if (a.size() < 2)
            return;
        for (int i = a.size() - 1; i > 0; i--)
        {
            for (int j = 0; j < i; j++)
            {
                if (a[j]>a[j + 1])
                    myswap(a[j], a[j + 1]);
            }
        }
    }
};

class Insert
{
public:
    void InsertSort(vector<int>&a)
    {
        if (a.size() < 2)
            return;
        for (int i = 1; i < a.size(); i++)
        {
            for (int j = i - 1; j >= 0; j--)
            {
                if (a[j + 1] < a[j])
                    myswap(a[j], a[j + 1]);
            }
        }
    }
};

class Select
{
public:
    void SelectSort1(vector<int>&a)
    {
        if (a.size() < 2)
            return;
        for (int i = 0; i < a.size() - 1;i++)
        {
            for (int j = i + 1; j < a.size();j++)
            {//边比较边交换
                if (a[j] < a[i])
                    myswap(a[j], a[i]);
            }
        }
    }
    void SelectSort2(vector<int>&a)
    {
        if (a.size() < 2)
            return;
        for (int i = 0; i < a.size() - 1; i++)
        {//找到最小值的下标再交换
            int temp = i;
            for (int j = i + 1; j < a.size(); j++)
                temp = a[j] < a[temp] ? j : temp;
            myswap1(a[i], a[temp]);
            //此处有问题，i有可能等于temp,此时用异或交换有问题了
            //如果不用异或交换，正常交换还是对的。
        }
    }
};

class Quick
{
public:
    void QuickSort(vector<int>&a)
    {
        if (a.size() < 2)
            return;
        QuickSort(a, 0, a.size() - 1);
    }
    void QuickSort(vector<int>&a, int l, int r)
    {
        if (l < r)
        {
            srand((int)time(NULL));
            int temp = rand() % (r - l + 1);
            myswap1(a[l + temp], a[r]);
            //myswap2(a, l + temp, r);
            vector<int>p = pattern(a, l, r);
            QuickSort(a, l, p[0] - 1);
            QuickSort(a, p[0] + 1, r);
        }
    }
    vector<int> pattern(vector<int>&a,int l,int r)
    {
        vector<int>p;
        int less = l - 1;
        int more = r;
        while (l<more)
        {
            if (a[l] < a[r])
                myswap1(a[++less], a[l++]);
            //myswap2(a, ++less, l++);
            else if (a[l]>a[r])
                myswap1(a[--more], a[l]);
                //myswap2(a, --more, l);
            else
                l++;
        }
        myswap1(a[r], a[more]);
        //myswap2(a, r, more);
        p.push_back(less + 1);
        p.push_back(more);
        return p;
    }
};

class Merge
{
public:
    void MergeSort(vector<int>&a)
    {
        if (a.size() < 2)
            return;
        MergeSort(a, 0, a.size() - 1);
    }
    void MergeSort(vector<int>&a, int l, int r)
    {
        if (l == r)
            return;
        int mid = l + (r - l) / 2;
        MergeSort(a, l, mid);
        MergeSort(a, mid + 1, r);
        merge(a, l, mid, r);
    }
    void merge(vector<int>&a, int l, int mid, int r)
    {
        vector<int>help(r - l + 1);
        int i = 0;
        int p1 = l;
        int p2 = mid + 1;
        while (p1<=mid && p2<=r)
            help[i++] = a[p1] < a[p2] ? a[p1++] : a[p2++];
        while (p1 <= mid)
            help[i++] = a[p1++];
        while (p2 <= r)
            help[i++] = a[p2++];
        for (i = 0; i < help.size(); i++)
            a[l + i] = help[i];
    }
};

class Heap
{
public:
    void HeapSort(vector<int>&a)
    {
        if (a.size() < 2)
            return;
        for (int i = 1; i < a.size(); i++)
            HeapInsert(a, i);
        int size = a.size();
        myswap1(a[0], a[--size]);
        while (size>0)
        {
            Heapify(a, 0, size);
            myswap1(a[0], a[--size]);
        }
    }
    void Heapify(vector<int>&a,int index,int size)
    {
        int left = 2 * index + 1;
        while (left<size)
        {
            int largest = left + 1 < size && a[left]<a[left + 1] ? left + 1 : left;
            largest = a[largest] > a[index] ? largest : index;
            if (index == largest)
                break;
            myswap1(a[largest], a[index]);
            index = largest;
            left = 2 * index + 1;
        }
    }
    void HeapInsert(vector<int>&a,int index)
    {
        while (a[index] > a[(index - 1) / 2])
        {
            myswap(a[index], a[(index - 1) / 2]);
            index = (index - 1) / 2;
        }       
    }
};

class Bucket
{
public:
    void BucketSort(vector<int>&a)
    {
        if (a.size() < 2)
            return;
        int imax = INT_MIN;
        for (int i = 0; i < a.size(); i++)
            imax = a[i]>imax ? a[i] : imax;
        vector<int>buckets(imax + 1, 0);
        for (int i = 0; i < a.size(); i++)
            buckets[a[i]]++;
        int j = 0;
        for (int i = 0; i < buckets.size();i++)
        {
            while (buckets[i]-->0)
                a[j++] = i;
        }
    }
};

2、main.cpp

#include <iostream>
#include "sort_mydefine.h"
using namespace std;

/*
2017/11/11
冒泡排序、插入排序、选择排序、随机快排
2017/11/12
归并排序、堆排序、桶排序
*/

#if 1
void main()
{
    vector<int>a = { 1, 1, 6, 4, 5, 7, 2, 14, 6, 14};
    //Bubble b;//冒泡排序
    //b.BubbleSort(a);  

    //Insert b;//插入排序
    //b.InsertSort(a);

    //Select b;//选择排序
    //b.SelectSort2(a);

    //Quick b;//随机快排
    //b.QuickSort(a);

    //Merge b;//归并排序
    //b.MergeSort(a);

    //Heap b;//堆排序
    //b.HeapSort(a);

    Bucket b;//堆排序
    b.BucketSort(a);
    for (int i = 0; i < a.size(); i++)
        cout << a[i] << " ";
    cout << endl;
    system("pause");
}
#else
#endif

9、应用

1、小和问题
如果每个数字左边比其小的数的相加之和称为小和。
求一个数列重所有的小和之和。
见博客。

2、逆序对问题
求一个数列中所有顺序为逆序的对数有几个。
逆序为大的值在小的值之前。
见博客。

3、最大差值问题。
求一个排好序的数列中，相邻数之间的差值最大的那个差值是多少。
见博客。

4、比较器的使用
见博客。

10、基数排序

时间复杂度：O(RN)
额外空间复杂度：O(N)
是否可实现稳定性：是

基数排序，是按照每一位上的数字进行排序的。首先找出数组中最大的那个数，获取这个数有多少位，最大数有多少位就要进行多少次遍历。

1、首先按照个位数上的数字进行排序，将数字依次放入对应的0-9的桶中。

2、然后出桶，这里要注意，出桶顺序在整个循环中要保持一致，比如先进先出，或者先进后出，只能选一种方式出桶。出桶后复制回原数组。

3、对此时的数组根据十位数的数字进行排序，依次入桶出桶，复制回原数组。

4、所有位数遍历结束，原数组已经排好序。

eg:

100 023 015 005 031

个位数排序：
桶：  0    1    2   3   4   5   6  7  8  9 
入桶：100  031     023     015
                          005
出桶：100 031 023 015 005

十位数排序：
桶：  0    1     2    3   4   5   6  7  8  9 
入桶：100  015  023   031  
     005
出桶：100 005 015 023 031

百位数排序：
桶：  0     1    2   3   4   5   6  7  8  9 
入桶：005  100
     015
     023
     031       
出桶：005 015 023 031 100

排序结束

然后进行优化，不需要准备0-9的10个桶，只需要准备一个桶bucket，其大小等于要排序的数组大小即可。

1、如何做，准备一个count数组，大小为10，存放当每位数0-9上各有多少个数。然后对count数组进行累加操作count[i] += count[i - 1]，这样做完之后，count中最大的数一定是原排序数组的大小。这样做的原因是记录存放在桶bucket的位置。

2、然后反向遍历原排序数组（反向的原因是数字从大到小的顺序向前放入bucket），对每一个数num，获取此次遍历位数上的数字p，找到count[p]，说明加上num前面有count[p]个数，所以将num放入桶bucket[count[p]-1]中，然后count[p]–。

3、最后再把bucket桶中的数复制回原数组。

4、然后进行下一次位数上的遍历。

再解释一下为什么用count累加和逆序遍历数组。

1、准备一个桶,每一次填充是填充在对应累计的count个数中,我们已经关注的低位里面最大的那个数(第一次关注个位,第二次关注十位),比如第一次填充中,此时比较值是个位数,count[5]=8,我们访问到了个位数为5的某个数假设为15好了,我们可以认为15是前面累计8个数里面最大的,然后放在buket[8-1]的位置,然后count[5]–,我们接下来遇到了25好了,注意我们只关注个位数目前,所以这个也是前面7个数最大的,(因为目前只关注个位,所以15和25都是最大的),然后count[7-1]放25,count[5]–,等于6,如果count[4]==6,说明个位为5的已经没有了,接下来个位为4的就是最大的了.

2、好,接下来是第二次,我们开始关注十位了,所以我们现在找到的是个位和十位一起最大的数,接着刚才的例子,假设还有一个14好了,那么按照我们的规则,只看14,15,25,这三个值,目前的排序是14,25,15,

3、我们关注十位的时候,从后往前,因为从后往前查找的过程中,保证了是在前面排序的基础上从大往小找,因为我们是要填充count[i]对应的个数里面最大的那个,假设count[1]为3好了,从后往前,我们先找到是15,15放在bucket[3-1]的位置,count[1]–,再找到14,放在buket[2-1]的位置,满足找到的是已经关注低位的最大的数.

4、相反,如果我们从前往后找,那么先找到的是14,放在buket[3-1]的位置,count[1]–,再找到15,放在buket[2-1]的位置,那么.15就在14的前面了.也可以这么简单的理解,,就是我们每次往桶里对应放的时候,都是从后往前放(对应的index是一直–的),那么自然就是先放大的了,先前排序的过程中,能够保障,已经关注的低位中,较大的在后面,所以我们要从后往前遍历.

代码：

class Radix
{
public:
    void RadixSort(vector<int>&a)
    {
        if (a.size() < 2)
            return;
        radix(a, 0, a.size() - 1, maxbits(a));
    }   
    void radix(vector<int>&a,int start,int end,int digits)
    {

        vector<int>bucket(end - start + 1);//准备一个桶，长度是原数组大小
        int num;//获取一个数x在位数digit上的数字
        for (int d = 1; d <= digits;d++)
        {
            vector<int>count(10,0);//记录每个0-9上各有多少个数，初始化为0
            for (int i = start; i <= end;i++)
            {
                num = getnum(a[i], d);//获得a[i]在d位上的数字
                count[num]++;//这个数字个数增1
            }
            for (int i = 1; i < count.size();i++)//规定入桶的顺序,从后面往前入 
                count[i] += count[i - 1];//累加和
            for (int i = end; i >= start;i--)//从后面往前出
            {
                num = getnum(a[i], d);
                bucket[count[num] - 1] = a[i];
                count[num]--;
            }
            for (int i = 0; i < bucket.size(); i++)
                a[start + i] = bucket[i];
        }
    }
    int getnum(int x, int digit)//获取一个数x在位数digit上的数字
    {
        return int(x / pow(10, digit - 1)) % 10;
    }
    int maxbits(vector<int>a)//获取数组最大值的位数
    {
        int imax = INT_MIN;
        for (int i = 0; i < a.size(); i++)
            imax = max(imax, a[i]);
        int digit = 0;
        while (imax > 0)
        {
            digit++;
            imax = imax / 10;
        }
        return digit;
    }
};
夏洛的网
关注
  • 6
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
排序：十大经典排序算法有哪些应用？
小识的博客
08-15 1357
冒泡排序 从头开始，依次比较数组中相邻的2个元素，如果后面的数比前面的数大，则交换2个数，否则不交换。每进行一轮比较，都会把数组中最大的元素放到最后面。 如下图，一轮比较的过程如下 当数组中有n个元素时，只需要进行n轮比较，则整个数组就是有序的 public static void bubbleSort(int[] a) { // 进行i轮比较 for (int i = 0; i < a.length - 1; i++) { for (int j = 0; j < .
排序算法合集及其应用举例
Sakura_lht
01-24 1288
1. 排序算法一表总览 排序算法 最好时间复杂度 最坏时间复杂度 平均时间复杂的 空间复杂度 排序方式 稳定性 快速排序 O(nlog⁡n)O(n\log n)O(nlogn) O(n2)O(n^2)O(n2) O(nlog⁡n)O(n\log n)O(nlogn) O(log⁡n)O(\log n)O(logn) 交换 不稳定 计数排序 O(k+n)O(k + n)O(k+n) O(k+n)O(k + n)O(k+n) O(k+n)O(k + n)O(k+n) O(k+n)O(k +
15个应用场景的算法实现（可套用）
最新发布
一个天蝎座的程序猿
04-26 741
常用的算法理解起来还是有难度的，大多数初中级程序员接触的机会也不多，但我们不能因为不接触就放弃研究和积累算法，除非你不想往更高的技术架构或高级去走，算法通常都是比较成熟的，拿来即用也不是不可以，这是第一步解决问题，然后再慢慢研究理解，因为项目中的核心技术永远掌握在公司那些天价核心的技术人员手里，今天的内容就分享到这里。
图文详解 排序算法对比以及能解决的问题
weixin_37970049的博客
06-04 1113
我们会使用的排序算法 常见的排序算法 冒泡排序、插入排序、选择排序、归并排序、快速排序、计数排序、基数排序、桶排序 思考1 插入排序和冒泡排序的时间复杂度相同，都是 O(n2) 在实际的软件开发里，为什么我们更倾向于使用插入排序算法而不是冒泡排序算法呢？ 冒泡排序 冒泡排序只会操作相邻的两个数据，每次冒泡操作都会对相邻的两个元素进行比较，如果不满足就让它俩互换。一次冒泡会至少一个元素移动到...
常见排序算法的性能以及应用场景
Cris_0525的博客
03-30 1720
文章目录1. 排序算法的性能总结1.1按平均时间复杂度将排序分为四类：1.2按稳定性将排序算法分为两类：2.排序算法的应用场景2.1 桶排序的应用场景2.2 快速排序的应用场景2.3希尔排序的应用场景 1. 排序算法的性能总结 1.1按平均时间复杂度将排序分为四类： 平方阶(O(n2))排序 包括：直接插入、直接选择和冒泡排序； 线性对数阶(O(nlgn))排序 包括： 快速快速、堆排序和归并排...
十大经典排序算法-归并排序算法详解
热门推荐
qq_35344198的博客
06-19 11万+
一、什么是归并排序 1.概念 归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法，归并排序对序列的元素进行逐层折半分组，然后从最小分组开始比较排序，合并成一个大的分组，逐层进行，最终所有的元素都是有序的 2.算法原理 这是一个无序数列：4、5、8、1、7、2、6、3，我们要将它按从小到大排序。按照归并排序的思想，我们要把序列逐层进行拆分 序列逐层拆分如下 然后从下往上逐层合并，首先对第一层序列1（只包含元素4）和序列2（只包含元素5）进行合并 创建一个大序列，序列长度为两个小序列长度
基本排序算法及其在MapReduce的应用
02-01
冒泡、选择、插入三种作为基本的排序算法是必须要掌握的，而在MapReduce的实际应用中。在Map阶段，k-v溢写时，采用的正是快排；而溢出文件的合并使用的则是归并；在Reduce阶段，通过shuffle从Map获取的文件进行合并...
排序算法总结及习题2
08-08
排序算法是计算机科学中至关重要的一部分，它涉及到如何有效地组织和处理数据。本文主要总结了七种常见的排序算法：名次排序、冒泡排序、...理解和掌握这些排序算法及其特点，对于提升编程效率和优化程序性能至关重要。
快速排序算法及其改进算法的分析与评价.doc
05-07
总结，快速排序及其改进算法的研究有助于我们理解排序算法的内在机制，优化算法性能，以适应各种实际场景的需求。通过对传统快速排序的局限性进行改进，如双倍快速排序，我们可以设计出更高效、更稳定的排序算法，...
第9章排序算法1
08-04
排序算法是将某种数据结构或数据序列按其数据元素的关键字的值以递增或递减的次序排列的过程，它在计算机数据处理中有着广泛的应用。 数据序列及其排序 数据序列是特定数据结构中的一系列数据元素，它是待加工处理...
python 常见的排序算法实现汇总
09-16
本文将深入探讨几种常见的排序算法及其Python实现，包括冒泡排序、选择排序、插入排序、希尔排序、快速排序和归并排序。这些算法主要分为比较类排序，它们通过元素之间的比较来决定顺序。 1. **冒泡排序**：冒泡...
各类排序算法比较和应用场景
MBuger的博客
03-28 2万+
简介插入排序插入排序是一种较为简单的排序算法，它的基本思想是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。 形象的可以理解为打扑克抓拍的过程，通常我们右手抓牌，没抓一张牌，就放到左手，抓下一张牌后，会把这张牌依次与左手上的牌比较，并把它插入到一个合适的位置（按牌面大小）。希尔排序希尔排序是对直接插入排序的一种优化，实质就是把直接插入排序改为了分组插入排序。其基
常用排序算法的性能分析及应用场景
传a奇—学习博客
11-01 1万+
一.排序算法分类 1.插入排序法     直接插入排序，希尔排序（面试最常问） 2.交换排序     冒泡排序，快速排序（面试最常问） 3.选择排序     直接选择排序，堆排序（面试最常问） 4.归并排序      归并排序 5.基数排序 当然排序算法博大精深，肯定不止以上几种，本人只列出了几个最为经典的，也是最常用的排序算法。 二.空间、时间复杂度、稳定性
排序算法在JDK中的应用
Alex_NINE的博客
05-27 1116
JDK8中的排序算法 JDK中对于数组的排序使用比较的多的是Arrays.sort()和Arrays.parallelSort()，前者是传统的排序算法，后者是JDK8新增的并行排序算法，基于fork/join框架,今天主要是分析Arrays.sort()的底层实现。 Arrays.sort()可以对所有的基本类型（除boolean）和Object进行排序，如果是数值类型的数就直接按照从大到小的顺...
一些排序算法的使用
l1076089424的博客
10-19 158
冒泡算法 public class test2 { public static void main(String[] args) { int[] num = { 80, 50, 42, 42, 66, 99 }; num(num); } public static void num(int[] num) { int count = num.length; for...
排序算法的实际应用
allwefantasy的专栏
10-12 7012
上次在研究算法的时候详细的介绍了快速排序。今天有个朋友托我将一些域名排序，按域名长度进行排序。我看了下估计至少有300多万行，处理出的结果（txt文件）多达将近100M.数据量好大啊。下面是程序清单。核心算法还是复用上次研究过的排序算法。由于数据量巨大，内存会溢出，所以基本解决解决方式是先将文件分段成多个小文件，再分别排序，然后合并到一个文件，最后删除那些小文件。但是由于数据量巨大严重的影响了性能
快速排序算法存在的问题及改进
zhouxukun123的专栏
02-28 4623
一、存在的问题 当数组长度较小时，不比其他排序算法高效，如插入排序； 当数组为有序数组时，或者所选中轴数每次都是最小或最大的元素，造成每次分区都只有一个分区（每次分区后规模都只减1），得到最坏时间复杂度O(n^2) 二、改进 对于快排存在的问题，对应的改进方法如下： 1.当划分到较小的子数组时，通常可以使用插入排序替代快速排序 此时可以设定一个快排分区的阈值，当待排数组分区后的长度小于阈值时改...
算法1：排序问题（1）
Mica_Dai的博客
02-10 360
文章目录插入排序归并排序   大道理什么的我已经不想多讲，直接上一些让自己重新理解问题的笔记才是硬核之事。今天我写的代码是排序问题，这是一个很古老，也是算法开课绕不开的问题，有很多种形态各样的排序算法——冒泡排序、插入排序、归并排序，快速排序、堆排序、希尔排序等等。   今天我首先想接触的是插入排序和归并排序两种。首先来看一下插入排序—— 插入排序   主要思路是将一个新的数据插入到一个已经排好序...
经典排序——帮你解决关于排序的绝大多数问题
JDSZGLLL的博客
09-13 743
各种排序实现的结果是一样的，但是方法各种各样，实现的原理也是各不相同，在实际运用的不同场景中我们该如何取舍呢？ 这就是这篇博客的意义，手把手教大家实现各种排序，让看完的同学可以从底层逻辑上，把经典的排序原理了解的清清楚楚，在使用的过程中可以得心应手。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值