bubble sort (#78)

Author: spring1843

README.md

@@ -25,6 +25,7 @@ Welcome to **Data Structures and Algorithms in Go**! 🎉 This project is design
         * Product of All Other Elements
         * Equal Sum Sub-arrays
         * Rotate K Steps
+        * Bubble Sort
     * [Strings](./strings)
         * The longest Dictionary Word Containing Key
         * Look and Tell

array/README.md

@@ -113,3 +113,7 @@ Given an array of integers A, return two sub-arrays with equal sums without chan
 ### Rotate K Steps
 
 Given an array of integers and a number k, rotate the array k times. [Solution](rotate_k_steps.go), [Tests](rotate_k_steps_test.go)
+
+### Bubble Sort
+
+Given an array of unsorted integers, sort the array using the Bubble Sort algorithm, where each element is repeatedly compared with the next element and swapped if needed. [Solution](bubble_sort.go), [Tests](bubble_sort_test.go)

array/bubble_sort.go

@@ -0,0 +1,12 @@
+package array
+
+// BubbleSort implements the Bubble Sort algorithm.
+func BubbleSort(input []int) {
+	for i := range input {
+		for j := range input {
+			if input[i] < input[j] {
+				input[i], input[j] = input[j], input[i]
+			}
+		}
+	}
+}

array/bubble_sort_test.go

@@ -0,0 +1,25 @@
+package array
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestBubbleSort(t *testing.T) {
+	tests := []struct {
+		input, sorted []int
+	}{
+		{[]int{}, []int{}},
+		{[]int{1}, []int{1}},
+		{[]int{1, 2}, []int{1, 2}},
+		{[]int{2, 1}, []int{1, 2}},
+		{[]int{2, 3, 1}, []int{1, 2, 3}},
+		{[]int{4, 2, 3, 1, 5}, []int{1, 2, 3, 4, 5}},
+	}
+	for i, test := range tests {
+		BubbleSort(test.input)
+		if !reflect.DeepEqual(test.input, test.sorted) {
+			t.Fatalf("Failed test case #%d. Want %v got %v", i, test.sorted, test.input)
+		}
+	}
+}

complexity.md

@@ -114,7 +114,7 @@ The time complexity of O(n log n) is commonly observed when it is necessary to i
 
 Polynomial time complexity marks the initial threshold of problematic time complexity for algorithms. This complexity often arises when an algorithm includes nested loops, involving both an inner loop and an outer loop. Examples:
 
-* Bobble sort rehearsal problem in [array](../array)
+* Bubble sort rehearsal problem in [array](../array)
 * Naive way of searching an unsorted [array](../array) for duplicates by using nested loops
 
 ### Exponential O(2^n)