modufy description

Author: akgmage

Diff for: sorting/bubble_sort.cpp

@@ -1,15 +1,24 @@
-// Implementation of Bubble sort.
-// Bubble sort, sometimes referred to as sinking sort, is a simple sorting algorithm
-// that repeatedly steps through the input list element by element,
-// comparing the current element with the one after it, swapping their values if needed.
-//  These passes through the list are repeated until no swaps had to be performed during a pass,
-// meaning that the list has become fully sorted. (Source wiki) https://en.wikipedia.org/wiki/Bubble_sort
+/*
+    Here's how the Bubble Sort algorithm works:
 
-// Time Complexity worst-case and average complexity O(n^{2})
-// Bubble sort is O(n) on a list that is already sorted i.e. Best case
+    1. We start by comparing the first two elements of the array. If the first element is greater than the second 
+       element, we swap them.
+    2. We then compare the second and third elements. If the second element is greater than the third element, 
+       we swap them.
+    3. We continue this process until we reach the end of the array. At this point, the largest element will 
+       be at the end of the array.
+    4. We then repeat steps 1-3 for the remaining unsorted portion of the array until the entire array is sorted.
+    
+    The time complexity of Bubble Sort is O(n^2) in the worst and average case, and O(n) in the best case when 
+    the input array is already sorted. 
+    
+    The space complexity is O(1) as Bubble Sort operates on the input array in-place.
 
-// Sample Input : [2, 1, 9, 3, 5, 4, 0]
-// Output : [0 1 2 3 4 5 9]
+    Bubble sort is O(n) on a list that is already sorted i.e. Best case
+
+    Sample Input : [2, 1, 9, 3, 5, 4, 0]
+    Output : [0 1 2 3 4 5 9]
+*/
 #include <iostream>
 #include <vector>
 

Diff for: sorting/bubble_sort.go

@@ -1,15 +1,24 @@
-// Implementation of Bubble sort.
-// Bubble sort, sometimes referred to as sinking sort, is a simple sorting algorithm
-// that repeatedly steps through the input list element by element,
-// comparing the current element with the one after it, swapping their values if needed.
-//  These passes through the list are repeated until no swaps had to be performed during a pass,
-// meaning that the list has become fully sorted. (Source wiki) https://en.wikipedia.org/wiki/Bubble_sort
+/*
+    Here's how the Bubble Sort algorithm works:
 
-// Time Complexity worst-case and average complexity O(n^{2})
-// Bubble sort is O(n) on a list that is already sorted i.e. Best case
+    1. We start by comparing the first two elements of the array. If the first element is greater than the second 
+       element, we swap them.
+    2. We then compare the second and third elements. If the second element is greater than the third element, 
+       we swap them.
+    3. We continue this process until we reach the end of the array. At this point, the largest element will 
+       be at the end of the array.
+    4. We then repeat steps 1-3 for the remaining unsorted portion of the array until the entire array is sorted.
+    
+    The time complexity of Bubble Sort is O(n^2) in the worst and average case, and O(n) in the best case when 
+    the input array is already sorted. 
+    
+    The space complexity is O(1) as Bubble Sort operates on the input array in-place.
 
-// Sample Input : [2, 1, 9, 3, 5, 4, 0]
-// Output : [0 1 2 3 4 5 9]
+    Bubble sort is O(n) on a list that is already sorted i.e. Best case
+
+    Sample Input : [2, 1, 9, 3, 5, 4, 0]
+    Output : [0 1 2 3 4 5 9]
+*/
 
 package main
 

Diff for: sorting/bubble_sort.java

@@ -1,16 +1,24 @@
-// Implementation of Bubble sort.
-// Bubble sort, sometimes referred to as sinking sort, is a simple sorting algorithm
-// that repeatedly steps through the input list element by element,
-// comparing the current element with the one after it, swapping their values if needed.
-//  These passes through the list are repeated until no swaps had to be performed during a pass,
-// meaning that the list has become fully sorted. (Source wiki) https://en.wikipedia.org/wiki/Bubble_sort
+/*
+    Here's how the Bubble Sort algorithm works:
 
-// Time Complexity worst-case and average complexity O(n^{2})
-// Bubble sort is O(n) on a list that is already sorted i.e. Best case
+    1. We start by comparing the first two elements of the array. If the first element is greater than the second 
+       element, we swap them.
+    2. We then compare the second and third elements. If the second element is greater than the third element, 
+       we swap them.
+    3. We continue this process until we reach the end of the array. At this point, the largest element will 
+       be at the end of the array.
+    4. We then repeat steps 1-3 for the remaining unsorted portion of the array until the entire array is sorted.
+    
+    The time complexity of Bubble Sort is O(n^2) in the worst and average case, and O(n) in the best case when 
+    the input array is already sorted. 
+    
+    The space complexity is O(1) as Bubble Sort operates on the input array in-place.
 
-// Sample Input : [2, 1, 9, 3, 5, 4, 0]
-// Output : [0 1 2 3 4 5 9]
+    Bubble sort is O(n) on a list that is already sorted i.e. Best case
 
+    Sample Input : [2, 1, 9, 3, 5, 4, 0]
+    Output : [0 1 2 3 4 5 9]
+*/
 
 public class BubbleSort {
     public static void bubbleSort(int[] arr) {

Diff for: sorting/bubble_sort.js

@@ -1,15 +1,24 @@
-// Implementation of Bubble sort.
-// Bubble sort, sometimes referred to as sinking sort, is a simple sorting algorithm
-// that repeatedly steps through the input list element by element,
-// comparing the current element with the one after it, swapping their values if needed.
-//  These passes through the list are repeated until no swaps had to be performed during a pass,
-// meaning that the list has become fully sorted. (Source wiki) https://en.wikipedia.org/wiki/Bubble_sort
+/*
+    Here's how the Bubble Sort algorithm works:
 
-// Time Complexity worst-case and average complexity O(n^{2})
-// Bubble sort is O(n) on a list that is already sorted i.e. Best case
+    1. We start by comparing the first two elements of the array. If the first element is greater than the second 
+       element, we swap them.
+    2. We then compare the second and third elements. If the second element is greater than the third element, 
+       we swap them.
+    3. We continue this process until we reach the end of the array. At this point, the largest element will 
+       be at the end of the array.
+    4. We then repeat steps 1-3 for the remaining unsorted portion of the array until the entire array is sorted.
+    
+    The time complexity of Bubble Sort is O(n^2) in the worst and average case, and O(n) in the best case when 
+    the input array is already sorted. 
+    
+    The space complexity is O(1) as Bubble Sort operates on the input array in-place.
 
-// Sample Input : [2, 1, 9, 3, 5, 4, 0]
-// Output : [0 1 2 3 4 5 9]
+    Bubble sort is O(n) on a list that is already sorted i.e. Best case
+
+    Sample Input : [2, 1, 9, 3, 5, 4, 0]
+    Output : [0 1 2 3 4 5 9]
+*/
 
 function bubbleSort(arr) {
   var n = arr.length;

Diff for: sorting/bubble_sort.py

@@ -1,15 +1,24 @@
-# Implementation of Bubble sort.
-# Bubble sort, sometimes referred to as sinking sort, is a simple sorting algorithm
-# that repeatedly steps through the input list element by element,
-# comparing the current element with the one after it, swapping their values if needed.
-#  These passes through the list are repeated until no swaps had to be performed during a pass,
-# meaning that the list has become fully sorted. (Source wiki) https://en.wikipedia.org/wiki/Bubble_sort
+'''
+    Here's how the Bubble Sort algorithm works:
 
-# Time Complexity worst-case and average complexity O(n^{2})
-# Bubble sort is O(n) on a list that is already sorted i.e. Best case
+    1. We start by comparing the first two elements of the array. If the first element is greater than the second 
+       element, we swap them.
+    2. We then compare the second and third elements. If the second element is greater than the third element, 
+       we swap them.
+    3. We continue this process until we reach the end of the array. At this point, the largest element will 
+       be at the end of the array.
+    4. We then repeat steps 1-3 for the remaining unsorted portion of the array until the entire array is sorted.
+    
+    The time complexity of Bubble Sort is O(n^2) in the worst and average case, and O(n) in the best case when 
+    the input array is already sorted. 
+    
+    The space complexity is O(1) as Bubble Sort operates on the input array in-place.
 
-# Sample Input : [2, 1, 9, 3, 5, 4, 0]
-# Output : [0 1 2 3 4 5 9]
+    Bubble sort is O(n) on a list that is already sorted i.e. Best case
+
+    Sample Input : [2, 1, 9, 3, 5, 4, 0]
+    Output : [0 1 2 3 4 5 9]
+'''
 
 def bubbleSort(arr):
     n = len(arr)