Given an array arr[] consisting of N integers, the task is to sort the given array by using Bubble Sort without using loops.
Examples:
Input: arr[] = {1, 3, 4, 2, 5}
Output: 1 2 3 4 5Input: arr[] = {1, 3, 4, 2}
Output: 1 2 3 4
Approach: The idea to implement Bubble Sort without using loops is based on the following observations:
- The sorting algorithm of Bubble Sort performs the following steps:
- The outer loop traverses the given array (N – 1) times.
- The inner loop traverses the array and swaps two adjacent elements if arr[i] > arr[i + 1], for every i over the range [0, N – 1].
- It can be observed that in every N – 1 iteration, the largest element over the range [0, N – 1 – i] shifts to the position (N – 1 – i) for every i over the range [0, N – 1].
- Therefore, the idea is to use recursion to avoid loops.
Follow the steps below to solve the problem:
- Consider the following base cases:
- If the array contains a single element, simply print the array.
- If the array contains two elements, swap the pair of elements (if required) to obtain a sorted sequence of array elements. Print the sorted array.
- Store the first two elements from the current array in variables, say a and b.
- Initialize an array, say bs[], to store the remaining array elements.
- Place the smaller value among a and b at the front of the current array.
- Recursively repeat the above steps with a new array formed by appending bs[] to the end of the larger value among a and b.
- Store the sorted list returned in a variable, say res[].
- Now, recursively repeat the above steps with a new array formed by appending res[] (excluding the last element) to the end of res[res.size() – 1] ( the last element ).
- After completing the above steps, print the returned list.
Below is the implementation of the above approach:
C++
// C++ program for the above approach #include<bits/stdc++.h> using namespace std;
// Function to implement bubble // sort without using loops vector< int > bubble_sort(vector< int > ar)
{ // Base Case: If array
// contains a single element
if (ar.size() <= 1)
return ar;
// Base Case: If array
// contains two elements
if (ar.size() == 2){
if (ar[0] < ar[1])
return ar;
else
return {ar[1], ar[0]};
}
// Store the first two elements
// of the list in variables a and b
int a = ar[0];
int b = ar[1];
// Store remaining elements
// in the list bs
vector< int > bs;
for ( int i = 2; i < ar.size(); i++)
bs.push_back(ar[i]);
// Store the list after
// each recursive call
vector< int > res;
// If a < b
if (a < b){
vector< int > temp1;
temp1.push_back(b);
for ( int i = 0; i < bs.size(); i++)
temp1.push_back(bs[i]);
vector< int > v = bubble_sort(temp1);
v.insert(v.begin(), a);
res = v;
}
// Otherwise, if b >= a
else {
vector< int > temp1;
temp1.push_back(a);
for ( int i = 0; i < bs.size(); i++)
temp1.push_back(bs[i]);
vector< int > v = bubble_sort(temp1);
v.insert(v.begin(), b);
res = v;
}
// Recursively call for the list
// less than the last element and
// and return the newly formed list
vector< int > pass;
for ( int i = 0; i < res.size() - 1; i++)
pass.push_back(res[i]);
vector< int > ans = bubble_sort(pass);
ans.push_back(res[res.size() - 1]);
return ans;
} // Driver Code int main()
{ vector< int > arr{1, 3, 4, 5, 6, 2};
vector< int > res = bubble_sort(arr);
// Print the array
for ( int i = 0; i < res.size(); i++)
cout << res[i] << " " ;
} // This code is contributed by ipg2016107. |
Java
// java program for the above approach import java.io.*;
import java.lang.*;
import java.util.*;
class GFG {
// Function to implement bubble
// sort without using loops
static ArrayList<Integer> bubble_sort(ArrayList<Integer> ar)
{
// Base Case: If array
// contains a single element
if (ar.size() <= 1 )
return ar;
// Base Case: If array
// contains two elements
if (ar.size() == 2 ) {
if (ar.get( 0 ) < ar.get( 1 ))
return ar;
else
return new ArrayList<Integer>(
Arrays.asList(ar.get( 1 ), ar.get( 0 )));
}
// Store the first two elements
// of the list in variables a and b
int a = ar.get( 0 );
int b = ar.get( 1 );
// Store remaining elements
// in the list bs
ArrayList<Integer> bs = new ArrayList<>();
for ( int i = 2 ; i < ar.size(); i++)
bs.add(ar.get(i));
// Store the list after
// each recursive call
ArrayList<Integer> res = new ArrayList<>();
// If a < b
if (a < b) {
ArrayList<Integer> temp1 = new ArrayList<>();
temp1.add(b);
for ( int i = 0 ; i < bs.size(); i++)
temp1.add(bs.get(i));
ArrayList<Integer> v = bubble_sort(temp1);
v.add( 0 , a);
res = v;
}
// Otherwise, if b >= a
else {
ArrayList<Integer> temp1 = new ArrayList<>();
temp1.add(a);
for ( int i = 0 ; i < bs.size(); i++)
temp1.add(bs.get(i));
ArrayList<Integer> v = bubble_sort(temp1);
v.add( 0 , b);
res = v;
}
// Recursively call for the list
// less than the last element and
// and return the newly formed list
ArrayList<Integer> pass = new ArrayList<>();
for ( int i = 0 ; i < res.size() - 1 ; i++)
pass.add(res.get(i));
ArrayList<Integer> ans = bubble_sort(pass);
ans.add(res.get(res.size() - 1 ));
return ans;
}
// Driver Code
public static void main(String[] args)
{
ArrayList<Integer> arr = new ArrayList<Integer>(
Arrays.asList( 1 , 3 , 4 , 5 , 6 , 2 ));
ArrayList<Integer> res = bubble_sort(arr);
// Print the array
for ( int i = 0 ; i < res.size(); i++)
System.out.print(res.get(i) + " " );
}
} // This code is contributed by Kingash. |
Python3
# Python3 program for the above approach # Function to implement bubble # sort without using loops def bubble_sort(ar):
# Base Case: If array
# contains a single element
if len (ar) < = 1 :
return ar
# Base Case: If array
# contains two elements
if len (ar) = = 2 :
return ar if ar[ 0 ] < ar[ 1 ] else [ar[ 1 ], ar[ 0 ]]
# Store the first two elements
# of the list in variables a and b
a, b = ar[ 0 ], ar[ 1 ]
# Store remaining elements
# in the list bs
bs = ar[ 2 :]
# Store the list after
# each recursive call
res = []
# If a < b
if a < b:
res = [a] + bubble_sort([b] + bs)
# Otherwise, if b >= a
else :
res = [b] + bubble_sort([a] + bs)
# Recursively call for the list
# less than the last element and
# and return the newly formed list
return bubble_sort(res[: - 1 ]) + res[ - 1 :]
# Driver Code arr = [ 1 , 3 , 4 , 5 , 6 , 2 ]
res = bubble_sort(arr)
# Print the array print ( * res)
|
C#
// C# program for the above approach using System;
using System.Collections.Generic;
class GFG{
// Function to implement bubble // sort without using loops static List< int > bubble_sort(List< int > ar)
{ // Base Case: If array
// contains a single element
List< int > temp = new List< int >();
if (ar.Count <= 1)
return ar;
// Base Case: If array
// contains two elements
if (ar.Count == 2)
{
if (ar[0] < ar[1])
return ar;
else
{
temp.Add(ar[1]);
temp.Add(ar[0]);
return temp;
}
}
// Store the first two elements
// of the list in variables a and b
int a = ar[0];
int b = ar[1];
// Store remaining elements
// in the list bs
List< int > bs = new List< int >();
for ( int i = 2; i < ar.Count; i++)
bs.Add(ar[i]);
// Store the list after
// each recursive call
List< int > res = new List< int >();
// If a < b
if (a < b)
{
List< int > temp1 = new List< int >();
temp1.Add(b);
for ( int i = 0; i < bs.Count; i++)
temp1.Add(bs[i]);
List< int > v = bubble_sort(temp1);
v.Insert(0, a);
res = v;
}
// Otherwise, if b >= a
else
{
List< int > temp1 = new List< int >();
temp1.Add(a);
for ( int i = 0; i < bs.Count; i++)
temp1.Add(bs[i]);
List< int > v = bubble_sort(temp1);
v.Insert(0, b);
res = v;
}
// Recursively call for the list
// less than the last element and
// and return the newly formed list
List< int > pass = new List< int >();
for ( int i = 0; i < res.Count - 1; i++)
pass.Add(res[i]);
List< int > ans = bubble_sort(pass);
ans.Add(res[res.Count - 1]);
return ans;
} // Driver Code public static void Main()
{ List< int > arr = new List< int >{ 1, 3, 4, 5, 6, 2 };
List< int > res = bubble_sort(arr);
// Print the array
for ( int i = 0; i < res.Count; i++)
Console.Write(res[i] + " " );
} } // This code is contributed by ukasp |
Javascript
<script> // JavaScript program for the above approach // Function to implement bubble // sort without using loops
function bubble_sort(ar)
{ // Base Case: If array
// contains a single element
if (ar.length <= 1)
return ar;
// Base Case: If array
// contains two elements
if (ar.length == 2) {
if (ar[0] < ar[1])
return ar;
else
return [ar[1], ar[0]];
}
// Store the first two elements
// of the list in variables a and b
let a = ar[0];
let b = ar[1];
// Store remaining elements
// in the list bs
let bs = [];
for (let i = 2; i < ar.length; i++)
bs.push(ar[i]);
// Store the list after
// each recursive call
let res = [];
// If a < b
if (a < b) {
let temp1 = [];
temp1.push(b);
for (let i = 0; i < bs.length; i++)
temp1.push(bs[i]);
let v = bubble_sort(temp1);
v.unshift(a);
res = v;
}
// Otherwise, if b >= a
else {
let temp1 = [];
temp1.push(a);
for (let i = 0; i < bs.length; i++)
temp1.push(bs[i]);
let v = bubble_sort(temp1);
v.unshift(b);
res = v;
}
// Recursively call for the list
// less than the last element and
// and return the newly formed list
let pass = [];
for (let i = 0; i < res.length - 1; i++)
pass.push(res[i]);
let ans = bubble_sort(pass);
ans.push(res[res.length - 1]);
return ans;
} // Driver Code let arr =[1, 3, 4, 5, 6, 2]; let res = bubble_sort(arr); document.write(res.join( " " ));
// This code is contributed by avanitrachhadiya2155 </script> |
Output:
1 2 3 4 5 6
Time Complexity: O(N2)
Auxiliary Space: O(N)