Related Articles

# Bucket Sort To Sort an Array with Negative Numbers

• Difficulty Level : Medium
• Last Updated : 02 Mar, 2021

We have discussed bucket sort in the main post on Bucket Sort
Bucket sort is mainly useful when input is uniformly distributed over a range. For example, consider the problem of sorting a large set of floating point numbers which are in range from 0.0 to 1.0 and are uniformly distributed across the range. In the above post, we have discussed Bucket Sort to sort numbers which are greater than zero.
How to modify Bucket Sort to sort both positive and negative numbers?
Example:

```Input : arr[] = { -0.897, 0.565, 0.656, -0.1234, 0, 0.3434 }
Output : -0.897 -0.1234  0 0.3434 0.565 0.656 ```

Here we considering number is in range -1.0 to 1.0 (floating point number)
Algorithm :

```sortMixed(arr[], n)
1) Split array into two parts
create two Empty vector Neg[], Pos[]
(for negative and positive element respectively)
Store all negative element in Neg[] by converting
into positive (Neg[i] = -1 * Arr[i] )
Store all +ve in pos[]  (pos[i] =  Arr[i])
2) Call function bucketSortPositive(Pos, pos.size())
Call function bucketSortPositive(Neg, Neg.size())

bucketSortPositive(arr[], n)
3) Create n empty buckets (Or lists).
4) Do following for every array element arr[i].
a) Insert arr[i] into bucket[n*array[i]]
5) Sort individual buckets using insertion sort.
6) Concatenate all sorted buckets. ```

Below is implementation of above idea (for floating point number )

## CPP

 `// C++ program to sort an array of positive``// and negative numbers using bucket sort``#include ``using` `namespace` `std;` `// Function to sort arr[] of size n using``// bucket sort``void` `bucketSort(vector<``float``> &arr, ``int` `n)``{``    ``// 1) Create n empty buckets``    ``vector<``float``> b[n];` `    ``// 2) Put array elements in different``    ``//    buckets``    ``for` `(``int` `i=0; iNeg ;``    ``vector<``float``>Pos;` `    ``// traverse array elements``    ``for` `(``int` `i=0; i

## Java

 `// Java program to sort an array of positive``// and negative numbers using bucket sort``import` `java.util.*;``class` `GFG``{` `  ``// Function to sort arr[] of size n using``  ``// bucket sort``  ``static` `void` `bucketSort(Vector arr, ``int` `n)``  ``{` `    ``// 1) Create n empty buckets``    ``@SuppressWarnings``(``"unchecked"``)``    ``Vector b[] = ``new` `Vector[n];``    ``for` `(``int` `i = ``0``; i < b.length; i++)``      ``b[i] = ``new` `Vector();` `    ``// 2) Put array elements in different``    ``// buckets``    ``for` `(``int` `i = ``0``; i < n; i++)``    ``{``      ``int` `bi = (``int``)(n*arr.get(i)); ``// Index in bucket``      ``b[bi].add(arr.get(i));``    ``}` `    ``// 3) Sort individual buckets``    ``for` `(``int` `i = ``0``; i < n; i++)``      ``Collections.sort(b[i]);` `    ``// 4) Concatenate all buckets into arr[]``    ``int` `index = ``0``;``    ``arr.clear();``    ``for` `(``int` `i = ``0``; i < n; i++)``      ``for` `(``int` `j = ``0``; j < b[i].size(); j++)``        ``arr.add(b[i].get(j));``  ``}` `  ``// This function mainly slpits array into two``  ``// and then calls bucketSort() for two arrays.``  ``static` `void` `sortMixed(``double` `arr[], ``int` `n)``  ``{``    ``VectorNeg = ``new` `Vector<>();``    ``VectorPos = ``new` `Vector<>(); ` `    ``// traverse array elements``    ``for` `(``int` `i = ``0``; i < n; i++)``    ``{``      ``if` `(arr[i] < ``0``)` `        ``// store -Ve elements by``        ``// converting into +ve element``        ``Neg.add (-``1` `* arr[i]) ;``      ``else` `        ``// store +ve elements``        ``Pos.add (arr[i]) ;``    ``}``    ``bucketSort(Neg, (``int``)Neg.size());``    ``bucketSort(Pos, (``int``)Pos.size());` `    ``// First store elements of Neg[] array``    ``// by converting into -ve``    ``for` `(``int` `i = ``0``; i < Neg.size(); i++)``      ``arr[i] = -``1` `* Neg.get( Neg.size() -``1` `- i);` `    ``// store +ve element``    ``for``(``int` `j = Neg.size(); j < n; j++)``      ``arr[j] = Pos.get(j - Neg.size());``  ``}` `  ``/* Driver program to test above function */``  ``public` `static` `void` `main(String[] args)``  ``{``    ``double` `arr[] = {-``0.897``, ``0.565``, ``0.656``,``                    ``-``0.1234``, ``0``, ``0.3434``};``    ``int` `n = arr.length;``    ``sortMixed(arr, n);` `    ``System.out.print(``"Sorted array is \n"``);``    ``for` `(``int` `i = ``0``; i < n; i++)``      ``System.out.print(arr[i] + ``" "``);``  ``}``}` `// This code is contributed by Rajput-Ji`

## C#

 `// C# program to sort an array of positive``// and negative numbers using bucket sort``using` `System;``using` `System.Collections.Generic;` `public` `class` `GFG``{` `  ``// Function to sort []arr of size n using``  ``// bucket sort``  ``static` `void` `bucketSort(List arr, ``int` `n)``  ``{` `    ``// 1) Create n empty buckets` `    ``List []b = ``new` `List[n];``    ``for` `(``int` `i = 0; i < b.Length; i++)``      ``b[i] = ``new` `List();` `    ``// 2) Put array elements in different``    ``// buckets``    ``for` `(``int` `i = 0; i < n; i++)``    ``{``      ``int` `bi = (``int``)(n*arr[i]); ``// Index in bucket``      ``b[bi].Add(arr[i]);``    ``}` `    ``// 3) Sort individual buckets``    ``for` `(``int` `i = 0; i < n; i++)``      ``b[i].Sort();` `    ``// 4) Concatenate all buckets into []arr``    ``int` `index = 0;``    ``arr.Clear();``    ``for` `(``int` `i = 0; i < n; i++)``      ``for` `(``int` `j = 0; j < b[i].Count; j++)``        ``arr.Add(b[i][j]);``  ``}` `  ``// This function mainly slpits array into two``  ``// and then calls bucketSort() for two arrays.``  ``static` `void` `sortMixed(``double` `[]arr, ``int` `n)``  ``{``    ``ListNeg = ``new` `List();``    ``ListPos = ``new` `List(); ` `    ``// traverse array elements``    ``for` `(``int` `i = 0; i < n; i++)``    ``{``      ``if` `(arr[i] < 0)` `        ``// store -Ve elements by``        ``// converting into +ve element``        ``Neg.Add (-1 * arr[i]) ;``      ``else` `        ``// store +ve elements``        ``Pos.Add (arr[i]) ;``    ``}``    ``bucketSort(Neg, (``int``)Neg.Count);``    ``bucketSort(Pos, (``int``)Pos.Count);` `    ``// First store elements of Neg[] array``    ``// by converting into -ve``    ``for` `(``int` `i = 0; i < Neg.Count; i++)``      ``arr[i] = -1 * Neg[ Neg.Count -1 - i];` `    ``// store +ve element``    ``for``(``int` `j = Neg.Count; j < n; j++)``      ``arr[j] = Pos[j - Neg.Count];``  ``}` `  ``/* Driver program to test above function */``  ``public` `static` `void` `Main(String[] args)``  ``{``    ``double` `[]arr = {-0.897, 0.565, 0.656,``                    ``-0.1234, 0, 0.3434};``    ``int` `n = arr.Length;``    ``sortMixed(arr, n);` `    ``Console.Write(``"Sorted array is \n"``);``    ``for` `(``int` `i = 0; i < n; i++)``      ``Console.Write(arr[i] + ``" "``);``  ``}``}` `// This code is contributed by Rajput-Ji`

Output:

```Sorted array is
-0.897  -0.1234 0 0.3434 0.565 0.656 ```

This article is contributed by Nishant Singh . If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.