Add Bubble Sort

Author: imazizbohra

.idea/uiDesigner.xml

@@ -1,5 +1,14 @@
+import sort.SortingAlgorithms;
+import sort.SortingService;
+
+import java.util.Arrays;
+
 public class Main {
     public static void main(String[] args) {
-        System.out.println("Hello world!");
+        int[] arr = {5, 3, 4, 2, 1};
+
+        SortingService.sort(arr, SortingAlgorithms.BUBBLE_SORT);
+
+        System.out.println(Arrays.toString(arr));
     }
 }

src/Main.java

@@ -0,0 +1,5 @@
+# Sorting Algorithms In Java
+
+1. Bubble Sort
+2. Selection Sort
+3. Insertion Sort

src/README.md

@@ -0,0 +1,7 @@
+package sort;
+
+public enum SortingAlgorithms {
+    BUBBLE_SORT,
+    SELECTION_SORT,
+    INSERTION_SORT
+}

src/sort/SortingAlgorithms.java

@@ -0,0 +1,17 @@
+package sort;
+
+import sort.bubble.BubbleSort;
+
+public class SortingService {
+    public static void sort(int[] arr) {
+        BubbleSort.sort(arr);
+    }
+
+    public static void sort(int[] arr, SortingAlgorithms sortAlgorithms) {
+        switch (sortAlgorithms) {
+            case BUBBLE_SORT:
+                BubbleSort.sort(arr);
+                break;
+        }
+    }
+}

src/sort/SortingService.java

@@ -0,0 +1,31 @@
+package sort.bubble;
+
+public class BubbleSort {
+    public static void sort(int[] arr) {
+        int n = arr.length;
+
+        // loop for n-1 passes
+        for (int i = 0; i < (n - 1); i++) {
+
+            // optimization for already sorted array
+            boolean swapped = false;
+
+            // loop for all the adjacent elements
+            for (int j = 0; j < (n - i - 1); j++) {
+                // compare adjacent element
+                // swap if out of order
+                if (arr[j] > arr[j + 1]) {
+                    int temp = arr[j];
+                    arr[j] = arr[j + 1];
+                    arr[j + 1] = temp;
+
+                    // swapped happened means array is not sorted
+                    swapped = true;
+                }
+            }
+
+            if (!swapped)
+                return;
+        }
+    }
+}

src/sort/bubble/BubbleSort.java

@@ -0,0 +1,28 @@
+# Bubble Sort
+
+### Time Complexity
+
+---
+1. Worst Case : O(n<sup>2</sup>). The worst case occurs when we want to sort a list in ascending order, but it is arranged in descending order.
+2. Best Case : O(n). The average case is when the list is arranged in a jumbled order.
+3. Average Case : O(n). The best case occurs when the list is already arranged in the desired order.
+
+### Space Complexity
+
+---
+1. Space complexity is O(1) because an extra variable is used for swapping.
+2. In the optimized bubble sort algorithm, two extra variables are used. Hence, the space complexity will be O(2).
+
+### Properties
+1. Comparison Based
+2. Stable
+3. Inplace
+
+### Advantages
+1. Bubble sort is easy to understand and implement.
+2. It does not require any additional memory space.
+3. It is a stable sorting algorithm, meaning that elements with the same key value maintain their relative order in the sorted output.
+
+### Disadvantages
+1. Bubble sort has a time complexity of O(n<sup>2</sup>) which makes it very slow for large data sets.
+2. Bubble sort is a comparison-based sorting algorithm, which means that it requires a comparison operator to determine the relative order of elements in the input data set. It can limit the efficiency of the algorithm in certain cases.