Question

如何对包含负数的整数数组进行排序？而且，桶排序和计数排序之间的区别是什么？

Answer 1

负值的存储桶排序

对负值使用Bucket排序只需要将每个元素映射到与其与要排序的最小值的距离成比例的桶。

例如，对于以下输入使用每个值的桶（如上所述）将如下所示：

input array: {4, 2, -2, 2, 4, -1, 0}
min = -2
bucket0: {-2}
bucket1: {-1}
bucket2: {0}
bucket3: {}
bucket4: {2, 2}
bucket5: {}
bucket6: {4, 4}

建议的算法

#A: array to be sorted
#count: number of items in A
#max: maximal value in A
#min: minimal value in A
procedure BucketSort(A, count, max, min)
    #calculate the range of item in each bucket
    bucketRange = (max - min + 1) / bucketsCount
    #distribute the item to the buckets
    for each item in A:
        bucket[(item.value - min) / bucketRange].push(item)
    #sort each bucket and build the sorted array A
    index = 0
    for bucket in {0...bucketsCount}:
        sort(bucket)
        for item in {0...itemsInBucket}:
            A[index] = item
            index++

C ++实现

注意 bucketRange ，它与 max 和 min 之间的范围成比例

#include <iostream>
#include <stdio.h>
#include <vector>
#include <algorithm>    // std::sort
#include <stdlib.h>     // rand
#include <limits>       // numeric_limits

using namespace std;

#define MAX_BUCKETS_COUNT (10) // choose this according to your space limitations

void BucketSort(int * arr, int count, int max, int min)
{
    if (count == 0 or max == min)
    {
        return;
    }

    // set the number of buckets to use
    int bucketsCount = std::min(count, MAX_BUCKETS_COUNT);
    vector<int> *buckets = new vector<int>[bucketsCount];

    // using this range we will we distribute the items into the buckets
    double bucketRange = (((double)max - min + 1) / (bucketsCount));

    for (int i = 0; i < count; ++i)
    {
        int bucket = (int)((arr[i] - min)  / bucketRange);
        buckets[bucket].push_back(arr[i]);
    }

    int index = 0;
    for (int i = 0; i < bucketsCount; ++i)
    {
        // here we sort each bucket O(klog(k) - k being the number of item in the bucket
        sort(buckets[i].begin(), buckets[i].end());
        for (vector<int>::iterator iter = buckets[i].begin(); iter != buckets[i].end(); ++iter)
        {
            arr[index] = *iter;
            ++index;
        }
    }

    delete[] buckets;

}

测试代码

int main ()
{
    int items = 50;
    int data[items];

    int shift = 15;//inorder to get some negative values in the array
    int max = std::numeric_limits<int>::min();
    int min = std::numeric_limits<int>::max();
    printf("before sorting: ");
    for (int i = 0; i < items; ++i)
    {
        data[i] = rand() % items - shift;
        data[i] < min ? min = data[i]: true;
        data[i] > max ? max = data[i]: true;
        printf("%d ,", data[i]);
    }
    printf("\n");

    BucketSort(data, items, max, min);

    printf("after sorting: ");
    for (int i = 0; i < items; ++i)
    {
        printf("%d ,", data[i]);
    }
    printf("\n");

    return 0;
}

Answer 2

这基本上只是一个链接答案，但它为您提供了制定好问题所需的信息。

Bucket Sort

维基百科的第1步，在那里你设置了一个最初空桶的数组＆＃34;，需要包含负数的桶。

Counting Sort

＆＃34;与计数排序相比，存储桶排序需要链接列表，动态数组或大量预分配内存来保存每个存储桶中的项目集，而计数排序则存储单个数字（项目数））每桶。＆＃34;

Answer 3

Bucket sort或bin sort 是一种排序算法，它通过将数组元素分配到多个存储区来工作。然后，使用不同的排序算法或通过递归应用桶排序算法单独对每个桶进行排序。

步骤：

设置一个最初为空的＆＃34;桶的数组＆＃34;。
分散：浏览原始数组，将每个对象放入其存储桶中。
对每个非空桶进行排序。
收集：按顺序访问存储桶并将所有元素放回原始数组中。

Bucket sort假定输入是从统一分布中提取的，并且平均运行时间为O（n）。计算复杂性估计涉及桶的数量。

最差案例表现：O（n ^ 2）

最佳案例表现：欧米茄（n + k）

平均案例表现：Theta（n + k）

最差的案例空间复杂性：O（n.k）

有关实施和象形理解：

http://javaexplorer03.blogspot.in/2015/11/bucket-sort-or-bin-sort.html

Answer 4

Bucket Sort需要一个有序字典，其中唯一值为键，各自的频率为值。这就是第一行所做的并将此字典分配给k。

第二行使用双列表理解返回一个python列表，以输出有序键＆＃39;频率＆＃39;倍。 Sum（...，[]）展平

neglist = [-1, 4, 5, 6, 7, 3, 4, 3, 2, 5, 8, -2, 7, 8, 0, -3, 7, 3, 7, 3, 1, 15, 12, 4, 5, 6, 7, 3, 1, 15]
poslist = [4, 2, 7, 9, 12, 3, 7]


def bucket(k):
    k = dict((uni, k.count(uni)) for uni in list(set(k)))
    return sum(([key for i in range(k.get(key))] for key in sorted(k.keys())), [])


print("NegList: ", bucket(neglist))
print("PosList: ", bucket(poslist))

'''
NegList:  [-3, -2, -1, 0, 1, 1, 2, 3, 3, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 7, 7, 7, 7, 7, 8, 8, 12, 15, 15]
PosList:  [2, 3, 4, 7, 7, 9, 12]
'''

桶排序的算法

4 个答案:

负值的存储桶排序

建议的算法

C ++实现

测试代码