Sort an array using Bubble Sort without using loops

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 loopsvector<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 Codeint 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 approachimport 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 loopsdef 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 arrayprint(*res)
// C# program for the above approachusing System;using System.Collections.Generic; class GFG{ // Function to implement bubble// sort without using loopsstatic 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 Codepublic 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 loopsfunction 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 Codelet  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
Arrays
Recursion
Sorting
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Maximum and minimum of an array using minimum number of comparisons
Multidimensional Arrays in Java
Given an array A[] and a number x, check for pair in A[] with sum as x (aka Two Sum)
Introduction to Arrays
K'th Smallest/Largest Element in Unsorted Array | Set 1
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
Backtracking | Introduction