big o notation examples

Author: gzeiniss

pom.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xmlns="http://maven.apache.org/POM/4.0.0"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>com.genezeiniss</groupId>
+    <artifactId>algorithm-complexity</artifactId>
+    <version>1.0-SNAPSHOT</version>
+
+    <properties>
+        <maven.compiler.source>11</maven.compiler.source>
+        <maven.compiler.target>11</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+</project>

src/main/java/com/genezeiniss/Main.java

@@ -0,0 +1,8 @@
+package com.genezeiniss;
+
+public class Main {
+    public static void main(String[] args) {
+        System.out.println("Hello world!");
+    }
+
+}

src/main/java/com/genezeiniss/big_o_notation/ConstantTimeExample.java

@@ -0,0 +1,26 @@
+package com.genezeiniss.big_o_notation;
+
+import java.util.List;
+
+// O(1): Constant Time Algorithm
+public class ConstantTimeExample {
+
+    // Accessing an element at a specific index in an array is an O(1) operation
+    // because it takes the same amount of time regardless of the array size.
+    public void accessElement(List<Integer> elements, int index) {
+        int element = elements.get(index);
+        System.out.printf("Element at index %s: %s", index, element);
+    }
+
+    // Updating or assigning value to an array element at a specific index is also an O(1) operation because it takes constant time.
+    public void updateElement(List<Integer> elements, int index) {
+        elements.set(index, 100);
+        System.out.printf("Updated element at index %s", index);
+    }
+
+    // Checking the length of an array is an O(1) operation because it's simply accessing a property of the array.
+    public void checkLength(List<Integer> elements) {
+        int length = elements.size();
+        System.out.printf("Length of elements list is %s", length);
+    }
+}

src/main/java/com/genezeiniss/big_o_notation/ExponentialTimeComplexity.java

@@ -0,0 +1,21 @@
+package com.genezeiniss.big_o_notation;
+
+import java.util.stream.IntStream;
+
+// O(2^n): Exponential Time Complexity
+public class ExponentialTimeComplexity {
+
+    public static void main(String[] args) {
+        // Example: Calculate and print the first 10 Fibonacci numbers
+        int n = 10;
+        System.out.printf("Fibonacci sequence up to %s terms: ", n);
+
+        IntStream.range(0, n)
+                .mapToObj(i -> fibonacci(i) + " ")
+                .forEach(System.out::print);
+    }
+
+    public static int fibonacci(int n) {
+        return n <= 1 ? n : fibonacci(n - 1) + fibonacci(n - 2);
+    }
+}

src/main/java/com/genezeiniss/big_o_notation/FactorialTimeComplexity.java

@@ -0,0 +1,42 @@
+package com.genezeiniss.big_o_notation;
+
+import java.util.ArrayList;
+import java.util.List;
+
+// O(n!): Factorial Time Complexity
+public class FactorialTimeComplexity {
+
+    public static void main(String[] args) {
+        List<Integer> nums = List.of(1, 2, 3);
+        List<List<Integer>> permutations = permute(new ArrayList<>(nums));
+        System.out.printf("Permutations of %s:\n", nums);
+        permutations.forEach(System.out::println);
+    }
+
+    // Method to generate all permutations of a list
+    public static List<List<Integer>> permute(List<Integer> nums) {
+        List<List<Integer>> result = new ArrayList<>();
+        permuteHelper(nums, 0, result);
+        return result;
+    }
+
+    // Helper method to generate permutations recursively
+    private static void permuteHelper(List<Integer> nums, int start, List<List<Integer>> result) {
+        if (start == nums.size() - 1) {
+            result.add(new ArrayList<>(nums));
+            return;
+        }
+        for (int i = start; i < nums.size(); i++) {
+            swap(nums, i, start);
+            permuteHelper(nums, start + 1, result);
+            swap(nums, i, start); // backtrack
+        }
+    }
+
+    // Method to swap elements in a list
+    private static void swap(List<Integer> nums, int i, int j) {
+        int temp = nums.get(i);
+        nums.set(i, nums.get(j));
+        nums.set(j, temp);
+    }
+}

src/main/java/com/genezeiniss/big_o_notation/LinearTimeExample.java

@@ -0,0 +1,63 @@
+package com.genezeiniss.big_o_notation;
+
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+// O(n): Linear Time Complexity
+public class LinearTimeExample {
+
+    public static void main(String[] args) {
+        // Simulating a book with 1000 pages
+        List<String> book = IntStream.range(0, 1000)
+                .mapToObj(LinearTimeExample::toChineseNumber)
+                .collect(Collectors.toList());
+
+        // The page we want to find (e.g., page 512 in Chinese characters)
+        String targetPage = toChineseNumber(512);
+
+        // Performing the linear search
+        int checks = linearSearch(book, targetPage);
+        System.out.printf("Number of checks needed: %s\n", checks);
+    }
+
+    public static int linearSearch(List<String> book, String targetPage) {
+        int checks = 0;
+
+        for (String page : book) {
+            checks++;
+            if (page.equals(targetPage)) {
+                return checks;
+            }
+        }
+
+        return -1; // Page not found
+    }
+
+    private static String toChineseNumber(int number) {
+        List<String> units = List.of("", "十", "百", "千", "万"); // This list contains Chinese characters for units like ten, hundred, thousand, and ten thousand.
+        List<String> digits = List.of("零", "一", "二", "三", "四", "五", "六", "七", "八", "九"); // This array contains Chinese characters for the digits 0 through 9.
+
+        // If the input number is zero, the function directly returns "零", which is the Chinese character for zero.
+        if (number == 0) {
+            return digits.get(0);
+        }
+
+        StringBuilder chineseNumber = new StringBuilder();
+        int unitIndex = 0;
+
+        // The function uses a loop to process each digit of the input number from right to left.
+        while (number > 0) {
+            int digit = number % 10; //  Extracts the rightmost digit of the number.
+            if (digit != 0) { // If the digit is not zero, it prepends the corresponding Chinese digit and unit to the StringBuilder.
+                chineseNumber.insert(0, digits.get(digit) + units.get(unitIndex));
+            } else if (chineseNumber.length() > 0 && chineseNumber.charAt(0) != '零') { // If the digit is zero and the current Chinese number being built doesn't already start with zero, it prepends "零".
+                chineseNumber.insert(0, digits.get(digit));
+            }
+            number /= 10; // Removes the rightmost digit from the number
+            unitIndex++; // Moves to the next unit (ten, hundred, thousand, etc.)
+        }
+
+        return chineseNumber.toString();
+    }
+}

src/main/java/com/genezeiniss/big_o_notation/LinearithmicTimeComplexity.java

@@ -0,0 +1,64 @@
+package com.genezeiniss.big_o_notation;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+// O(n log n): Linearithmic Time Complexity
+public class LinearithmicTimeComplexity {
+
+    public static void main(String[] args) {
+        List<Integer> list = Arrays.asList(38, 27, 43, 3, 9, 82, 10);
+        System.out.printf("Original list: %s\n", list);
+
+        List<Integer> sortedList = mergeSort(list);
+        System.out.printf("Sorted list: %s\n", sortedList);
+    }
+
+    public static List<Integer> mergeSort(List<Integer> list) {
+        // Base case: a list with zero or one element is already sorted
+        if (list.size() <= 1) {
+            return list;
+        }
+
+        // Divide: The dataset is repeatedly divided in half until each sub-array contains a single element.
+        // The number of times you can divide n elements in half is log(n).
+        int middle = list.size() / 2;
+        List<Integer> left = list.subList(0, middle);
+        List<Integer> right = list.subList(middle, list.size());
+
+        // Conquer: Each of these single-element arrays is trivially sorted.
+        left = mergeSort(left);
+        right = mergeSort(right);
+
+        // Combine: The sorted sub-arrays are merged back together.
+        // Merging n elements requires linear time, O(n).
+        return merge(left, right);
+    }
+
+    public static List<Integer> merge(List<Integer> left, List<Integer> right) {
+        List<Integer> result = new ArrayList<>();
+        int leftIndex = 0, rightIndex = 0;
+
+        // Merge the two lists while there are elements in both
+        while (leftIndex < left.size() && rightIndex < right.size()) {
+            if (left.get(leftIndex) <= right.get(rightIndex)) {
+                result.add(left.get(leftIndex++));
+            } else {
+                result.add(right.get(rightIndex++));
+            }
+        }
+
+        // If there are remaining elements in the left list, add them
+        while (leftIndex < left.size()) {
+            result.add(left.get(leftIndex++));
+        }
+
+        // If there are remaining elements in the right list, add them
+        while (rightIndex < right.size()) {
+            result.add(right.get(rightIndex++));
+        }
+
+        return result;
+    }
+}

src/main/java/com/genezeiniss/big_o_notation/LogarithmicTimeExample.java

@@ -0,0 +1,37 @@
+package com.genezeiniss.big_o_notation;
+
+// O(log n): Logarithmic Time Complexity
+public class LogarithmicTimeExample {
+
+    public static void main(String[] args) {
+        var totalPages = 1000;
+        var targetPage = 512;
+
+        var checks = binarySearch(totalPages, targetPage);
+        System.out.printf("Number of checks needed: %s\n", checks);
+    }
+
+    public static int binarySearch(int totalPages, int targetPage) {
+        int low = 1;
+        int high = totalPages;
+        int checks = 0;
+
+        while (low <= high) {
+            int mid = low + (high - low) / 2;
+            checks++; // Counting the number of checks
+
+            switch (Integer.compare(mid, targetPage)) {
+                case 0:
+                    return checks;
+                case -1:
+                    low = mid + 1;
+                    break;
+                case 1:
+                    high = mid - 1;
+                    break;
+            }
+        }
+
+        return -1; // Page not found
+    }
+}

src/main/java/com/genezeiniss/big_o_notation/QuadraticTimeComplexity.java

@@ -0,0 +1,37 @@
+package com.genezeiniss.big_o_notation;
+
+import java.util.Arrays;
+import java.util.List;
+
+// O(n^2): Quadratic Time Complexity
+public class QuadraticTimeComplexity {
+
+    public static void main(String[] args) {
+        List<Integer> list = Arrays.asList(64, 34, 25, 12, 22, 11, 90);
+        System.out.printf("Unsorted list: %s\n", list);
+
+        bubbleSort(list);
+        System.out.printf("Sorted list: %s\n", list);
+    }
+
+    public static void bubbleSort(List<Integer> list) {
+        int n = list.size();
+        boolean swapped;
+
+        for (int i = 0; i < n - 1; i++) {
+            swapped = false;
+            // Inner loop to perform the comparisons and swaps
+            for (int j = 0; j < n - i - 1; j++) {
+                // If the current element is greater than the next element, swap them
+                if (list.get(j) > list.get(j + 1)) {
+                    int temp = list.get(j);
+                    list.set(j, list.get(j + 1));
+                    list.set(j + 1, temp);
+                    swapped = true;
+                }
+            }
+            // If no elements were swapped during the inner loop, the array is sorted
+            if (!swapped) break;
+        }
+    }
+}