Add all 23 GoF design pattern implementations (2026-06-13)

03-behavioral/strategy/BubbleSort.java

@@ -0,0 +1,12 @@
+package strategy;
+
+public class BubbleSort implements SortStrategy {
+    @Override
+    public void sort(int[] data) {
+        System.out.println("  [BubbleSort] O(n²) — small arrays only");
+        for (int i = 0; i < data.length - 1; i++)
+            for (int j = 0; j < data.length - 1 - i; j++)
+                if (data[j] > data[j + 1]) { int t = data[j]; data[j] = data[j+1]; data[j+1] = t; }
+    }
+    @Override public String getName() { return "BubbleSort"; }
+}

03-behavioral/strategy/Main.java

@@ -0,0 +1,37 @@
+package strategy;
+
+import java.util.Arrays;
+
+/**
+ * Strategy Design Pattern — Runnable Demo
+ * Run: javac strategy/*.java -d out/strategy && java -cp out/strategy strategy.Main
+ * Article: https://ankurm.com/strategy-design-pattern-java/
+ */
+public class Main {
+    public static void main(String[] args) {
+        System.out.println("=== Strategy Design Pattern Demo ===\n");
+
+        int[] data = {64, 34, 25, 12, 22, 11, 90};
+        System.out.println("Input: " + Arrays.toString(data));
+
+        Sorter sorter = new Sorter(new BubbleSort());
+        System.out.println("\n-- BubbleSort --");
+        System.out.println("Sorted: " + Arrays.toString(sorter.sort(data)));
+
+        sorter.setStrategy(new MergeSort());
+        System.out.println("\n-- MergeSort --");
+        System.out.println("Sorted: " + Arrays.toString(sorter.sort(data)));
+
+        sorter.setStrategy(new QuickSort());
+        System.out.println("\n-- QuickSort --");
+        System.out.println("Sorted: " + Arrays.toString(sorter.sort(data)));
+
+        System.out.println("\n-- Runtime strategy selection (simulating large dataset) --");
+        int size = 10_000;
+        SortStrategy chosen = size > 1000 ? new QuickSort() : new BubbleSort();
+        sorter.setStrategy(chosen);
+        System.out.println("  Chose " + chosen.getName() + " for size=" + size);
+
+        System.out.println("\n=== Demo complete ===");
+    }
+}

03-behavioral/strategy/MergeSort.java

@@ -0,0 +1,30 @@
+package strategy;
+
+import java.util.Arrays;
+
+public class MergeSort implements SortStrategy {
+    @Override
+    public void sort(int[] data) {
+        System.out.println("  [MergeSort] O(n log n) — stable, good for large datasets");
+        mergeSort(data, 0, data.length - 1);
+    }
+
+    private void mergeSort(int[] a, int l, int r) {
+        if (l >= r) return;
+        int m = (l + r) / 2;
+        mergeSort(a, l, m); mergeSort(a, m + 1, r);
+        merge(a, l, m, r);
+    }
+
+    private void merge(int[] a, int l, int m, int r) {
+        int[] left = Arrays.copyOfRange(a, l, m + 1);
+        int[] right = Arrays.copyOfRange(a, m + 1, r + 1);
+        int i = 0, j = 0, k = l;
+        while (i < left.length && j < right.length)
+            a[k++] = left[i] <= right[j] ? left[i++] : right[j++];
+        while (i < left.length)  a[k++] = left[i++];
+        while (j < right.length) a[k++] = right[j++];
+    }
+
+    @Override public String getName() { return "MergeSort"; }
+}

03-behavioral/strategy/QuickSort.java

@@ -0,0 +1,26 @@
+package strategy;
+
+public class QuickSort implements SortStrategy {
+    @Override
+    public void sort(int[] data) {
+        System.out.println("  [QuickSort] O(n log n) avg — fast in practice, not stable");
+        quickSort(data, 0, data.length - 1);
+    }
+
+    private void quickSort(int[] a, int lo, int hi) {
+        if (lo >= hi) return;
+        int p = partition(a, lo, hi);
+        quickSort(a, lo, p - 1);
+        quickSort(a, p + 1, hi);
+    }
+
+    private int partition(int[] a, int lo, int hi) {
+        int pivot = a[hi], i = lo;
+        for (int j = lo; j < hi; j++)
+            if (a[j] <= pivot) { int t = a[i]; a[i++] = a[j]; a[j] = t; }
+        int t = a[i]; a[i] = a[hi]; a[hi] = t;
+        return i;
+    }
+
+    @Override public String getName() { return "QuickSort"; }
+}

03-behavioral/strategy/SortStrategy.java

@@ -0,0 +1,7 @@
+package strategy;
+
+/** Strategy interface — all sorting algorithms implement this */
+public interface SortStrategy {
+    void sort(int[] data);
+    String getName();
+}

03-behavioral/strategy/Sorter.java

@@ -0,0 +1,24 @@
+package strategy;
+
+import java.util.Arrays;
+
+/**
+ * Context — uses a SortStrategy. The strategy can be swapped at runtime.
+ * Sorter doesn't care which algorithm is used; it just calls sort().
+ */
+public class Sorter {
+    private SortStrategy strategy;
+
+    public Sorter(SortStrategy strategy) { this.strategy = strategy; }
+
+    public void setStrategy(SortStrategy strategy) {
+        System.out.println("  Switching to: " + strategy.getName());
+        this.strategy = strategy;
+    }
+
+    public int[] sort(int[] data) {
+        int[] copy = Arrays.copyOf(data, data.length);
+        strategy.sort(copy);
+        return copy;
+    }
+}