Posted on by Kalkicode
Code Sorting

# Recursive Bubble Sort

Bubble sort is a simple sorting algorithm that repeatedly steps through the list to be sorted, compares adjacent elements and swaps them if they are in the wrong order. The pass through the list is repeated until the list is sorted.

The Recursive Bubble Sort is a variation of the traditional Bubble Sort algorithm. Bubble Sort is a simple comparison-based sorting algorithm that repeatedly steps through the list to be sorted, compares adjacent elements, and swaps them if they are in the wrong order. The process is repeated until the entire list is sorted.

Recursive Bubble Sort, as the name suggests, employs a recursive approach to perform the sorting. In the recursive version, we perform one pass of the Bubble Sort and then call the recursive function on the reduced subarray without the last element (since it is already in its correct position). This process continues until the entire array is sorted.

## Problem Statement

Given an array of integers, we want to sort it in ascending order using Recursive Bubble Sort.

## Example

Let's take an example to illustrate the Recursive Bubble Sort process:

Given Array: [5, 2, 8, 1, 6]

1. Initial array: [5, 2, 8, 1, 6]
2. Recursive pass 1: [2, 5, 1, 6, 8]
3. Recursive pass 2: [2, 1, 5, 6, 8]
4. Recursive pass 3: [1, 2, 5, 6, 8]

The array is now sorted in ascending order.

## Pseudocode

The pseudocode for Recursive Bubble Sort is as follows:

``````// Function for Recursive Bubble Sort
recursive_bubble_sort(record[], size):
if size <= 0:
return

for i = 0 to size - 2:
if record[i] > record[i + 1]:
swap record[i] and record[i + 1]

recursive_bubble_sort(record, size - 1)
``````

## Algorithm Explanation:

2. Call the `recursive_bubble_sort` function with the array and its size.
3. In the `recursive_bubble_sort` function, check if the size of the array is less than or equal to 0. If so, return (base case).
4. Run a loop from 0 to size - 2 (size - 1 is excluded to avoid out-of-bounds access).
5. Inside the loop, compare adjacent elements at indices i and i + 1. If the current element is greater than the next element, swap them.
6. After completing one pass of the Bubble Sort, call the `recursive_bubble_sort` function recursively with the array and size - 1, effectively excluding the last element from further sorting.
7. The recursion continues until the size becomes 1, and the array is sorted.

## Explanation of the Code:

1. The code starts with the `main` function where the initial array `record` is defined.
2. The size of the array is calculated using `sizeof(record) / sizeof(record[0])`.
3. The `display` function is defined to print the elements of the array.
4. The unsorted array is displayed before sorting using `display(record, size)`.
5. The `bubble_sort` function is called to sort the array.
6. The sorted array is displayed after sorting using `display(record, size)`.

## Program Solution

``````//C Program
//Recursive Bubble Sort
#include <stdio.h>

//Display array elements
void display(int record[], int size)
{
for (int i = 0; i < size; ++i)
{
printf("%d ", record[i]);
}
printf("\n");
}
//Perform bubble sort in given array
void bubble_sort(int record[], int size)
{
if (size <= 0)
{
//When have no more than one element
return;
}
int temp = 0;
for (int i = 0; i < size - 1; ++i)
{
if (record[i] > record[i + 1])
{
//When need to swap two adjacent elements
temp = record[i];
record[i] = record[i + 1];
record[i + 1] = temp;
}
}
bubble_sort(record, size - 1);
}
int main()
{
//Assume given array elements
int record[] = {
2 , 8 , 1 , 5 , 0 , 9 , 3 , 7 , 2
};
//Get the size of array
int size = sizeof(record) / sizeof(record[0]);
//Before sort
display(record, size);
bubble_sort(record, size);
//After sort
display(record, size);
return 0;
}``````

#### Output

``````2 8 1 5 0 9 3 7 2
0 1 2 2 3 5 7 8 9``````
``````//Java Program
//Recursive Bubble Sort
class MySort
{
//Display array elements
public void display(int[] record, int size)
{
for (int i = 0; i < size; ++i)
{
System.out.print(" " + record[i]);
}
System.out.print("\n");
}
//Perform bubble sort in given array
public void bubble_sort(int[] record, int size)
{
if (size <= 0)
{
//When have no more than one element
return;
}
int temp = 0;
for (int i = 0; i < size - 1; ++i)
{
if (record[i] > record[i + 1])
{
//When need to swap two adjacent elements
temp = record[i];
record[i] = record[i + 1];
record[i + 1] = temp;
}
}
bubble_sort(record, size - 1);
}
public static void main(String[] args)
{
MySort obj = new MySort();
//Assume given array elements
int[] record = {
2,
8,
1,
5,
0,
9,
3,
7,
2
};
//Get the size of array
int size = record.length;
//Before sort
obj.display(record, size);
obj.bubble_sort(record, size);
//After sort
obj.display(record, size);
}
}``````

#### Output

`````` 2 8 1 5 0 9 3 7 2
0 1 2 2 3 5 7 8 9``````
``````//Include header file
#include <iostream>
using namespace std;

//C++ Program
//Recursive Bubble Sort
class MySort
{
public:
//Display array elements
void display(int record[], int size)
{
for (int i = 0; i < size; ++i)
{
cout << " " << record[i];
}
cout << "\n";
}
//Perform bubble sort in given array
void bubble_sort(int record[], int size)
{
if (size <= 0)
{
//When have no more than one element
return;
}
int temp = 0;
for (int i = 0; i < size - 1; ++i)
{
if (record[i] > record[i + 1])
{
//When need to swap two adjacent elements
temp = record[i];
record[i] = record[i + 1];
record[i + 1] = temp;
}
}
this->bubble_sort(record, size - 1);
}
};
int main()
{
MySort obj = MySort();
int record[] = {
2 , 8 , 1 , 5 , 0 , 9 , 3 , 7 , 2
};
//Get the size of array
int size = sizeof(record) / sizeof(record[0]);
//Before sort
obj.display(record, size);
obj.bubble_sort(record, size);
//After sort
obj.display(record, size);
return 0;
}``````

#### Output

`````` 2 8 1 5 0 9 3 7 2
0 1 2 2 3 5 7 8 9``````
``````//Include namespace system
using System;
//C# Program
//Recursive Bubble Sort
class MySort
{
//Display array elements
public void display(int[] record, int size)
{
for (int i = 0; i < size; ++i)
{
Console.Write(" " + record[i]);
}
Console.Write("\n");
}
//Perform bubble sort in given array
public void bubble_sort(int[] record, int size)
{
if (size <= 0)
{
//When have no more than one element
return;
}
int temp = 0;
for (int i = 0; i < size - 1; ++i)
{
if (record[i] > record[i + 1])
{
//When need to swap two adjacent elements
temp = record[i];
record[i] = record[i + 1];
record[i + 1] = temp;
}
}
bubble_sort(record, size - 1);
}
public static void Main(String[] args)
{
MySort obj = new MySort();
int[] record = {
2 , 8 , 1 , 5 , 0 , 9 , 3 , 7 , 2
};
//Get the size of array
int size = record.Length;
//Before sort
obj.display(record, size);
obj.bubble_sort(record, size);
//After sort
obj.display(record, size);
}
}``````

#### Output

`````` 2 8 1 5 0 9 3 7 2
0 1 2 2 3 5 7 8 9``````
``````<?php
//Php Program
//Recursive Bubble Sort
class MySort
{
//Display array elements
public	function display( \$record, \$size)
{
for (\$i = 0; \$i < \$size; ++\$i)
{
echo " ". \$record[\$i];
}
echo "\n";
}
//Perform bubble sort in given array
public	function bubble_sort( & \$record, \$size)
{
if (\$size <= 0)
{
//When have no more than one element
return;
}
\$temp = 0;
for (\$i = 0; \$i < \$size - 1; ++\$i)
{
if (\$record[\$i] > \$record[\$i + 1])
{
//When need to swap two adjacent elements
\$temp = \$record[\$i];
\$record[\$i] = \$record[\$i + 1];
\$record[\$i + 1] = \$temp;
}
}
\$this->bubble_sort(\$record, \$size - 1);
}
}

function main()
{
\$obj = new MySort();
//Assume given array elements
\$record = array(2, 8, 1, 5, 0, 9, 3, 7, 2);
//Get the size of array
\$size = count(\$record);
//Before sort
\$obj->display(\$record, \$size);
\$obj->bubble_sort(\$record, \$size);
//After sort
\$obj->display(\$record, \$size);
}
main();``````

#### Output

`````` 2 8 1 5 0 9 3 7 2
0 1 2 2 3 5 7 8 9``````
``````//Node Js Program
//Recursive Bubble Sort
class MySort
{
//Display array elements
display(record, size)
{
for (var i = 0; i < size; ++i)
{
process.stdout.write(" " + record[i]);
}
process.stdout.write("\n");
}
//Perform bubble sort in given array
bubble_sort(record, size)
{
if (size <= 0)
{
//When have no more than one element
return;
}
var temp = 0;
for (var i = 0; i < size - 1; ++i)
{
if (record[i] > record[i + 1])
{
//When need to swap two adjacent elements
temp = record[i];
record[i] = record[i + 1];
record[i + 1] = temp;
}
}
this.bubble_sort(record, size - 1);
}
}

function main()
{
var obj = new MySort();
//Assume given array elements
var record = [2, 8, 1, 5, 0, 9, 3, 7, 2];
//Get the size of array
var size = record.length;
//Before sort
obj.display(record, size);
obj.bubble_sort(record, size);
//After sort
obj.display(record, size);
}
main();``````

#### Output

`````` 2 8 1 5 0 9 3 7 2
0 1 2 2 3 5 7 8 9``````
``````# Python 3 Program
# Recursive Bubble Sort
class MySort :
# Display array elements
def display(self, record, size) :
i = 0
while (i < size) :
print(" ", record[i], end = "")
i += 1

print("\n", end = "")

# Perform bubble sort in given array
def bubble_sort(self, record, size) :
if (size <= 0) :
# When have no more than one element
return

temp = 0
i = 0
while (i < size - 1) :
if (record[i] > record[i + 1]) :
# When need to swap two adjacent elements
temp = record[i]
record[i] = record[i + 1]
record[i + 1] = temp

i += 1

self.bubble_sort(record, size - 1)

def main() :
obj = MySort()
# Assume given array elements
record = [2, 8, 1, 5, 0, 9, 3, 7, 2]
# Get the size of array
size = len(record)
# Before sort
obj.display(record, size)
obj.bubble_sort(record, size)
# After sort
obj.display(record, size)

if __name__ == "__main__": main()``````

#### Output

``````  2  8  1  5  0  9  3  7  2
0  1  2  2  3  5  7  8  9``````
``````# Ruby Program
# Recursive Bubble Sort
class MySort

# Display array elements
def display(record, size)

i = 0
while (i < size)

print(" ", record[i])
i += 1
end
print("\n")
end
# Perform bubble sort in given array
def bubble_sort(record, size)

if (size <= 0)

# When have no more than one element
return
end
temp = 0
i = 0
while (i < size - 1)

if (record[i] > record[i + 1])

# When need to swap two adjacent elements
temp = record[i]
record[i] = record[i + 1]
record[i + 1] = temp
end
i += 1
end
self.bubble_sort(record, size - 1)
end
end
def main()

obj = MySort.new()
# Assume given array elements
record = [2, 8, 1, 5, 0, 9, 3, 7, 2]
# Get the size of array
size = record.length
# Before sort
obj.display(record, size)
obj.bubble_sort(record, size)
# After sort
obj.display(record, size)
end
main()``````

#### Output

`````` 2 8 1 5 0 9 3 7 2
0 1 2 2 3 5 7 8 9
``````
``````//Scala Program
//Recursive Bubble Sort
class MySort
{
//Display array elements
def display(record: Array[Int], size: Int): Unit = {
var i: Int = 0;
while (i < size)
{
print(" " + record(i));
i += 1;
}
print("\n");
}
//Perform bubble sort in given array
def bubble_sort(record: Array[Int], size: Int): Unit = {
if (size <= 0)
{
//When have no more than one element
return;
}
var temp: Int = 0;
var i: Int = 0;
while (i < size - 1)
{
if (record(i) > record(i + 1))
{
//When need to swap two adjacent elements
temp = record(i);
record(i) = record(i + 1);
record(i + 1) = temp;
}
i += 1;
}
bubble_sort(record, size - 1);
}
}
object Main
{
def main(args: Array[String]): Unit = {
var obj: MySort = new MySort();
//Assume given array elements
var record: Array[Int] = Array(2, 8, 1, 5, 0, 9, 3, 7, 2);
//Get the size of array
var size: Int = record.length;
//Before sort
obj.display(record, size);
obj.bubble_sort(record, size);
//After sort
obj.display(record, size);
}
}``````

#### Output

`````` 2 8 1 5 0 9 3 7 2
0 1 2 2 3 5 7 8 9``````
``````//Swift Program
//Recursive Bubble Sort
class MySort
{
//Display array elements
func display(_ record: [Int], _ size: Int)
{
var i: Int = 0;
while (i < size)
{
print(" ", record[i], terminator: "");
i += 1;
}
print("\n", terminator: "");
}
//Perform bubble sort in given array
func bubble_sort(_ record: inout[Int], _ size: Int)
{
if (size <= 0)
{
//When have no more than one element
return;
}
var temp: Int = 0;
var i: Int = 0;
while (i < size - 1)
{
if (record[i] > record[i + 1])
{
//When need to swap two adjacent elements
temp = record[i];
record[i] = record[i + 1];
record[i + 1] = temp;
}
i += 1;
}
self.bubble_sort(&record, size - 1);
}
}
func main()
{
let obj: MySort = MySort();
//Assume given array elements
var record: [Int] = [2, 8, 1, 5, 0, 9, 3, 7, 2];
//Get the size of array
let size: Int = record.count;
//Before sort
obj.display(record, size);
obj.bubble_sort(&record, size);
//After sort
obj.display(record, size);
}
main();``````

#### Output

``````  2  8  1  5  0  9  3  7  2
0  1  2  2  3  5  7  8  9``````

## Resultant Output Explanation:

For the given input array [2, 8, 1, 5, 0, 9, 3, 7, 2], the output of the code will be:

``````Before sort: 2 8 1 5 0 9 3 7 2
After sort: 0 1 2 2 3 5 7 8 9
``````

## Time Complexity

The time complexity of Recursive Bubble Sort is the same as that of the traditional Bubble Sort, which is O(n^2) in the worst case. The worst case occurs when the array is sorted in reverse order, and every element needs to be compared and swapped in each pass. However, the average case time complexity is also O(n^2). Although Recursive Bubble Sort provides an interesting recursive approach, it doesn't improve the time complexity of the algorithm. Therefore, it is considered inefficient for large arrays and is mainly used for educational purposes or when dealing with very small datasets.

## Comment

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.

Categories
Relative Post