Bucket Sort

pick a language to open the code

def bucket_sort(a):
    if not a:
        return
    n = len(a)
    span = max(a) + 1
    buckets = [[] for _ in range(n)]
    for value in a:
        buckets[value * n // span].append(value)
    i = 0
    for bucket in buckets:
        bucket.sort()
        for value in bucket:
            a[i] = value
            i += 1

function bucketSort(a) {
  if (a.length === 0) return;
  const n = a.length;
  const span = Math.max(...a) + 1;
  const buckets = Array.from({ length: n }, () => []);
  for (const value of a) buckets[Math.floor((value * n) / span)].push(value);
  let i = 0;
  for (const bucket of buckets) {
    bucket.sort((x, y) => x - y);
    for (const value of bucket) a[i++] = value;
  }
}

void bucket_sort(int a[], int n, int span) {
    int* starts = calloc(n + 1, sizeof(int));
    int* out = malloc(sizeof(int) * n);
    for (int i = 0; i < n; i++) starts[(long)a[i] * n / span + 1]++;
    for (int b = 1; b <= n; b++) starts[b] += starts[b - 1];

    int* fill = malloc(sizeof(int) * n);
    memcpy(fill, starts, sizeof(int) * n);
    for (int i = 0; i < n; i++) {
        int b = (long)a[i] * n / span;
        out[fill[b]++] = a[i];
    }
    for (int b = 0; b < n; b++) {
        insertion_sort_range(out, starts[b], starts[b + 1]);
    }
    memcpy(a, out, sizeof(int) * n);
    free(starts);
    free(out);
    free(fill);
}

void bucket_sort(std::vector<int>& a) {
    if (a.empty()) return;
    size_t n = a.size();
    int span = *std::max_element(a.begin(), a.end()) + 1;
    std::vector<std::vector<int>> buckets(n);
    for (int value : a) {
        buckets[static_cast<size_t>(value) * n / span].push_back(value);
    }
    size_t i = 0;
    for (auto& bucket : buckets) {
        std::sort(bucket.begin(), bucket.end());
        for (int value : bucket) a[i++] = value;
    }
}

static void BucketSort(int[] a) {
    if (a.Length == 0) return;
    int n = a.Length;
    int span = a.Max() + 1;
    var buckets = new List<int>[n];
    for (int b = 0; b < n; b++) buckets[b] = new List<int>();
    foreach (int value in a) buckets[(long)value * n / span].Add(value);
    int i = 0;
    foreach (var bucket in buckets) {
        bucket.Sort();
        foreach (int value in bucket) a[i++] = value;
    }
}

static void bucketSort(int[] a) {
    if (a.length == 0) return;
    int n = a.length;
    int span = Arrays.stream(a).max().getAsInt() + 1;
    List<List<Integer>> buckets = new ArrayList<>();
    for (int b = 0; b < n; b++) buckets.add(new ArrayList<>());
    for (int value : a) buckets.get((int) ((long) value * n / span)).add(value);
    int i = 0;
    for (List<Integer> bucket : buckets) {
        Collections.sort(bucket);
        for (int value : bucket) a[i++] = value;
    }
}