Open in App
Not now

# Burst Sort Algorithm

• Last Updated : 24 Jan, 2023

### What is BurstSort?

BurstSort is an advanced sorting algorithm developed by Tony P. Hoare and Charles M. Payne in 1997. It is a hybrid of two sorting algorithms, namely quicksort and radix sort. BurstSort has a faster running time than both of its parent algorithms and is particularly efficient for sorting strings.

### How Does BurstSort Work?

BurstSort combines the two sorting algorithms quicksort and radix sort in order to achieve a faster sorting time.
The algorithm works in two phases.

• The first phase is a quicksort step that sorts the elements in the list based on the first character of each element.
• The second phase is a radix sort step which sorts the elements in the list based on the remaining characters in each element.

### How is it different from the radix sort?

BurstSort is different from radix sort in that it is a hybrid algorithm. While radix sort works by sorting elements based on their individual characters, BurstSort first sorts the elements based on their first character and then uses radix sort to sort the remaining characters. This two-step approach makes BurstSort faster than radix sort.

### Illustration:

Let’s consider the following array as an example: arr[]   = [1, 5, 3, 7, 2, 4, 6]

Step 1: Split the array into two sub-arrays

Step 2: Sort the two sub-arrays:

Step 3: Merge the two sorted sub-arrays:

Follow the below steps to solve the problem:

• Split the array into two parts.
• BurstSort each part separately.
• Use mergeSort to join them.

Below is the implementation of the above approach:

## C++

 `#include ` `#include ` `using` `namespace` `std;`   `// Function to merge two sorted arrays into a single sorted` `// array` `vector<``int``> merge(vector<``int``>& arr1, vector<``int``>& arr2)` `{` `    ``vector<``int``> arr3;` `    ``int` `i = 0, j = 0;`   `    ``while` `(i < arr1.size() && j < arr2.size()) {` `        ``if` `(arr1[i] < arr2[j])` `            ``arr3.push_back(arr1[i++]);` `        ``else` `            ``arr3.push_back(arr2[j++]);` `    ``}`   `    ``while` `(i < arr1.size())` `        ``arr3.push_back(arr1[i++]);`   `    ``while` `(j < arr2.size())` `        ``arr3.push_back(arr2[j++]);`   `    ``return` `arr3;` `}`   `// Function to split an array into two sub-arrays` `vector > split(vector<``int``>& arr)` `{` `    ``vector > subarr(2);` `    ``int` `mid = arr.size() / 2;`   `    ``for` `(``int` `i = 0; i < mid; i++)` `        ``subarr[0].push_back(arr[i]);`   `    ``for` `(``int` `i = mid; i < arr.size(); i++)` `        ``subarr[1].push_back(arr[i]);`   `    ``return` `subarr;` `}`   `// Function to implement Burstsort algorithm` `vector<``int``> burstSort(vector<``int``>& arr)` `{` `    ``// Base case: if array size is 1, return it` `    ``if` `(arr.size() == 1)` `        ``return` `arr;`   `    ``// Split the array into two sub-arrays` `    ``vector > subarr = split(arr);`   `    ``// Sort the two sub-arrays` `    ``vector<``int``> arr1 = burstSort(subarr[0]);` `    ``vector<``int``> arr2 = burstSort(subarr[1]);`   `    ``// Merge the sorted arrays into a single sorted array` `    ``return` `merge(arr1, arr2);` `}`   `// Driver code` `int` `main()` `{` `    ``vector<``int``> arr = { 1, 5, 3, 7, 2, 4, 6 };`   `    ``arr = burstSort(arr);`   `    ``for` `(``int` `i = 0; i < arr.size(); i++)` `        ``cout << arr[i] << ``" "``;`   `    ``return` `0;` `}`

## Java

 `// Java code implementation` `import` `java.io.*;` `import` `java.util.*;`   `class` `GFG {`   `  ``// Function to merge two sorted arrays into a single` `  ``// sorted array` `  ``static` `List merge(List arr1,` `                             ``List arr2)` `  ``{` `    ``List arr3 = ``new` `ArrayList<>();` `    ``int` `i = ``0``, j = ``0``;`   `    ``while` `(i < arr1.size() && j < arr2.size()) {` `      ``if` `(arr1.get(i) < arr2.get(j))` `        ``arr3.add(arr1.get(i++));` `      ``else` `        ``arr3.add(arr2.get(j++));` `    ``}`   `    ``while` `(i < arr1.size())` `      ``arr3.add(arr1.get(i++));`   `    ``while` `(j < arr2.size())` `      ``arr3.add(arr2.get(j++));`   `    ``return` `arr3;` `  ``}`   `  ``// Function to split an array into two sub-arrays` `  ``static` `List > split(List arr)` `  ``{` `    ``List > subarr` `      ``= ``new` `ArrayList<>(Arrays.asList(` `        ``new` `ArrayList<>(), ``new` `ArrayList<>()));` `    ``int` `mid = arr.size() / ``2``;`   `    ``for` `(``int` `i = ``0``; i < mid; i++)` `      ``subarr.get(``0``).add(arr.get(i));`   `    ``for` `(``int` `i = mid; i < arr.size(); i++)` `      ``subarr.get(``1``).add(arr.get(i));`   `    ``return` `subarr;` `  ``}`   `  ``// Function to implement Burstsort algorithm` `  ``static` `List burstSort(List arr)` `  ``{` `    ``// Base case: if array size is 1, return it` `    ``if` `(arr.size() == ``1``)` `      ``return` `arr;`   `    ``// Split the array into two sub-arrays` `    ``List > subarr = split(arr);`   `    ``// Sort the two sub-arrays` `    ``List arr1 = burstSort(subarr.get(``0``));` `    ``List arr2 = burstSort(subarr.get(``1``));`   `    ``// Merge the sorted arrays into a single sorted` `    ``// array` `    ``return` `merge(arr1, arr2);` `  ``}`   `  ``public` `static` `void` `main(String[] args)` `  ``{` `    ``List arr = ``new` `ArrayList<>();` `    ``arr.add(``1``);` `    ``arr.add(``5``);` `    ``arr.add(``3``);` `    ``arr.add(``7``);` `    ``arr.add(``2``);` `    ``arr.add(``4``);` `    ``arr.add(``6``);`   `    ``arr = burstSort(arr);`   `    ``for` `(``int` `i = ``0``; i < arr.size(); i++)` `      ``System.out.print(arr.get(i) + ``" "``);`   `    ``System.out.println();` `  ``}` `}`   `// This code is contributed by lokesh.`

## Python3

 `def` `merge(arr1, arr2):` `    ``arr3 ``=` `[]` `    ``i, j ``=` `0``, ``0`   `    ``while` `i < ``len``(arr1) ``and` `j < ``len``(arr2):` `        ``if` `arr1[i] < arr2[j]:` `            ``arr3.append(arr1[i])` `            ``i ``+``=` `1` `        ``else``:` `            ``arr3.append(arr2[j])` `            ``j ``+``=` `1`   `    ``while` `i < ``len``(arr1):` `        ``arr3.append(arr1[i])` `        ``i ``+``=` `1`   `    ``while` `j < ``len``(arr2):` `        ``arr3.append(arr2[j])` `        ``j ``+``=` `1`   `    ``return` `arr3`   `def` `split(arr):` `    ``mid ``=` `len``(arr) ``/``/` `2` `    ``subarr1 ``=` `arr[:mid]` `    ``subarr2 ``=` `arr[mid:]` `    ``return` `subarr1, subarr2`   `def` `burstSort(arr):` `    ``# Base case: if array size is 1, return it` `    ``if` `len``(arr) ``=``=` `1``:` `        ``return` `arr`   `    ``# Split the array into two sub-arrays` `    ``subarr1, subarr2 ``=` `split(arr)`   `    ``# Sort the two sub-arrays` `    ``arr1 ``=` `burstSort(subarr1)` `    ``arr2 ``=` `burstSort(subarr2)`   `    ``# Merge the sorted arrays into a single sorted array` `    ``return` `merge(arr1, arr2)`   `arr ``=` `[``1``, ``5``, ``3``, ``7``, ``2``, ``4``, ``6``]` `arr ``=` `burstSort(arr)` `print``(arr)`   `#code by ksam24000`

## C#

 `using` `System;` `using` `System.Linq;` `using` `System.Collections.Generic;`   `public` `class` `GFG` `{`   `  ``// Function to merge two sorted arrays into a single` `  ``// sorted array` `  ``public` `static` `List<``int``> merge(List<``int``> arr1,` `                                ``List<``int``> arr2)` `  ``{` `    ``List<``int``> arr3 = ``new` `List<``int``>();` `    ``int` `i = 0, j = 0;`   `    ``while` `(i < arr1.Count && j < arr2.Count) {` `      ``if` `(arr1[i] < arr2[j])` `        ``arr3.Add(arr1[i++]);` `      ``else` `        ``arr3.Add(arr2[j++]);` `    ``}`   `    ``while` `(i < arr1.Count)` `      ``arr3.Add(arr1[i++]);`   `    ``while` `(j < arr2.Count)` `      ``arr3.Add(arr2[j++]);`   `    ``return` `arr3;` `  ``}`   `  ``// Function to split an array into two sub-arrays` `  ``public` `static` `List > split(List<``int``> arr)` `  ``{` `    ``List > subarr = ``new` `List >() {` `      ``new` `List<``int``>(), ``new` `List<``int``>()` `      ``};` `    ``int` `mid = arr.Count / 2;`   `    ``for` `(``int` `i = 0; i < mid; i++)` `      ``subarr[0].Add(arr[i]);`   `    ``for` `(``int` `i = mid; i < arr.Count; i++)` `      ``subarr[1].Add(arr[i]);`   `    ``return` `subarr;` `  ``}`   `  ``// Function to implement Burstsort algorithm` `  ``public` `static` `List<``int``> burstSort(List<``int``> arr)` `  ``{` `    ``// Base case: if array size is 1, return it` `    ``if` `(arr.Count == 1)` `      ``return` `arr;`   `    ``// Split the array into two sub-arrays` `    ``var` `subarr = split(arr);`   `    ``// Sort the two sub-arrays` `    ``var` `arr1 = burstSort(subarr[0]);` `    ``var` `arr2 = burstSort(subarr[1]);`   `    ``// Merge the sorted arrays into a single sorted` `    ``// array` `    ``return` `merge(arr1, arr2);` `  ``}`   `  ``// Driver code` `  ``static` `public` `void` `Main()` `  ``{` `    ``List<``int``> arr` `      ``= ``new` `List<``int``>() { 1, 5, 3, 7, 2, 4, 6 };`   `    ``arr = burstSort(arr);`   `    ``Console.WriteLine(``string``.Join(``" "``, arr));` `  ``}` `}`   `// This code is contributed by akashish__`

## Javascript

 `// Function to merge two sorted arrays into a single sorted` `// array` `function` `merge(arr1, arr2)` `{` `    ``let arr3=``new` `Array();` `    ``let i = 0, j = 0;`   `    ``while` `(i < arr1.length && j < arr2.length) {` `        ``if` `(arr1[i] < arr2[j])` `            ``arr3.push(arr1[i++]);` `        ``else` `            ``arr3.push(arr2[j++]);` `    ``}`   `    ``while` `(i < arr1.length)` `        ``arr3.push(arr1[i++]);`   `    ``while` `(j < arr2.length)` `        ``arr3.push(arr2[j++]);`   `    ``return` `arr3;` `}`   `// Function to split an array into two sub-arrays` `function` `split(arr)` `{` `    ``let subarr=``new` `Array(2);` `    ``for``(let i=0; i<2; i++)` `        ``subarr[i]=``new` `Array();` `    ``let mid = Math.floor(arr.length / 2);`   `    ``for` `(let i = 0; i < mid; i++)` `        ``subarr[0].push(arr[i]);`   `    ``for` `(let i = mid; i < arr.length; i++)` `        ``subarr[1].push(arr[i]);`   `    ``return` `subarr;` `}`   `// Function to implement Burstsort algorithm` `function` `burstSort(arr)` `{` `    ``// Base case: if array size is 1, return it` `    ``if` `(arr.length == 1)` `        ``return` `arr;`   `    ``// Split the array into two sub-arrays` `    ``let subarr = split(arr);`   `    ``// Sort the two sub-arrays` `    ``let arr1 = burstSort(subarr[0]);` `    ``let arr2 = burstSort(subarr[1]);`   `    ``// Merge the sorted arrays into a single sorted array` `    ``return` `merge(arr1, arr2);` `}`   `// Driver code` `let arr = [ 1, 5, 3, 7, 2, 4, 6 ];`   `arr = burstSort(arr);`   `for` `(let i = 0; i < arr.length; i++)` `    ``console.log(arr[i]+``" "``);`   ` ``// This code is contributed by poojaagarwal2.`

Output

`1 2 3 4 5 6 7 `

Time Complexity: O(N*log(N))
Auxiliary Space: O(N)

Related Articles:

My Personal Notes arrow_drop_up
Related Articles