DSA using Java - Bubble Sort

Overview

Bubble sort is a simple sorting algorithm. This sorting algorithm is comparison based algorithm in which each pair of adjacent elements is compared and elements are swapped if they are not in order. This algorithm is not suitable for large data sets as its average and worst case complexity are of O(n²) where n are no. of items.

Pseudocode

procedure bubbleSort( A : array of items )
   for i = 1 to length(A) - 1 inclusive do:
      swapped = false
      for j = 1 to length(A) - 1 inclusive do:
         /* compare the adjacent elements */   
         if A[i-1] > A[i] then
            /* swap them */
            swap( A[i-1], A[i] )		 
            swapped = true
         end if
      end for
      /*if no number was swapped that means 
      array is sorted now, break the loop.*/
      if(!swapped) then
         break	 
   end for
end procedure

Demo Program

package com.tutorialspoint.simplesort;

import java.util.Arrays;

public class BubbleSortDemo {
    
   public static void main(String[] args){
      int[] sourceArray = {4,6,3,2,1,9,7};
      System.out.println("Input Array: " 
      + Arrays.toString(sourceArray));
      printline(50);
      System.out.println("Output Array: " 
      + Arrays.toString(bubbleSort(sourceArray)));
      printline(50);
   }    

   public static void printline(int count){
      for(int i=0;i <count-1;i++){
         System.out.print("=");
      }
      System.out.println("=");
   }

   public static int[] bubbleSort(int[] intArray){

      int temp;
      boolean swapped = false;       
      // loop through all numbers 
      for(int i=0; i < intArray.length-1; i++){ 
         swapped = false;
         // loop through numbers falling ahead 
         for(int j=1; j < intArray.length-i; j++){
            System.out.println("     Items compared: [ " 
            + intArray[j-1] + ", " + intArray[j] +" ]" ); 
            // check if next number is lesser than current no
            //   swap the numbers. 
            //  (Bubble up the highest number) 
            if(intArray[j-1] > intArray[j]){
               temp=intArray[j-1];
               intArray[j-1] = intArray[j];
               intArray[j] = temp;
               swapped = true;
            }           
         }
         // if no number was swapped that means 
         //   array is sorted now, break the loop. 
         if(!swapped){
            break;
         }
         System.out.println("Iteration "+(i+1) +"#: " 
                            + Arrays.toString(intArray));
         }            
      return intArray;
   }    
}

If we compile and run the above program then it would produce following result −

Input Array: [4, 6, 3, 2, 1, 9, 7]
==================================================
     Items compared: [ 4, 6 ]
     Items compared: [ 6, 3 ]
     Items compared: [ 6, 2 ]
     Items compared: [ 6, 1 ]
     Items compared: [ 6, 9 ]
     Items compared: [ 9, 7 ]
Iteration 1#: [4, 3, 2, 1, 6, 7, 9]
     Items compared: [ 4, 3 ]
     Items compared: [ 4, 2 ]
     Items compared: [ 4, 1 ]
     Items compared: [ 4, 6 ]
     Items compared: [ 6, 7 ]
Iteration 2#: [3, 2, 1, 4, 6, 7, 9]
     Items compared: [ 3, 2 ]
     Items compared: [ 3, 1 ]
     Items compared: [ 3, 4 ]
     Items compared: [ 4, 6 ]
Iteration 3#: [2, 1, 3, 4, 6, 7, 9]
     Items compared: [ 2, 1 ]
     Items compared: [ 2, 3 ]
     Items compared: [ 3, 4 ]
Iteration 4#: [1, 2, 3, 4, 6, 7, 9]
     Items compared: [ 1, 2 ]
     Items compared: [ 2, 3 ]
Output Array: [1, 2, 3, 4, 6, 7, 9]
==================================================