Bead Sort | A Natural Sorting Algorithm - GeeksforGeeks

27 May, 2018
Also known as Gravity sort, this algorithm was inspired from natural phenomenons and was designed keeping in mind objects(or beads) falling under the influence of gravity.
The Idea: Positive numbers are represented by a set of beads like those on an abacus.
Sorting of {7, 2, 1, 4, 2} using Bead Sort. Beads fall down one by one if there is space below.
Like in the image above the beads represent the following numbers from top to bottom : 7, 2, 1, 4, 2. Now, imagine that this is the position of the beads at time t = 0 and with every passing second the beads will fall down by one level provided there is no bead already present below them. In such a case, they just rest upon the bead below them.(Rods are numbered from left to right and levels are numbered from the bottom as 1, 2, .......... n.)Now, at time t = 1 the bottom 2 beads in the first two rods from the left stay at their positions while the second bead from the top from the second rod comes down by one level to rest upon the bead below it. The beads in the 3rd and 4th rod at level 2 come down to level 1. Simultaneously, the beads in the rods 3 to 7 come down by one level. Now, the numbers from top to bottom become: 2, 6, 2, 2, 4.This goes on till time t = 4 where we get the sorted sequence of numbers from top to bottom which is: 1, 2, 2, 4, 7.
Like in the image above the beads represent the following numbers from top to bottom : 7, 2, 1, 4, 2. Now, imagine that this is the position of the beads at time t = 0 and with every passing second the beads will fall down by one level provided there is no bead already present below them. In such a case, they just rest upon the bead below them.(Rods are numbered from left to right and levels are numbered from the bottom as 1, 2, .......... n.)
Now, at time t = 1 the bottom 2 beads in the first two rods from the left stay at their positions while the second bead from the top from the second rod comes down by one level to rest upon the bead below it. The beads in the 3rd and 4th rod at level 2 come down to level 1. Simultaneously, the beads in the rods 3 to 7 come down by one level. Now, the numbers from top to bottom become: 2, 6, 2, 2, 4.
This goes on till time t = 4 where we get the sorted sequence of numbers from top to bottom which is: 1, 2, 2, 4, 7.
Why is it called so?
When one tries to visualize this algorithm it appears as if beads are falling down under the influence of gravity to the bottom-most level they can reach resulting the set of beads being arranged in a descending order from the ground up. If you are having trouble visualizing this visit this link
Lets say that we have to sort the numbers 3, 4, 1, 2. The above algorithm would work like this.
Bead Sort Working
Below is the code, try to implement it yourself before looking at the code.
The Code:
// C++ program to implement gravity/bead sort#include <bits/stdc++.h>using namespace std;  #define BEAD(i, j) beads[i * max + j]  // function to perform the above algorithmvoid beadSort(int *a, int len){    // Find the maximum element    int max = a[0];    for (int i = 1; i < len; i++)        if (a[i] > max)           max = a[i];      // allocating memory    unsigned char beads[max*len];    memset(beads, 0, sizeof(beads));      // mark the beads    for (int i = 0; i < len; i++)        for (int j = 0; j < a[i]; j++)            BEAD(i, j) = 1;      for (int j = 0; j < max; j++)    {        // count how many beads are on each post        int sum = 0;        for (int i=0; i < len; i++)        {            sum += BEAD(i, j);            BEAD(i, j) = 0;        }          // Move beads down        for (int i = len - sum; i < len; i++)            BEAD(i, j) = 1;    }      // Put sorted values in array using beads    for (int i = 0; i < len; i++)    {        int j;        for (j = 0; j < max && BEAD(i, j); j++);          a[i] = j;    }}  // driver function to test the algorithmint main(){    int a[] = {5, 3, 1, 7, 4, 1, 1, 20};    int len = sizeof(a)/sizeof(a[0]);      beadSort(a, len);      for (int i = 0; i < len; i++)        printf("%d ", a[i]);      return 0;}
Output:
1 1 1 3 4 5 7 20

Time Complexity:The algorithm’s run–time complexity ranges from O(1) to O(S) (S is the sum of the input integers) depending on the user’s perspective. Finally, three possible implementations are suggested.
O(1) : Dropping all beads together as a single (simultaneous) operation. This complexity cannot be implemented in practice.O(): In a realistic physical model that uses gravity, the time it takes to let the beads fall is proportional to the square root of the maximum height, which is proportional to n.O(n) : Dropping the row of beads in the frame (representing a number) as a distinct operation since the number of rows is equal to n.O(S) : Dropping each and every bead’ as a separate operation since S is the sum of all the beads.
O(1) : Dropping all beads together as a single (simultaneous) operation. This complexity cannot be implemented in practice.
O(): In a realistic physical model that uses gravity, the time it takes to let the beads fall is proportional to the square root of the maximum height, which is proportional to n.
O(n) : Dropping the row of beads in the frame (representing a number) as a distinct operation since the number of rows is equal to n.
O(S) : Dropping each and every bead’ as a separate operation since S is the sum of all the beads.
Like the Pigeonhole sort, bead sort is unusual in that in worst case it can perform faster than O(), the fastest performance possible for a comparison sort in worst case. This is possible because the key for a bead sort is always a positive integer and bead sort exploits its structure.
Space Complexity: Bead sort is the record-holder as for waste. The costs for the extra memory exceed the costs for storing the array itself. Its memory complexity is O()
References:
https://www.wikiwand.com/en/Bead_sort
https://kukuruku.co/post/bead-sort/
https://rosettacode.org/wiki/Sorting_algorithms/Bead_sort
https://www.cs.auckland.ac.nz/~mjd/misc/BeadSort5.pdf
This article is contributed by Palash Nigam . 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.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
Pigeonhole Principle
Sorting
Sorting
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
C++ Program for QuickSort
Stability in sorting algorithms
Quickselect Algorithm
Quick Sort vs Merge Sort
QuickSort using Random Pivoting
Sorting in Java
Check if two arrays are equal or not
Binary Insertion Sort
Recursive Bubble Sort
Sort a nearly sorted (or K sorted) array