Sort an array using Bubble Sort without using loops - GeeksforGeeks

22 Jun, 2021

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 5
Input: 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].


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.


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++
Java
Python3
C#
Javascript
 

 
 










// 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 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 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# 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






 

 
 










<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)
ipg2016107
ukasp
Kingash
avanitrachhadiya2155

array-rearrange


BubbleSort


Arrays


Recursion


Sorting

Writing code in comment? 
                                    Please use ide.geeksforgeeks.org, 
                                    generate link and share the link here.
                                
Stack Data Structure (Introduction and Program)
Top 50 Array Coding Problems for Interviews
Introduction to Arrays
Multidimensional Arrays in Java
Given an array A[] and a number x, check for pair in A[] with sum as x (aka Two Sum)
Write a  program to print all permutations of a given string
Given an array A[] and a number x, check for pair in A[] with sum as x (aka Two Sum)
Recursion
Program for Tower of Hanoi
Program for Sum of the digits of a given number