Merge pull request #3630 from Ishitamukherjee2004/main

Bubble Sort from gfg is added

Author: ajay-dhangar

dsa-solutions/gfg-solutions/Easy problems/Bubble-Sort.md

@@ -0,0 +1,263 @@
+---
+id: bubble-sort
+title: Bubble Sort
+sidebar_label: Bubble-Sort
+tags:
+  - Sorting
+  - Algorithms
+description: "This tutorial covers the solution to the Bubble Sort problem from the GeeksforGeeks."
+---
+## Problem Description
+
+Given an unsorted array of size `N`, use bubblesort to sort `arr[]` in increasing order.
+
+## Examples
+
+**Example 1:**
+
+```
+Input: 
+N = 5
+arr[] = {4, 1, 3, 9, 7}
+Output: 
+1 3 4 7 9
+```
+
+**Example 2:**
+
+```
+Input:
+N = 10 
+arr[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1}
+Output: 
+1 2 3 4 5 6 7 8 9 10
+```
+
+## Your Task
+You don't have to read input or print anything. Your task is to complete the function bubblesort() which takes the array and it's size as input and sorts the array using bubble sort algorithm.
+
+Expected Time Complexity: O(N^2)
+
+Expected Auxiliary Space: O(1)
+
+## Constraints
+
+* `1 ≤ N ≤ 10^3`
+
+## Problem Explanation
+
+The task is to traverse the array and sort the array using bubble sort.
+
+## Code Implementation
+
+### C++ Solution
+
+```cpp
+// Optimized implementation of Bubble sort
+#include <bits/stdc++.h>
+using namespace std;
+
+// An optimized version of Bubble Sort
+void bubbleSort(int arr[], int n)
+{
+    int i, j;
+    bool swapped;
+    for (i = 0; i < n - 1; i++) {
+        swapped = false;
+        for (j = 0; j < n - i - 1; j++) {
+            if (arr[j] > arr[j + 1]) {
+                swap(arr[j], arr[j + 1]);
+                swapped = true;
+            }
+        }
+
+        // If no two elements were swapped
+        // by inner loop, then break
+        if (swapped == false)
+            break;
+    }
+}
+
+// Function to print an array
+void printArray(int arr[], int size)
+{
+    int i;
+    for (i = 0; i < size; i++)
+        cout << " " << arr[i];
+}
+
+// Driver program to test above functions
+int main()
+{
+    int arr[] = { 64, 34, 25, 12, 22, 11, 90 };
+    int N = sizeof(arr) / sizeof(arr[0]);
+    bubbleSort(arr, N);
+    cout << "Sorted array: \n";
+    printArray(arr, N);
+    return 0;
+}
+
+
+```
+
+```java
+// Optimized java implementation of Bubble sort
+
+import java.io.*;
+
+class GFG {
+    
+    // An optimized version of Bubble Sort
+    static void bubbleSort(int arr[], int n)
+    {
+        int i, j, temp;
+        boolean swapped;
+        for (i = 0; i < n - 1; i++) {
+            swapped = false;
+            for (j = 0; j < n - i - 1; j++) {
+                if (arr[j] > arr[j + 1]) {
+                    
+                    // Swap arr[j] and arr[j+1]
+                    temp = arr[j];
+                    arr[j] = arr[j + 1];
+                    arr[j + 1] = temp;
+                    swapped = true;
+                }
+            }
+
+            // If no two elements were
+            // swapped by inner loop, then break
+            if (swapped == false)
+                break;
+        }
+    }
+
+    // Function to print an array
+    static void printArray(int arr[], int size)
+    {
+        int i;
+        for (i = 0; i < size; i++)
+            System.out.print(arr[i] + " ");
+        System.out.println();
+    }
+
+    // Driver program
+    public static void main(String args[])
+    {
+        int arr[] = { 64, 34, 25, 12, 22, 11, 90 };
+        int n = arr.length;
+        bubbleSort(arr, n);
+        System.out.println("Sorted array: ");
+        printArray(arr, n);
+    }
+}
+
+
+
+```
+
+```python
+# Optimized Python program for implementation of Bubble Sort
+
+
+def bubbleSort(arr):
+    n = len(arr)
+    
+    # Traverse through all array elements
+    for i in range(n):
+        swapped = False
+
+        # Last i elements are already in place
+        for j in range(0, n-i-1):
+
+            # Traverse the array from 0 to n-i-1
+            # Swap if the element found is greater
+            # than the next element
+            if arr[j] > arr[j+1]:
+                arr[j], arr[j+1] = arr[j+1], arr[j]
+                swapped = True
+        if (swapped == False):
+            break
+
+
+# Driver code to test above
+if __name__ == "__main__":
+    arr = [64, 34, 25, 12, 22, 11, 90]
+
+    bubbleSort(arr)
+
+    print("Sorted array:")
+    for i in range(len(arr)):
+        print("%d" % arr[i], end=" ")
+
+
+
+```
+
+```javascript
+// Optimized javaScript implementation
+// of Bubble sort
+// An optimized version of Bubble Sort
+function bubbleSort(arr, n)
+{
+    var i, j, temp;
+    var swapped;
+    for (i = 0; i < n - 1; i++) 
+    {
+        swapped = false;
+        for (j = 0; j < n - i - 1; j++) 
+        {
+            if (arr[j] > arr[j + 1]) 
+            {
+                // Swap arr[j] and arr[j+1]
+                temp = arr[j];
+                arr[j] = arr[j + 1];
+                arr[j + 1] = temp;
+                swapped = true;
+            }
+        }
+
+        // IF no two elements were 
+        // swapped by inner loop, then break
+        if (swapped == false)
+        break;
+    }
+}
+
+// Function to print an array 
+function printArray(arr, size)
+{
+  var i;
+  for (i = 0; i < size; i++)
+      console.log(arr[i] + " ");
+}
+
+// Driver program
+var arr = [ 64, 34, 25, 12, 22, 11, 90 ];
+var n = arr.length;
+bubbleSort(arr, n);
+console.log("Sorted array: ");
+printArray(arr, n);
+
+
+
+```
+
+## Solution Logic:
+
+1. The largest element is placed in its correct position, i.e., the end of the array.
+
+2. Place the second largest element at correct position
+
+3. Place the remaining two elements at their correct positions.
+
+4. Total no. of passes: n-1. Total no. of comparisons: n*(n-1)/2
+
+
+## Time Complexity
+
+* The time complexity is $O(N^2)$ as there are two nested loops
+
+## Space Complexity
+
+* The auxiliary space complexity is $O(1)$ due to the only extra memory used is for temporary variables while swapping two values in Array.