indices) {
42 | StringBuilder prettySeq = new StringBuilder(" Sequence: ");
43 | StringBuilder prettyPtr = new StringBuilder("Start Pts: ");
44 | int currPos = 0;
45 | for (int i = 0; i < seq.length(); i++) {
46 | char curr = seq.charAt(i);
47 | prettySeq.append(String.format("%c ", curr));
48 |
49 | if (currPos < indices.size()) {
50 | int currIdx = indices.get(currPos);
51 | if (currIdx == i) {
52 | prettyPtr.append("^ ");
53 | currPos++;
54 | } else {
55 | prettyPtr.append(" ");
56 | }
57 | }
58 | }
59 | System.out.println(" Pattern: " + pattern);
60 | System.out.println(prettySeq);
61 | System.out.println(prettyPtr);
62 | }
63 | }
64 |
--------------------------------------------------------------------------------
/scripts/algorithms/sorting/countingSort/RunCountingSort.java:
--------------------------------------------------------------------------------
1 | package algorithms.sorting.countingSort;
2 |
3 | /**
4 | * Script to run Counting Sort.
5 | */
6 | public class RunCountingSort {
7 |
8 | //\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
9 | ////////////////////////////////////////// This section is for user input \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
10 | private static int[] toSort =
11 | new int[] {3, 4, 2, 65, 76, 93, 22, 1, 5, 7, 88, 54, 44, 7, 5, 6, 2, 64, 43, 22, 27, 33, 59, 64, 76, 99, 37, 7};
12 |
13 | //\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
14 |
15 | public static void main(String[] args) {
16 | int[] sorted = CountingSort.sort(toSort);
17 | display(sorted);
18 | }
19 |
20 | /**
21 | * Prints the string representation of the array.
22 | *
23 | * @param arr the given array.
24 | */
25 | public static void display(int[] arr) {
26 | StringBuilder toDisplay = new StringBuilder("[");
27 | for (int num : arr) {
28 | toDisplay.append(String.format("%d ", num));
29 | }
30 | toDisplay = toDisplay.replace(toDisplay.length() - 1, toDisplay.length(), "]");
31 | System.out.println(toDisplay);
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/scripts/algorithms/sorting/insertionSort/RunInsertionSort.java:
--------------------------------------------------------------------------------
1 | package algorithms.sorting.insertionSort;
2 |
3 | /**
4 | * Script to run Insertion Sort.
5 | */
6 | public class RunInsertionSort {
7 |
8 | //\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
9 | ////////////////////////////////////////// This section is for user input \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
10 | private static int[] toSort =
11 | new int[] {3, 4, 2, 65, 76, 93, 22, 1, 5, 7, 88, 54, 44, 7, 5, 6, 2, 64, 43, 22, 27, 33, 59, 64, 76, 99, 37, 7};
12 |
13 | //\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
14 |
15 | public static void main(String[] args) {
16 | int[] sorted = InsertionSort.sort(toSort);
17 | display(sorted);
18 | }
19 |
20 | /**
21 | * Prints the string representation of the array.
22 | *
23 | * @param arr the given array.
24 | */
25 | public static void display(int[] arr) {
26 | StringBuilder toDisplay = new StringBuilder("[");
27 | for (int num : arr) {
28 | toDisplay.append(String.format("%d ", num));
29 | }
30 | toDisplay = toDisplay.replace(toDisplay.length() - 1, toDisplay.length(), "]");
31 | System.out.println(toDisplay);
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/settings.gradle:
--------------------------------------------------------------------------------
1 | /*
2 | * This file was generated by the Gradle 'init' task.
3 | *
4 | * The settings file is used to specify which projects to include in your build.
5 | * For more detailed information on multi-project builds, please refer to https://docs.gradle.org/8.3/userguide/building_swift_projects.html in the Gradle documentation.
6 | */
7 |
8 | rootProject.name = 'data-structures-and-algorithms'
9 |
--------------------------------------------------------------------------------
/src/main/java/algorithms/binarySearch/README.md:
--------------------------------------------------------------------------------
1 | # Binary Search
2 |
3 | ## Background
4 |
5 | Binary search is a search algorithm that finds the position of a target value within a sorted array or list. It compares
6 | the target value to the middle element of the search range, then, based on the comparison, narrows the search to the
7 | upper or lower half of the current search range.
8 |
9 | ## Implementation Invariant
10 |
11 | At the end of each iteration, the target value is either within the search range or does not exist in the search space.
12 |
13 | ## BinarySearch and BinarySearchTemplate
14 |
15 | We will discuss more implementation-specific details and complexity analysis in the respective folders. In short,
16 | 1. The [binarySearch](binarySearch) method is a more straightforward and intuitive version of the binary search
17 | algorithm.
18 | 2. The [binarySearchTemplate](binarySearchTemplated) method provides a more generalised template that can be used for
19 | most binary search problems by introducing a condition method that can be modified based on the requirements of the
20 | implementation.
21 |
22 |
23 |
--------------------------------------------------------------------------------
/src/main/java/algorithms/binarySearch/binarySearch/BinarySearch.java:
--------------------------------------------------------------------------------
1 | package algorithms.binarySearch.binarySearch;
2 |
3 | /**
4 | * Here, we are implementing BinarySearch where we search an array for a target value at O(log n) time complexity.
5 | *
6 | * Assumptions:
7 | * The array is sorted in ascending order.
8 | * All elements in the array are unique. (to allow for easy testing)
9 | *
10 | * Brief Description and Implementation Invariant:
11 | *
12 | * Brief Description:
13 | * With the assumption that the array is sorted in ascending order, BinarySearch reduces the search range by half or
14 | * half + 1 (due to floor division) after every loop. This is done by reassigning the max (high) or min (low) of the
15 | * search range to the middle of the search range when the target value is smaller than or larger than the current
16 | * middle value respectively, and continuing the search thereafter.
17 | *
18 | * In both scenarios where the target is not equal to arr[mid], the high and low pointers are reassigned mid decremented
19 | * /incremented by 1. This ensures that there will never be an infinite loop as the search range will no longer include
20 | * the mid-value, causing the search range to constantly "shrink". We know we can decrement/increment mid by 1 during
21 | * the reassignment as the mid-value is definitely not the target and should no longer be in the search range.
22 | *
23 | * At the end of every loop, we know that the target value is either within the search range or does not exist in the
24 | * array, thereby ensuring the correctness of the algorithm.
25 | *
26 | * Since after each iteration, the search range is halved, it will only take a maximum of O(log n) times before the
27 | * target is either found or determined to not exist in the array.
28 | */
29 | public class BinarySearch {
30 | /**
31 | * Searches for a target value within a sorted array using the binary search algorithm.
32 | *
33 | * @param arr the sorted array in which the search is to be performed.
34 | * @param target the value to be searched for.
35 | * @return the index of the target if found, otherwise -1.
36 | */
37 | public static int search(int[] arr, int target) {
38 | int high = arr.length - 1; // max index is 3 if array length is 4
39 | int low = 0;
40 | while (low <= high) { // When low == high, arr[low] can still == target, therefore should still check
41 | int mid = low + (high - low) / 2; // equivalent to high + low / 2 but reduces cases of integer overflow
42 | if (arr[mid] > target) {
43 | high = mid - 1; // -1 since current mid is not == target and should not be in the search range anymore
44 | } else if (arr[mid] < target) {
45 | low = mid + 1; // +1 since current mid is not == target and should not be in the search range anymore
46 | } else {
47 | return mid;
48 | }
49 | }
50 |
51 | return -1;
52 | }
53 | }
54 |
--------------------------------------------------------------------------------
/src/main/java/algorithms/binarySearch/binarySearch/README.md:
--------------------------------------------------------------------------------
1 | # BinarySearch
2 |
3 | ## Background
4 |
5 | BinarySearch is a more straightforward and intuitive version of the binary search algorithm. In this approach, after the
6 | mid-value is calculated, the high or low pointer is adjusted by just one unit.
7 |
8 | ### Illustration
9 |
10 | 
11 |
12 | Image Source: GeeksforGeeks
13 |
14 | From the above example, after mid points to index 4 in the first search, the low pointer moves to index 5 (+1 from 4)
15 | when narrowing the search. Similarly, when mid points to index 7 in the second search, the high pointer shifts to index
16 | 6 (-1 from 7) when narrowing the search. This prevents any possibility of infinite loops. During the search, the moment
17 | mid-value is equal to the target value, the search ends prematurely.
18 |
19 | ## Complexity Analysis
20 | **Time**:
21 | - Worst case: O(log n)
22 | - Average case: O(log n)
23 | - Best case: O(1)
24 |
25 | In the worst case, the target is either in the first or last index or does not exist in the array at all.
26 | In the best case, the target is the middle (odd number of element) or the first middle element (even number of elements)
27 | if floor division is used to determine the middle.
28 |
29 | **Space**: O(1)
30 |
31 | Since no new data structures are used and searching is only done within the array given.
--------------------------------------------------------------------------------
/src/main/java/algorithms/binarySearch/binarySearchTemplated/BinarySearchTemplated.java:
--------------------------------------------------------------------------------
1 | package algorithms.binarySearch.binarySearchTemplated;
2 |
3 | /**
4 | * Here, we are implementing BinarySearchTemplated where we search an array for a target value at O(log n) time
5 | * complexity.
6 | *
7 | * Assumptions:
8 | * The array is sorted in ascending order.
9 | * All elements in the array are unique. (to allow for easy testing)
10 | *
11 | * Brief Description and Implementation Invariant:
12 | * With the assumption that the array is sorted in ascending order, BinarySearchTemplated reduces the search range by
13 | * half or half + 1 (due to floor division) after every loop. This is done by reassigning the max (high) or min (low) of
14 | * the search range to the middle of the search range when the target value is smaller than or larger than the current
15 | * middle value respectively, and continuing the search thereafter.
16 | *
17 | * In this version, there is no condition to check if the current mid is equal to the target to prematurely end the
18 | * search. Hence, the only way for the loop to complete is when low exceeds high.
19 | *
20 | * At the end of every loop, we know that the target value is either within the search range or does not exist in the
21 | * array, thereby ensuring the correctness of the algorithm.
22 | *
23 | * Since after each iteration, the search range is halved, it will only take a maximum of O(log n) times before the
24 | * target is either found or determined to not exist in the array.
25 | */
26 | public class BinarySearchTemplated {
27 | /**
28 | * A utility method to compare two integers.
29 | *
30 | * @param value The current value from the array.
31 | * @param target The value being searched for.
32 | * @return true if the current value is less than the target, otherwise false.
33 | */
34 | // The condition should be changed accordingly
35 | public static boolean condition(int value, int target) {
36 | return value >= target;
37 | }
38 |
39 | /**
40 | * Conducts a binary search to find the target within the sorted array.
41 | *
42 | * @param arr The sorted input array.
43 | * @param target The value to be searched within the array.
44 | * @return The index of the target value if found, otherwise -1.
45 | */
46 | public static int search(int[] arr, int target) {
47 | // The search space i.e. high and low should be changed accordingly.
48 | int high = arr.length - 1; // max index is 3 if array length is 4
49 | int low = 0;
50 | while (low < high) {
51 | int mid = low + (high - low) / 2; // equivalent to high + low / 2 but reduces cases of integer overflow
52 | if (condition(arr[mid], target)) { // if value >= target
53 | high = mid;
54 | } else { // if value < target
55 | low = mid + 1;
56 | }
57 | }
58 |
59 | // Checks if low value is indeed the target
60 | // Note that the following checks may not be required in other use cases of this template
61 | if (low < arr.length && arr[low] == target) {
62 | // returned value should be changed accordingly (low or low - 1)
63 | return low;
64 | }
65 | // Returns -1 if loop was exited without finding the target
66 | return -1;
67 | }
68 | }
69 |
--------------------------------------------------------------------------------
/src/main/java/algorithms/minimumSpanningTree/README.md:
--------------------------------------------------------------------------------
1 | # Minimum Spanning Tree Algorithms
2 |
3 | ## Background
4 |
5 | Minimum Spanning Tree (MST) algorithms are used to find the minimum spanning tree of a weighted, connected graph. A
6 | spanning tree of a graph is a connected, acyclic subgraph that includes all the vertices of the original graph. An MST
7 | is a spanning tree with the minimum possible total edge weight.
8 |
9 | ### 4 Properties of MST
10 | 1. An MST should not have any cycles
11 | 2. If you cut an MST at any single edge, the two pieces will also be MSTs
12 | 3. **Cycle Property:** For every cycle, the maximum weight edge is not in the MST
13 |
14 | 
15 |
16 | Image Source: CS2040S 22/23 Sem 2 Lecture Slides
17 |
18 | 4. **Cut Property:** For every partition of the nodes, the minimum weight edge across the cut is in the MST
19 |
20 | 
21 |
22 | Image Source: CS2040S 22/23 Sem 2 Lecture Slides
23 |
24 | Note that the other edges across the partition may or may not be in the MST.
25 |
26 | ## Prim's Algorithm and Kruskal's Algorithm
27 |
28 | We will discuss more implementation-specific details and complexity analysis in the respective folders. In short,
29 | 1. [Prim's Algorithm](prim) is a greedy algorithm that finds the minimum spanning tree of a graph by starting from an
30 | arbitrary node (vertex) and adding the edge with the minimum weight that connects the current tree to a new node, adding
31 | the node to the current tree, until all nodes are included in the tree.
32 | <<<<<<< HEAD
33 | 2. [Kruskal's Algorithm](kruskal) is a greedy algorithm that finds the minimum spanning tree of a graph by sorting the
34 | edges by weight and adding the edge with the minimum weight that does not form a cycle into the current tree.
35 |
36 | ## Notes
37 |
38 | ### Difference between Minimum Spanning Tree and Shortest Path
39 | It is important to note that a Minimum Spanning Tree of a graph does not represent the shortest path between all the
40 | nodes. See below for an example:
41 |
42 | The below graph is a weighted, connected graph with 5 nodes and 6 edges:
43 | 
44 |
45 | The following is the Minimum Spanning Tree of the above graph:
46 | 
47 |
48 | Taking node A and D into consideration, the shortest path between them is A -> D, with a total weight of 4.
49 | 
50 |
51 | However, the shortest path between A and D in the Minimum Spanning Tree is A -> C -> D, with a total weight of 5, which
52 | is not the shortest path in the original graph.
53 | 
54 |
--------------------------------------------------------------------------------
/src/main/java/algorithms/minimumSpanningTree/kruskal/README.md:
--------------------------------------------------------------------------------
1 | # Kruskal's Algorithm
2 |
3 | ## Background
4 | Kruskal's Algorithm is a greedy algorithm used to find the minimum spanning tree (MST) of a connected, weighted graph.
5 | It works by sorting all the edges in the graph by their weight in non-decreasing order and then adding the smallest edge
6 | to the MST, provided it does not form a cycle with the already included edges. This is repeated until all vertices are
7 | included in the MST.
8 |
9 | ## Implementation Details
10 | Kruskal's Algorithm uses a simple `ArrayList` to sort the edges by weight.
11 |
12 | A [`DisjointSet`](/dataStructures/disjointSet/weightedUnion) data structure is also used to keep track of the
13 | connectivity of vertices and detect cycles.
14 |
15 | ## Complexity Analysis
16 |
17 | **Time Complexity:**
18 | Sorting the edges by weight: O(E log E) = O(E log V), where V and E is the number of vertices and edges respectively.
19 | Union-Find operations: O(E α(V)), where α is the inverse Ackermann function.
20 | Overall complexity: O(E log V)
21 |
22 | **Space Complexity:**
23 | O(V + E) for the storage of vertices in the disjoint set and edges in the priority queue.
--------------------------------------------------------------------------------
/src/main/java/algorithms/minimumSpanningTree/prim/README.md:
--------------------------------------------------------------------------------
1 | # Prim's Algorithm
2 |
3 | ## Background
4 |
5 | Prim's Algorithm is a greedy algorithm that finds the minimum spanning tree of a graph by starting from an
6 | arbitrary node (vertex) and adding the edge, with the minimum weight that connects the current tree to an unexplored
7 | node, and the unexplored node to the current tree, until all nodes are included in the tree.
8 |
9 | ### Implementation Details
10 |
11 | A `PriorityQueue` (binary heap) is utilised to keep track of the minimum weight edge that connects the current tree to
12 | an unexplored node. In an ideal scenario, the minimum weight edge to each node in the priority queue should be updated each
13 | time a lighter edge is found to maintain a single unique node in the priority queue. This means that a decrease key
14 | operation is required.
15 |
16 | **Decrease Key Operation:**
17 |
18 | However, we know that the decrease key operation of a binary heap implementation of a priority
19 | queue will take O(V) time, which will result in a larger time complexity for the entire algorithm compared to using only
20 | O(log V) operations for each edge. Hence, in our implementation, to avoid the use of a decrease key operation, we will simply insert duplicate nodes with
21 | their new minimum weight edge, which will take O(log E) = O(log V) given an upper bound of E = V^2, into the queue,
22 | while leaving the old node in the queue. Additionally, we will track if a node has already been added into the MST to
23 | avoid adding duplicate nodes.
24 |
25 | **Priority Queue Implementation:**
26 |
27 | Note that a priority queue is an abstract data type that can be implemented using different data structures. In this
28 | implementation, the default Java `PriorityQueue` is used, which is a binary heap. By implementing the priority queue
29 | with an AVL tree, a decrease key operation that has a time complexity of O(log V) can also be achieved.
30 |
31 | ## Complexity Analysis
32 |
33 | **Time Complexity:**
34 | - O(V^2 log V) for the basic version with an adjacency matrix, where V is the number of vertices.
35 | - O(E log V) with a binary heap and adjacency list, where V and E is the number of vertices and edges
36 | respectively.
37 |
38 | **Space Complexity:**
39 | - O(V^2) for the adjacency matrix representation.
40 | - O(V + E) for the adjacency list representation.
41 |
42 | ## Notes
43 |
44 | ### Difference between Prim's Algorithm and Dijkstra's Algorithm
45 |
46 | | | Prim's Algorithm | Dijkstra's Algorithm |
47 | |-------------------------------------|---------------------------------------------------------------------------------|----------------------------------------------------------|
48 | | Purpose | Finds MST - minimum sum of edge weights that includes all vertices in the graph | Finds shortest path from a single source to all vertices |
49 | | Property Compared in Priority Queue | Minimum weight of incoming edge to a vertex | Minimum distance from source vertex to current vertex |
50 |
51 |
--------------------------------------------------------------------------------
/src/main/java/algorithms/orthogonalRangeSearching/RangeTreeNode.java:
--------------------------------------------------------------------------------
1 | package algorithms.orthogonalRangeSearching;
2 |
3 | /**
4 | * This class is the node class for building a range tree.
5 | * @param Generic type of the node class
6 | */
7 | public class RangeTreeNode {
8 | private T val;
9 | private int height;
10 | private RangeTreeNode left = null;
11 | private RangeTreeNode right = null;
12 | private RangeTreeNode parent = null;
13 | private RangeTreeNode yTree = null;
14 |
15 | public RangeTreeNode(T val) {
16 | this.val = val;
17 | }
18 |
19 | /**
20 | * Constructor for range tree node
21 | * @param val value of node
22 | * @param left left child of node
23 | * @param right right child of node
24 | */
25 | public RangeTreeNode(T val, RangeTreeNode left, RangeTreeNode right) {
26 | this.val = val;
27 | this.left = left;
28 | this.right = right;
29 | }
30 |
31 | public T getVal() {
32 | return this.val;
33 | }
34 |
35 | public int getHeight() {
36 | return this.height;
37 | }
38 |
39 | public RangeTreeNode getLeft() {
40 | return this.left;
41 | }
42 |
43 | public RangeTreeNode getRight() {
44 | return this.right;
45 | }
46 |
47 | public RangeTreeNode getParent() {
48 | return this.parent;
49 | }
50 |
51 | public RangeTreeNode getYTree() {
52 | return this.yTree;
53 | }
54 |
55 | public void setVal(T val) {
56 | this.val = val;
57 | }
58 |
59 | public void setLeft(RangeTreeNode left) {
60 | this.left = left;
61 | }
62 |
63 | public void setRight(RangeTreeNode right) {
64 | this.right = right;
65 | }
66 |
67 | public void setParent(RangeTreeNode parent) {
68 | this.parent = parent;
69 | }
70 |
71 | public void setHeight(int height) {
72 | this.height = height;
73 | }
74 |
75 | public void setYTree(RangeTreeNode yTree) {
76 | this.yTree = yTree;
77 | }
78 |
79 | @Override
80 | public boolean equals(Object other) {
81 | if (other == this) {
82 | return true;
83 | }
84 | if (!(other instanceof RangeTreeNode)) {
85 | return false;
86 | }
87 | RangeTreeNode node = (RangeTreeNode) other;
88 | return this.val == node.val;
89 | }
90 |
91 | @Override
92 | public String toString() {
93 | return String.valueOf(this.val);
94 | }
95 |
96 | }
97 |
--------------------------------------------------------------------------------
/src/main/java/algorithms/orthogonalRangeSearching/oneDim/README.md:
--------------------------------------------------------------------------------
1 | # 1D Orthogonal Range Searching
2 |
3 | 1D orthogonal range searching is a computational problem where you search for elements or data points within a
4 | specified 1D range (interval) in a collection of 1D data (e.g. Find me everyone between ages 22 and 27). Additionally,
5 | we also want to support efficient insertions of new data points into the maintained set.
6 |
7 | One strategy would be to sort all the data points in O(nlogn) time, then insertion would take O(n). We can binary
8 | search the low and high of the specified range to return the start and end indices of all the data points within
9 | in O(logn) time. This would be a reasonable approach if the no. of queries >> no. of insertions.
10 |
11 | In cases where the no. of insertions >> no. of queries, we might want to further optimise the time complexity of
12 | insertions to O(logn) using a 1D range tree.
13 |
14 | Strategy:
15 | 1. Use a binary search tree
16 | 2. Store all points in the leaves of the tree (internal nodes only store copies)
17 | 3. Each internal node v stores the MAX of any leaf in the left sub-tree (**range tree property**)
18 |
19 | 
20 |
21 | Say we want to find all the nodes between 10 and 50 i.e. query(10, 50). We would want to:
22 | 1. Find split node: highest node where search includes both left & right subtrees
23 | => we want to make use of the range tree property to perform binary search to find our split node. See findSplit(root, low, high) in code.
24 | 2. Left traversal & right traversal
25 | - Left traversal covers the range within [low, splitNode]
26 | - Right traversal covers the range within (splitNode, high]
27 |
28 | 
29 | Image Source: Lecture Slides
30 |
31 | ## Complexity Analysis
32 | **Time**:
33 |
34 | Build Tree (cost incurred once only):
35 | - if given an unsorted array, O(nlogn) limited by sorting step
36 | - if given a sorted array, O(n)
37 |
38 | Querying: O(k + logn)
39 | - Find Split Node: O(logn) (binary search)
40 | - Left Traversal: at every step, we either
41 | 1. output all-right subtree (O(k) where k is no. of leaves) and recurse left
42 | 2. recurse right (at most logn times)
43 | - Right Traversal: similar to left traversal
44 |
45 | **Space**: S(n) = S(n / 2) + O(n) => O(nlogn)
46 |
47 | ## Notes
48 | ### Dynamic Updates
49 | If we need to dynamically update the tree, insertion and deletion is done in a manner similar to AVL trees
50 | (insert/delete and rotate to maintain height balance), except now we need to ensure that we are adding the new node
51 | as a leaf node, and we still need to adhere to the range tree property.
52 |
53 | Note how the ORS tree property enables efficient dynamic updating of the tree, as the value of the nodes do not need
54 | to change after rotation.
55 |
56 | 
57 |
58 | For more implementation details, refer to the code below "// Functions from here onwards are designed to support
59 | dynamic updates."
60 |
--------------------------------------------------------------------------------
/src/main/java/algorithms/orthogonalRangeSearching/twoDim/README.md:
--------------------------------------------------------------------------------
1 | # 2D Orthogonal Range Searching
2 |
3 | 2D orthogonal range searching is a computational problem that involves efficiently answering queries about points
4 | in a two-dimensional space that fall within a specified axis-aligned rectangular range (orthogonal range). In other
5 | words, given a set of points in 2D, find me all the points that lie within a specific rectangle.
6 |
7 | To do so, we can extend the idea of 1D range trees to the 2D context.
8 |
9 | Strategy
10 | - Each node in the x-tree has a set of points in its subtree
11 | - Store a y-tree at each x-node containing all the points in the x-subtree
12 |
13 | 
14 |
15 | 1. Build an x-tree using only x-coordinates.
16 | - This should be done in the exact same way as you would for a 1D range tree.
17 | 2. For every node in the x-tree, build a y-tree out of nodes in the x-subtree using only y-coordinates.
18 |
19 | 
20 |
21 | Given the 2D range tree, we now want to query the points in a given rectangle
22 | i.e. search(tree, xLow, xHigh, yLow, yHigh).
23 |
24 | We first want to find the points that will satisfy the x-condition i.e. find me all points whose x-coordinates are
25 | between xLow and xHigh. To do so, we first need to find our split node in the x-tree, by performing binary search[^1]
26 | while traversing the x-tree - similar to how we found the split node in a 1D range tree. This will give us our X-split.
27 |
28 | Now given our X-split, we want to find points that satisfy both our x-condition and y-condition.
29 |
30 | Let's first explore our x-left subtree (X-left traversal). If (xLow <= x-coordinate of curr node), we are confident
31 | that the entire right subtree of the curr node satisfies our x-condition (because of BST property).
32 |
33 | Now we want to perform a Y-search to find the points that also satisfy the y-condition. To do so, we first need to
34 | find our split node in the y-tree i.e. Y-split. Notice that the problem is now reduced to a 1D ORS problem. Once we
35 | have found Y-split, we can simply perform left traversal and right traversal from Y-split, similar to how it is done
36 | in 1D ORS.
37 |
38 | A similar symmetric logic applies in exploring our x-right subtree.
39 |
40 | 
41 | Image Source: https://www.cse.wustl.edu/~taoju/cse546/lectures/Lecture21_rangequery_2d.pdf
42 |
43 | ## Complexity Analysis
44 | **Time**:
45 |
46 | Build Tree (cost incurred once only): O(nlog^2n)
47 |
48 | Querying: O(k + log^2n)
49 | - O(logn) to find X-split
50 | - O(logn) recursing steps in X-left traversal/X-right-traversal
51 | - O(logn) y-tree searches of cost O(logn) => overall: O(log^2n)
52 | - O(k) enumerating output
53 |
54 | **Space**: O(nlogn)
55 | - Each point appears in at most 1 y-tree per level. (Refer to 1st image for visualisation)
56 | - There are O(logn) levels in the x-tree.
57 | - Therefore, each node appears in at most O(logn) y-trees. => overall: O(nlogn)
58 | - The x-tree takes O(n) space.
59 |
60 | ## Notes
61 | ### Dynamic Updates
62 | Unlike 1D range trees, dynamic updates in a 2D range tree are inefficient as rotations in the x-tree might involve
63 | entirely rebuilding the y-trees for the rotated notes. Therefore, 2D ORS is mainly used for static querying.
64 |
65 | ### d-dimensional Range Trees
66 | - Query cost: O(k + log^dn)
67 | - Build tree cost: O(nlog^(d-1)n)
68 | - Space: O(nlog^(d-1)n)
69 |
70 | [^1] This reference to binary search differs from our typical binary search formulation, but essentially refers
71 | to the findSplit function where you walk down the balanced tree and remove roughly half of the nodes each time.
--------------------------------------------------------------------------------
/src/main/java/algorithms/patternFinding/README.md:
--------------------------------------------------------------------------------
1 | # Knuth-Moris-Pratt Algorithm
2 |
3 | ## Background
4 | KMP match is a type of pattern-searching algorithm that improves the efficiency of naive search by avoiding unnecessary
5 | comparisons. It is most notable when the pattern has repeating sub-patterns.
6 |
7 | Pattern-searching problems is prevalent across many fields of CS, for instance,
8 | in text editors when searching for a pattern, in computational biology sequence matching problems,
9 | in NLP problems, and even for looking for file patterns for effective file management.
10 | It is hence crucial that we develop an efficient algorithm.
11 |
12 | Typically, the algorithm returns a list of indices that denote the start of each occurrence of the pattern string.
13 |
14 | 
15 | Image Source: GeeksforGeeks
16 |
17 | ### Intuition
18 | It's efficient because it utilizes the information gained from previous character comparisons. When a mismatch occurs,
19 | the algorithm uses this information to skip over as many characters as possible.
20 |
21 | Considering the string pattern:
22 |
23 | Pattern:| X | Y | X | Y | C | X | Y | X | Y | F |
24 | |-------|---|---|---|---|---|---|---|---|---|---|
25 | Position:| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10|
26 |
27 | and string:
28 |
29 | String: | X | Y | X | Y | C | X | Y | X | Y | C | X | Y | X | Y | F | G | A | B | C |
30 | |--------|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
31 | Position:| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10| 11| 12| 13| 14| 15| 16| 17| 18| 19|
32 |
33 | KMP has, during its initial processing of the pattern, identified that "XYXY" is a repeating sub-pattern.
34 | This means when the mismatch at F (10th character of the pattern) and C (10th character of the string) occurs,
35 | KMP doesn't need to start matching again from the very beginning of the pattern.
36 | Instead, it leverages the information that "XYXY" has already been matched.
37 |
38 | Therefore, the algorithm continues matching from the 5th character of the pattern string.
39 |
40 | This is the key idea behind KMP algorithm and is applied throughout the string.
41 | How it knows to 'reuse' previously identified sub-patterns is by keeping
42 | track of what is known as the Longest Prefix Suffix (LPS; Longest prefix that is also a suffix) Table. Look at the
43 | implementation for a step-by-step explanation for how LPS table is generated.
44 |
45 | Pattern: | | X | Y | X | Y | C | X | Y | X | Y | F |
46 | |--------|---|---|---|---|---|---|---|---|---|---|---|
47 | Position:| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10|
48 | LPS: | -1| 0 | 0 | 1 | 2 | 0 | 1 | 2 | 3 | 4 | 0 |
49 |
50 | ## Complexity Analysis
51 | Let k be the length of the pattern and n be the length of the string to match against.
52 |
53 | Naively, we can look for patterns in a given sequence in O(nk) where n is the length of the sequence and k
54 | is the length of the pattern. We do this by iterating every character of the sequence, and look at the
55 | immediate k-1 characters that come after it. This is not a big issue if k is known to be small, but there's
56 | no guarantee this is the case.
57 |
58 | **Time complexity**: O(n+k)
59 |
60 | KMP does this in O(n+k) by making use of previously identified sub-patterns. It identifies sub-patterns
61 | by first processing the pattern input in O(k) time, allowing identification of patterns in
62 | O(n) traversal of the sequence. More details found in the src code.
63 |
64 | **Space complexity**: O(k) auxiliary space to store suffix that matches with prefix of the pattern string
65 |
66 | ## Notes
67 | 1. A detailed illustration of how the algorithm works is shown in the code.
68 | But if you have trouble understanding the implementation,
69 | here is a good [video](https://www.youtube.com/watch?v=EL4ZbRF587g) as well.
70 | 2. A subroutine to find Longest Prefix Suffix (LPS) is commonly involved in the preprocessing step of KMP.
71 | It may be useful to interpret these numbers as the number of characters matched between the suffix and prefix.
72 | Knowing the number of characters of prefix would help in informing the position of the next character of the pattern to
73 | match.
74 |
--------------------------------------------------------------------------------
/src/main/java/algorithms/sorting/bubbleSort/BubbleSort.java:
--------------------------------------------------------------------------------
1 | package algorithms.sorting.bubbleSort;
2 |
3 | /**
4 | * Here, we are implementing BubbleSort where we sort the array in increasing (or more precisely, non-decreasing)
5 | * order. Below are some details specific to this implementation.
6 | *
7 | * Early Termination:
8 | * At the end of the (n-1)th iteration of the outer loop, where n is the length of the array, the largest (n-1)
9 | * elements are correctly sorted at the final (n-1) positions of the array, leaving the last 1 element placed correctly
10 | * in the first position of the array. Therefore, (n-1) iterations of the outer loop is sufficient.
11 | *
12 | * Slight optimisation:
13 | * At the kth iteration of the outer loop, we only require (n-k) adjacent comparisons to get the kth-largest element
14 | * to its correct position.
15 | */
16 | public class BubbleSort {
17 | /**
18 | * Sorts the given array in-place in non-decreasing order.
19 | *
20 | * @param arr array to be sorted.
21 | * @return the same array arr that is sorted.
22 | */
23 | public static int[] sort(int[] arr) {
24 | int n = arr.length;
25 | boolean swapped; // tracks of the presence of swaps within one iteration of the outer loop to
26 | // facilitate early termination
27 | for (int i = 0; i < n - 1; i++) { // outer loop which supports the invariant; n-1 suffice
28 | swapped = false;
29 | for (int j = 0; j < n - 1 - i; j++) { // inner loop that does the adjacent comparisons
30 | if (arr[j] > arr[j + 1]) { // if we changed this to <, we will sort the array in non-increasing order
31 | int temp = arr[j];
32 | arr[j] = arr[j + 1];
33 | arr[j + 1] = temp;
34 | swapped = true;
35 | }
36 | }
37 | if (!swapped) {
38 | break;
39 | }
40 | }
41 | return arr;
42 | }
43 | }
44 |
--------------------------------------------------------------------------------
/src/main/java/algorithms/sorting/bubbleSort/README.md:
--------------------------------------------------------------------------------
1 | # Bubble Sort
2 |
3 | ## Background
4 |
5 | Bubble sort is one of the more intuitive comparison-based sorting algorithms.
6 | It makes repeated comparisons between neighbouring elements, 'bubbling' (side-by-side swaps)
7 | largest (or smallest) element in the unsorted region to the sorted region (often the front or the back).
8 |
9 | 
10 |
11 | ### Implementation Invariant
12 | **After the kth iteration, the biggest k items are correctly sorted at the final k positions of the array**.
13 |
14 | The job of the kth iteration of the outer loop is to bubble the kth-largest element to the kth position of the array
15 | from the right (i.e. its correct position).
16 | This is done through repeatedly comparing adjacent elements and swapping them if they are in the wrong order.
17 |
18 | ## Complexity Analysis
19 |
20 | **Time**:
21 |
22 | - Worst case (reverse sorted array): O(n^2)
23 | - Average case: O(n^2)
24 | - Best case (sorted array): O(n)
25 |
26 | In the worst case, during each iteration of the outer loop, the number of adjacent comparisons is upper-bounded
27 | by n. Since BubbleSort requires (n-1) iterations of the outer loop to sort the entire array, the total number
28 | of comparisons performed can be upper-bounded by (n-1) * n ≈ n^2.
29 |
30 | This implementation of BubbleSort terminates the outer loop once there are no swaps within one iteration of the
31 | outer loop. This improves the best case time complexity to O(n) for an already sorted array.
32 |
33 | **Space**: O(1) since sorting is done in-place
34 |
35 | ## Notes
--------------------------------------------------------------------------------
/src/main/java/algorithms/sorting/countingSort/CountingSort.java:
--------------------------------------------------------------------------------
1 | package algorithms.sorting.countingSort;
2 |
3 | /**
4 | *
Stable implementation of Counting Sort.
5 | * This non-comparison-based sorting algorithm is efficient for sorting integers with a small range.
6 | * For detailed explanation and complexity analysis, see README.
7 | */
8 | public class CountingSort {
9 | /**
10 | * Sorts the given array.
11 | *
12 | * @param arr array to be sorted.
13 | * @return new array that is sorted.
14 | */
15 | public static int[] sort(int[] arr) {
16 | int k = 0;
17 | int n = arr.length;
18 | // Find the max. value in arr. This tells us the size of the freq map array.
19 | for (int i = 0; i < n; i++) {
20 | k = Math.max(k, arr[i]);
21 | }
22 | // Obtain frequency map
23 | int[] freq = new int[k + 1];
24 | for (int num : arr) {
25 | freq[num]++;
26 | }
27 | // Obtain prefix sum of freq map
28 | for (int i = 1; i < k + 1; i++) {
29 | freq[i] += freq[i - 1];
30 | }
31 | // Sort the array by placing element in the output array
32 | int[] sorted = new int[n];
33 | for (int i = arr.length - 1; i >= 0; i--) { // we start from the back to maintain stable property
34 | int num = arr[i];
35 | sorted[freq[num] - 1] = num; // freq[num]-1 because 0-indexed
36 | freq[num]--;
37 | }
38 | return sorted;
39 | }
40 | }
41 |
--------------------------------------------------------------------------------
/src/main/java/algorithms/sorting/countingSort/README.md:
--------------------------------------------------------------------------------
1 | # Counting Sort
2 |
3 | ## Background
4 |
5 | Counting sort is a non-comparison-based sorting algorithm and isn't bounded by the O(nlogn) lower-bound
6 | of most sorting algorithms.
7 | It first obtains the frequency map of all elements (i.e. counting the occurrence of every element), then
8 | computes the prefix sum for the map. This prefix map tells us which position an element should be inserted.
9 | It is updated after each insertion to reflect the new position to insert the next time the same element is
10 | encountered.
11 |
12 | 
13 |
14 | Image Source: https://www.oreilly.com/library/view/mastering-algorithms-with/1565924533/ch12s13.html
15 |
16 | _To align with the naming convention of our implementation, data => arr, counts => freq, temp => sorted._
17 |
18 | ### Implementation Invariant
19 |
20 | **At the end of the ith iteration, the ith element (of the original array) from the back will be placed in
21 | its correct position**.
22 |
23 | Note: An alternative implementation from the front is easily done with minor modification.
24 | The catch is that this implementation would not be stable.
25 |
26 | ### Common Misconception
27 |
28 | _"Counting sort does not require total ordering of elements since it is non-comparison based."_
29 |
30 | This is incorrect. It requires total ordering of elements to determine their relative positions in the sorted output.
31 | In our implementation, the total ordering property is reflected by virtue of the structure of the frequency map.
32 |
33 | ## Complexity Analysis
34 |
35 | **Time**: O(k+n)=O(max(k,n))
36 | **Space**: O(k+n)=O(max(k,n))
37 | where k is the value of the largest element and n is the number of elements.
38 |
39 | Counting sort is most efficient if the range of input values do not exceed the number of input values.
40 | Counting sort is NOT AN IN-PLACE algorithm. For one, it requires additional space to store freq map.
41 |
42 | ## Notes
43 |
44 | 1. Our counting sort implementation works only on non-negative integers. However, to adapt it to work for arrays with
45 | negative integers, we can add an offset of +m, where m is the smallest integer in the array.
46 | 2. Counting sort (stable version) is often used as a sub-routine for radix sort.
47 | 3. Supplementary: Here is a [video](https://www.youtube.com/watch?v=OKd534EWcdk) if you are still having troubles.
48 |
--------------------------------------------------------------------------------
/src/main/java/algorithms/sorting/cyclicSort/README.md:
--------------------------------------------------------------------------------
1 | # Cyclic Sort
2 |
3 | ## Background
4 |
5 | Cyclic sort is a comparison-based, in-place algorithm that performs sorting (generally) in O(n^2) time.
6 | Under some special conditions (discussed later), the algorithm is non-comparison based and
7 | the best case could be done in O(n) time. This is the version that tends to be used in practice.
8 |
9 | ### Implementation Invariant
10 |
11 | **At the end of the kth iteration, the smallest (largest) i items are correctly sorted
12 | in the first (last) i positions of the array**.
13 |
14 | ### Comparison to Selection Sort
15 |
16 | Its invariant is quite similar as selection sort's. But they differ in maintaining this invariant.
17 | The algorithm for cyclic sort does a bit more than selection sort's.
18 | In the process of trying to find the correct element for the ith position, any element that was
19 | encountered will be correctly placed in their positions as well.
20 |
21 | This allows cyclic sort to have a time complexity of O(n) for certain inputs.
22 | (where the relative ordering of the elements is already known). This is discussed in the [**simple**](./simple) case.
23 |
24 | ## Simple and Generalised Case
25 |
26 | We discuss more implementation-specific details and complexity analysis in the respective folders. In short,
27 |
28 | 1. The [**simple**](./simple) case discusses the **non-comparison based** implementation of cyclic sort under
29 | certain conditions. This allows the best case to be better than O(n^2).
30 | 2. The [**generalised**](./generalised) case discusses cyclic sort for general inputs. This is comparison-based and is
31 | typically implemented in O(n^2).
32 |
33 | Note that, in practice, the generalised case is hardly used. There are more efficient algorithms to use for sorting,
34 | e.g. merge and quick sort. If the concern is the number of swaps, generalized cyclic sort does indeed require fewer
35 | swaps, but likely won't lower than selection sort's.
36 |
37 | In other words, **cyclic sort is specially designed for situations where the elements to be sorted are
38 | known to fall within a specific, continuous range, such as integers from 1 to n, without any gaps or duplicates.**
39 |
40 |
41 |
--------------------------------------------------------------------------------
/src/main/java/algorithms/sorting/cyclicSort/generalised/CyclicSort.java:
--------------------------------------------------------------------------------
1 | package algorithms.sorting.cyclicSort.generalised;
2 | /**
3 | * Implementation of cyclic sort in the generalised case where the input can contain any integer and duplicates.
4 | */
5 | public class CyclicSort {
6 | /**
7 | * Sorts the given array using CyclicSort. Generalised case where the input array can contain any integer, and
8 | * can contain duplicates.
9 | * See documentation in README for more details.
10 | *
11 | * @param arr the given array to be sorted. Can contain any integers and can contain duplicates.
12 | * @param n the size of the given array to be sorted.
13 | */
14 | public static void cyclicSort(int[] arr, int n) {
15 | for (int currIdx = 0; currIdx < n - 1; currIdx++) {
16 | int currElement;
17 | int rightfulPos;
18 |
19 | do {
20 | rightfulPos = currIdx; // initialization since elements before currIdx are correctly placed
21 | currElement = arr[currIdx];
22 | for (int i = currIdx + 1; i < n; i++) { // O(n) find rightfulPos for the currElement
23 | if (arr[i] < currElement) {
24 | rightfulPos++;
25 | }
26 | }
27 | if (rightfulPos == currIdx) { // verified curr position is correct for curr element
28 | break;
29 | }
30 | while (currElement == arr[rightfulPos]) { // duplicates found, so find next suitable position
31 | rightfulPos++;
32 | }
33 | int tmp = currElement; // swap, put item in its rightful position
34 | arr[currIdx] = arr[rightfulPos];
35 | arr[rightfulPos] = tmp;
36 | } while (rightfulPos != currIdx);
37 | }
38 | }
39 |
40 | /**
41 | * Overloaded helper method that calls internal implementation.
42 | * @param arr the input array to be sorted.
43 | */
44 | public static void sort(int[] arr) {
45 | cyclicSort(arr, arr.length);
46 | }
47 | }
48 |
--------------------------------------------------------------------------------
/src/main/java/algorithms/sorting/cyclicSort/generalised/README.md:
--------------------------------------------------------------------------------
1 | # Generalized Case
2 |
3 | ## Background
4 |
5 | Implementation of cyclic sort in the generalised case where the input can contain any integer and duplicates.
6 |
7 | This is a comparison-based algorithm. In short, for the element encountered at the ith position of the original array,
8 | the algorithm does a O(n) traversal to search for its rightful position and does a swap. It repeats this until a swap
9 | placing the correct element at the ith position, before moving onto the next (i+1)th.
10 |
11 | ### Illustration
12 |
13 | Result: 6 10 6 5 7 4 2 1
14 | Read: ^ 6 should be placed at index 4, so we do a swap with 6 and 7,
15 | Result: 7 10 6 5 6 4 2 1
16 | Read: ^ 7 should be placed at index 6, so we do a swap. Note that index 5 should be taken up by dup 6
17 | Result: 2 10 6 5 6 4 7 1
18 | Read: ^ 2 should be placed at index 1, so swap.
19 | Result: 10 2 6 5 6 4 7 1
20 | Read: ^ 10 is the largest, should be placed at last index, so swap.
21 | Result: 1 2 6 5 6 4 7 10
22 | Read: ^ Correctly placed, so move on. Same for 2.
23 | Read:
24 | ^ 6 should be placed at index 4. But index 4 already has a 6. So place at index 5 and so on.
25 | Result: 1 2 4 5 6 6 7 10
26 | Read:
27 | ^ ^ ^ ^ ^ Continue with O(n) verification of correct position at each iteration
28 |
29 | ## Complexity Analysis
30 |
31 | **Time**:
32 |
33 | - Best: O(n^2) even if the ith element is encountered in the ith position, a O(n) traversal validation check is needed
34 | - Worst: O(n^2) since we need O(n) time to find / validate the correct position of an element and
35 | the total number of O(n) traversals is bounded by O(n).
36 | - Average: O(n^2), it's bounded by the above two
37 |
38 | **Space**: O(1) auxiliary space, this is an in-place algorithm
39 |
40 | ## Notes
--------------------------------------------------------------------------------
/src/main/java/algorithms/sorting/cyclicSort/simple/CyclicSort.java:
--------------------------------------------------------------------------------
1 | package algorithms.sorting.cyclicSort.simple;
2 |
3 | /**
4 | * Implementation of cyclic sort in the simple case where the n elements of the given array are contiguous,
5 | * but not in sorted order. Below illustrates the idea using integers from 0 to n-1.
6 | */
7 | public class CyclicSort {
8 | /**
9 | * Sorts the given array.
10 | *
11 | * @param arr the array to be sorted.
12 | */
13 | public static void sort(int[] arr) {
14 | int curr = 0; // can be easily modified to work on n numbers starting at some other number
15 | while (curr < arr.length) { // iterate until the end of the array
16 | int ele = arr[curr]; // encounter an element that may not be in its correct position
17 | assert ele >= 0 && ele < arr.length : "Input array should only have integers from 0 to n-1 (inclusive)";
18 | if (ele != curr) { // verified that it is indeed not the correct element to be placed at curr position
19 | int tmp = arr[ele]; // go to the correct position of ele
20 | arr[ele] = ele; // do a swap
21 | arr[curr] = tmp; // note that curr isn't incremented because we haven't yet placed the correct element
22 | } else {
23 | curr += 1; // found the correct element to be placed at curr, which in this eg, is itself, so, increment
24 | }
25 | }
26 | }
27 | }
28 |
--------------------------------------------------------------------------------
/src/main/java/algorithms/sorting/cyclicSort/simple/FindFirstMissingNonNegative.java:
--------------------------------------------------------------------------------
1 | package algorithms.sorting.cyclicSort.simple;
2 |
3 | /**
4 | * Cyclic sort algorithm can be easily modified to find first missing non-negative integer (i.e. starting from 0)
5 | * in O(n).
6 | */
7 | public class FindFirstMissingNonNegative {
8 | /**
9 | * Finds the first missing non-negative integer in the array.
10 | *
11 | * @param arr the given array.
12 | * @return the first missing, non-negative integer.
13 | */
14 | public static int findMissing(int[] arr) {
15 | int curr = 0;
16 | while (curr < arr.length) {
17 | int ele = arr[curr];
18 | if (ele >= 0 && ele < arr.length && ele != curr) { // if ele (still) needs to be placed in its correct pos
19 | if (arr[ele] == ele) { // the correct position of ele already has ele (i.e. duplicates), so just move on
20 | curr += 1;
21 | continue;
22 | }
23 | int tmp = arr[ele]; // do the swap and place ele at its right position first
24 | arr[ele] = ele;
25 | arr[curr] = tmp;
26 | } else {
27 | curr += 1; // either found the correct element, or a number out of range to ignore first.
28 | }
29 | }
30 |
31 | for (int i = 0; i < arr.length; i++) { // iterate to look for the missing number which will be out of place.
32 | if (arr[i] != i) {
33 | return i; // this is the missing non-negative element!
34 | }
35 | }
36 | return arr.length; // 0 to n-1 integers are all present. First missing non-negative element is n.
37 | }
38 | }
39 |
--------------------------------------------------------------------------------
/src/main/java/algorithms/sorting/cyclicSort/simple/README.md:
--------------------------------------------------------------------------------
1 | # Simple Case
2 |
3 | ## Background
4 |
5 | Cyclic Sort can achieve O(n) time complexity in cases where the elements of the collection have a known,
6 | continuous range, and there exists a direct, O(1) time-complexity mapping from each element to its respective index in
7 | the sorted order.
8 |
9 | This is typically applicable when sorting a sequence of integers that are in a consecutive range
10 | or can be easily mapped to such a range. We illustrate the idea with n integers from 0 to n-1.
11 |
12 | In this implementation, the algorithm is **not comparison-based**! (unlike the general case).
13 | It makes use of the known inherent ordering of the numbers,
14 | bypassing the `nlogn` lower bound for most sorting algorithms.
15 |
16 |
17 | Duplicates
18 | Not designed to hande duplicates. When duplicates are present, the algorithm can run into issues,
19 | such as overwriting elements or getting stuck in infinite loops,
20 | because it assumes that each element has a unique position in the array.
21 |
22 | If you need to handle duplicates, modifications are required,
23 | such as checking for duplicate values before placing elements,
24 | which can impact the simplicity and efficiency (possibly degrade to `O(n^2)`) of the algorithm.
25 |
26 |
27 |
28 | Inherent Ordering..?
29 | This property allows the sorting algorithm to avoid comparing elements with each other
30 | and instead directly place each element in its correct position.
31 |
32 | For example, if sorting integers from 0 to n-1, the number 0 naturally belongs at index 0, 1 at index 1, and so on.
33 | This inherent structure allows Cyclic Sort to achieve `O(n)` time complexity,
34 | bypassing the typical `O(nlogn)` time bound of comparison-based sorting algorithms
35 | ([proof](https://tildesites.bowdoin.edu/~ltoma/teaching/cs231/fall07/Lectures/sortLB.pdf))
36 | by using the known order of elements rather than making comparisons to determine their positions.
37 |
38 |
39 | ## Complexity Analysis
40 |
41 | **Time**:
42 |
43 | - Best: O(n) since the array has to be traversed
44 | - Worst: O(n) since each element is at most seen twice
45 | - Average: O(n), it's bounded by the above two
46 |
47 | **Space**: O(1) auxiliary space, this is an in-place algorithm
48 |
49 | ## Case Study: Find First Missing Non-negative Integer
50 |
51 | Cyclic sort algorithm can be easily modified to find first missing non-negative integer (i.e. starting from 0) in O(n).
52 | The invariant is the same, but for numbers that are out-of-range (negative or greater than n),
53 | simply ignore the number at the position and
54 | move on first. It may be subject to swap later.
55 |
56 | There are other ways of doing so, using a hash set for instance, but what makes cyclic sort stand out is that it is
57 | able to do so in O(1) space. In other words, it is in-place and require no additional space.
58 |
59 | The algorithm does a 2-pass iteration.
60 |
61 | 1. In the 1st iteration, it places elements at its rightful position where possible.
62 | 2. In the 2nd iteration, it will look for the first out of place element (element that is not supposed
63 | to be in that position). The answer will be the index of that position.
64 |
65 | Note that the answer is necessarily between 0 and n (inclusive), where n is the length of the array,
66 | otherwise there would be a contradiction.
67 |
68 | ## Notes
69 |
70 | 1. It may seem quite trivial to sort integers from 0 to n-1 when one could simply generate such a sequence.
71 | But this algorithm is useful in cases where the integers to be sorted are keys to associated values (or some mapping)
72 | and sorting needs to be done in O(1) auxiliary space.
73 | 2. The implementation here uses integers from 0 to n-1. This can be easily modified for n contiguous integers starting
74 | at some arbitrary number (simply offset by this start number).
75 | 3. This version of cyclic sort does not handle duplicates (at least, sorting might not be guaranteed to be in O(n))
76 |
--------------------------------------------------------------------------------
/src/main/java/algorithms/sorting/insertionSort/InsertionSort.java:
--------------------------------------------------------------------------------
1 | package algorithms.sorting.insertionSort;
2 |
3 | /**
4 | * Here, we are implementing InsertionSort where we sort the array in increasing (or more precisely, non-decreasing)
5 | * order.
6 | *
7 | * Note:
8 | * 1. the loop invariant here slightly differs from the lecture slides as we are using 0-based indexing
9 | * 2. Insertion into the sorted portion is done byb 'bubbling' elements as in bubble sort
10 | */
11 |
12 | public class InsertionSort {
13 | /**
14 | * Sorts the given array in-place in non-decreasing order.
15 | *
16 | * @param arr array to be sorted.
17 | * @return the same array arr that is sorted.
18 | */
19 | public static int[] sort(int[] arr) {
20 | int n = arr.length;
21 | for (int i = 1; i < n; i++) { //loop which supports the invariant
22 | arr = insert(arr, i, arr[i]);
23 | }
24 | return arr;
25 | }
26 |
27 | /**
28 | * Inserts val within the sorted portion of the array. The sorted portion of the array is arr[0, idx - 1].
29 | *
30 | * @param arr the array to be sorted (of length idx)
31 | * @param idx index of the element to be inserted into the sorted portion of the array
32 | * @param val value of the element to be inserted into the sorted portion of the array
33 | * @return returns arr with arr[0, idx] in sorted order
34 | */
35 | private static int[] insert(int[] arr, int idx, int val) {
36 | int pointer = idx - 1;
37 |
38 | while (pointer >= 0 && arr[pointer] > val) { //if we change this to arr[pointer] < val,
39 | // we can sort the array in non-increasing order
40 | arr[pointer + 1] = arr[pointer];
41 | pointer -= 1;
42 | }
43 | arr[pointer + 1] = val;
44 |
45 | return arr;
46 | }
47 | }
48 |
--------------------------------------------------------------------------------
/src/main/java/algorithms/sorting/insertionSort/README.md:
--------------------------------------------------------------------------------
1 | # Insertion Sort
2 |
3 | ## Background
4 |
5 | Insertion sort is a comparison-based sorting algorithm that builds the final sorted array one element at a
6 | time. It works by repeatedly taking an element from the unsorted portion of the array and
7 | inserting it correctly (portion remains sorted) into the sorted portion. Note that the position is not final
8 | since subsequent elements from unsorted portion may displace previously inserted elements. What's important is
9 | the sorted region remains sorted.
10 |
11 | More succinctly, at the kth iteration, we take the element arr[k] and insert
12 | it into arr[0, k-1] following sorted order, returning us arr[0, k] in sorted order.
13 |
14 | 
15 |
16 | ### Implementation Invariant
17 | The loop invariant: **At the end of kth iteration, the first (k+1) items in the array are in sorted order**.
18 |
19 | At the end of the (n-1)th iteration, all n items in the array will be in sorted order.
20 |
21 | ## Complexity Analysis
22 |
23 | **Time**:
24 |
25 | - Worst case (reverse sorted array): O(n^2)
26 | - Average case: O(n^2)
27 | - Best case (sorted array): O(n)
28 |
29 | In the worst case, inserting an element into the sorted array of length m requires us to iterate through the
30 | entire array, requiring O(m) time. Since InsertionSort does this insertion (n - 1) times, the time complexity
31 | of InsertionSort in the worst case is 1 + 2 + ... + (n-2) + (n-1) = O(n^2).
32 |
33 | In the best case of an already sorted array, inserting an element into the sorted array of length m requires
34 | O(1) time as we insert it directly behind the first position of the pointer in the sorted array. Since InsertionSort
35 | does this insertion (n-1) times, the time complexity of InsertionSort in the best case is O(1) * (n-1) = O(n).
36 |
37 | **Space**: O(1) since sorting is done in-place
38 |
39 | ## Notes
40 |
41 | ### Common Misconception
42 |
43 | Its invariant is often confused with selection sort's. In selection sort, an element in the unsorted region will
44 | be immediately placed in its correct and final position as it would be in the sorted array. This is not the case
45 | for insertion sort. However, it is because of this 'looser' invariant that allows for a better best case time complexity
46 | for insertion sort.
47 |
48 | Image Source: https://www.hackerrank.com/challenges/correctness-invariant/problem
49 |
--------------------------------------------------------------------------------
/src/main/java/algorithms/sorting/mergeSort/iterative/MergeSort.java:
--------------------------------------------------------------------------------
1 | package algorithms.sorting.mergeSort.iterative;
2 |
3 | /**
4 | * Here, we are implementing MergeSort where we sort the array in increasing (or more precisely, non-decreasing)
5 | * order iteratively.
6 | */
7 |
8 | public class MergeSort {
9 |
10 | /**
11 | * Sorts the given array in non-decreasing order.
12 | *
13 | * @param arr The given array to be sorted.
14 | */
15 | public static void sort(int[] arr) {
16 | int interval = 1;
17 | int n = arr.length;
18 | int[] temp = new int[n];
19 |
20 | while (interval < n) {
21 | for (int i = 0; i < n - interval; i += 2 * interval) {
22 | int end = Math.min(i + 2 * interval - 1, n - 1);
23 | int mid = i + interval - 1;
24 | merge(arr, i, mid, end, temp);
25 | }
26 | interval *= 2;
27 | }
28 | }
29 |
30 | /**
31 | * Merges two sorted sub-arrays within the given array. The two sub-arrays are arr[start, mid] and
32 | * arr[mid + 1, end]. Upon completion of this function, arr[start, end] will be in sorted order.
33 | *
34 | * @param arr The array containing the sub-arrays to be merged.
35 | * @param start The starting index of the first sub-array to be merged.
36 | * @param mid The ending index (inclusive) of the first sub-array to be merged. In the iterative implementation,
37 | * the mid parameter is required in the merge function to determine the splitting point between the
38 | * sub-arrays to be merged.
39 | * @param end The ending index (inclusive) of the second sub-array to be merged.
40 | * @param temp A temporary array used for merging intermediate results.
41 | */
42 | private static void merge(int[] arr, int start, int mid, int end, int[] temp) {
43 | int i = start;
44 | int j = mid + 1;
45 | int pointer = start;
46 |
47 | // Merge the two sorted sub-arrays into the temp array
48 | while (i <= mid && j <= end) {
49 | if (arr[i] <= arr[j]) {
50 | //we use <= here to maintain stability of MergeSort. If arr[i] == arr[j], the algorithm prefers the
51 | //one from the left sub-array (arr[i]). This decision preserves the relative order of equal elements.
52 |
53 | //if we change this to arr[i] >= arr[j], we can sort the array in non-increasing order.
54 |
55 | temp[pointer] = arr[i];
56 | i++;
57 | } else {
58 | temp[pointer] = arr[j];
59 | j++;
60 | }
61 | pointer++;
62 | }
63 |
64 | // Copy any remaining elements from the left sub-array
65 | while (i <= mid) {
66 | temp[pointer] = arr[i];
67 | i++;
68 | pointer++;
69 | }
70 |
71 | // Copy any remaining elements from the right sub-array
72 | while (j <= end) {
73 | temp[pointer] = arr[j];
74 | j++;
75 | pointer++;
76 | }
77 |
78 | // Copy the merged elements back to the original array
79 | if (end + 1 - start >= 0) {
80 | System.arraycopy(temp, start, arr, start, end + 1 - start);
81 | }
82 | }
83 |
84 | }
85 |
--------------------------------------------------------------------------------
/src/main/java/algorithms/sorting/mergeSort/iterative/README.md:
--------------------------------------------------------------------------------
1 | # Merge Sort
2 |
3 | ### Background
4 | The iterative implementation of MergeSort takes a bottom-up approach, where the sorting process starts by merging
5 | intervals of size 1. Intervals of size 1 are trivially in sorted order. The algorithm then proceeds to merge
6 | adjacent sorted intervals, doubling the interval size with each merge step, until the entire array is fully sorted.
7 |
8 | 
9 |
10 | Image Source: https://www.chelponline.com/iterative-merge-sort-12243
11 |
12 | ### Implementation Invariant
13 | At each iteration of the merging process, the main array is divided into sub-arrays of a certain interval
14 | size (interval). Each of these sub-arrays is sorted within itself. The last sub-array may not be of size
15 | interval, but it is still sorted since its size is necessarily less than interval.
16 |
17 | ### Complexity Analysis
18 | Time:
19 | - Worst case: O(nlogn)
20 | - Average case: O(nlogn)
21 | - Best case: O(nlogn)
22 |
23 | Given two sorted arrays of size p and q, we need O(p + q) time to merge the two arrays into one sorted array, since
24 | we have to iterate through every element in both arrays once.
25 |
26 | - At the 1st level of the merge process, our merging subroutine involves n sub-arrays of size 1, taking O(n) time.
27 | - At the 2nd level of the merge process, our merging subroutine involves (n/2) sub-arrays of size 2, taking O(n) time.
28 | - At the kth level of the merge process, our merging subroutine involves (n/(2^(k-1))) sub-arrays of size (2^(k-1)),
29 | taking O(n) time.
30 |
31 | Since interval doubles at every iteration of the merge process, there are logn such levels. Every level takes
32 | O(n) time, hence overall time complexity is n * logn = O(nlogn)
33 |
34 | Regardless of how sorted the input array is, MergeSort carries out the partitioning and merging process, so the
35 | time complexity of MergeSort is O(nlogn) for all cases.
36 |
37 | Space:
38 | - O(n) since we require a temporary array to temporarily store the merged elements in sorted order
--------------------------------------------------------------------------------
/src/main/java/algorithms/sorting/mergeSort/recursive/MergeSort.java:
--------------------------------------------------------------------------------
1 | package algorithms.sorting.mergeSort.recursive;
2 |
3 | /**
4 | * Here, we are implementing MergeSort where we sort the array in increasing (or more precisely, non-decreasing)
5 | * order recursively.
6 | */
7 |
8 | public class MergeSort {
9 |
10 | /**
11 | * Sorts the sub-array arr[start, end] using the MergeSort algorithm.
12 | *
13 | * @param arr The given array to be sorted.
14 | * @param start The starting index of the sub-array to be sorted.
15 | * @param end The ending index (inclusive) of the sub-array to be sorted.
16 | * @param temp A temporary array used for merging.
17 | */
18 | private static void mergeSort(int[] arr, int start, int end, int[] temp) {
19 | if (start >= end) {
20 | return;
21 | }
22 | int mid = (start + end) / 2;
23 | mergeSort(arr, start, mid, temp);
24 | mergeSort(arr, mid + 1, end, temp);
25 | merge(arr, start, end, temp);
26 | }
27 |
28 | /**
29 | * Merges two sorted sub-arrays within the given array. The two sub-arrays are arr[start, mid] and
30 | * arr[mid + 1, end]. Upon completion of this function, arr[start, end] will be in sorted order.
31 | *
32 | * @param arr The array containing the sub-arrays to be merged.
33 | * @param start The starting index of the first sub-array to be merged.
34 | * @param end The ending index (inclusive) of the second sub-array to be merged.
35 | * @param temp A temporary array used for merging intermediate results.
36 | */
37 | private static void merge(int[] arr, int start, int end, int[] temp) {
38 | int mid = (start + end) / 2;
39 | int i = start;
40 | int j = mid + 1;
41 | int pointer = start;
42 |
43 | // Merge the two sorted sub-arrays into the temp array
44 | while (i <= mid && j <= end) {
45 | if (arr[i] <= arr[j]) {
46 | //we use <= here to maintain stability of MergeSort. If arr[i] == arr[j], the algorithm prefers the
47 | //one from the left sub-array (arr[i]). This decision preserves the relative order of equal elements.
48 |
49 | //if we change this to arr[i] >= arr[j], we can sort the array in non-increasing order.
50 |
51 | temp[pointer] = arr[i];
52 | i++;
53 | } else {
54 | temp[pointer] = arr[j];
55 | j++;
56 | }
57 | pointer++;
58 | }
59 |
60 | // Copy any remaining elements from the left sub-array
61 | while (i <= mid) {
62 | temp[pointer] = arr[i];
63 | i++;
64 | pointer++;
65 | }
66 |
67 | // Copy any remaining elements from the right sub-array
68 | while (j <= end) {
69 | temp[pointer] = arr[j];
70 | j++;
71 | pointer++;
72 | }
73 |
74 | // Copy the merged elements back to the original array
75 | if (end + 1 - start >= 0) {
76 | System.arraycopy(temp, start, arr, start, end + 1 - start);
77 | }
78 | }
79 |
80 | /**
81 | * Sorts the given array in non-decreasing order.
82 | *
83 | * @param arr The given array to be sorted
84 | */
85 | public static void sort(int[] arr) {
86 | int n = arr.length;
87 | int[] temp = new int[n];
88 | mergeSort(arr, 0, n - 1, temp);
89 | }
90 |
91 | }
92 |
--------------------------------------------------------------------------------
/src/main/java/algorithms/sorting/mergeSort/recursive/README.md:
--------------------------------------------------------------------------------
1 | # Merge Sort
2 |
3 | ### Background
4 | MergeSort is a divide-and-conquer sorting algorithm. The recursive implementation takes a top-down approach by
5 | recursively dividing the array into two halves, sorting each half separately, and then merging the sorted halves
6 | to produce the final sorted output.
7 |
8 | 
9 |
10 | Image Source: https://www.101computing.net/merge-sort-algorithm/
11 |
12 | ### Implementation Invariant (for the merging subroutine)
13 | The sub-array temp[start, (k-1)] consists of the (𝑘−start) smallest elements of arr[start, mid] and
14 | arr[mid + 1, end], in sorted order.
15 |
16 | ### Complexity Analysis
17 | Time:
18 | - Worst case: O(nlogn)
19 | - Average case: O(nlogn)
20 | - Best case: O(nlogn)
21 | Merging two sorted sub-arrays of size (n/2) requires O(n) time as we need to iterate through every element in both
22 | sub-arrays in order to merge the two sorted sub-arrays into one sorted array.
23 |
24 | Recursion expression: T(n) = 2T(n/2) + O(n) => O(nlogn)
25 |
26 | Regardless of how sorted the input array is, MergeSort carries out the same divide-and-conquer strategy, so the
27 | time complexity of MergeSort is O(nlogn) for all cases.
28 |
29 | Space:
30 | - O(n) since we require a temporary array to temporarily store the merged elements in sorted order
--------------------------------------------------------------------------------
/src/main/java/algorithms/sorting/quickSort/README.md:
--------------------------------------------------------------------------------
1 | # QuickSort
2 |
3 | This page will provide a high-level overview of the different types of QuickSort and the significance of each
4 | enhancement.
5 |
6 | 
7 |
8 | We start off with Simple QuickSort, which utilises Hoare's / Lomuto's partitioning with a fixed pivot. But the time
9 | complexity of Simple QuickSort degrades to O(n^2) when pivots chosen are continuously bad. This could be because of
10 | inputs such as sorted arrays, where picking the first element as the pivot will always lead to an extremely imbalanced
11 | partitioning. This could also be because of the presence of duplicates, as we now handle duplicates by putting them to
12 | one side of the pivot.
13 |
14 | Therefore, we introduced randomisation in pivot selection to prevent fixed pivot selection from continuously choosing
15 | a bad pivot. We also added a good pivot check (Paranoid) to Simple QuickSort to ensure that the pivots we select are
16 | "good" and will not cause extremely imbalanced partitions. However, the presence of the good pivot checks will cause
17 | infinite recursion when the array contains many duplicates, since any pivot you choose in the array will fail the good
18 | pivot check.
19 |
20 | So, we introduced 3-way partitioning to handle duplicates by partitioning the array into three sections: elements less
21 | than the pivot, elements equal to the pivot, and elements greater than the pivot. Now the good pivot check ignores the
22 | size of the segment that comprises elements = to pivot.
23 |
24 | ## Recommended Order of Reading
25 | 1. [Hoares](./hoares)
26 | 2. [Lomuto](./lomuto)
27 | 3. [Paranoid](./paranoid)
28 | 4. [3-way partitioning](./threeWayPartitioning)
29 |
--------------------------------------------------------------------------------
/src/main/java/algorithms/sorting/quickSort/hoares/QuickSort.java:
--------------------------------------------------------------------------------
1 | package algorithms.sorting.quickSort.hoares;
2 |
3 | /**
4 | * Here, we are implementing Hoares's QuickSort where we sort the array in increasing (or more precisely,
5 | * non-decreasing) order. We will follow lecture implementation here, which differs slightly from the usual
6 | * implementation of Hoare's. See more under notes in README.
7 | *
8 | * Implementation Invariant:
9 | * The pivot is in the correct position, with elements to its left being <= it, and elements to its right being > it.
10 | * (We edited the pseudocode a bit to keep the duplicates to the left of the pivot.)
11 | *
12 | * This implementation picks the first element as the pivot.
13 | */
14 |
15 | public class QuickSort {
16 | /**
17 | * Sorts the given array in-place in non-decreasing order.
18 | *
19 | * @param arr array to be sorted.
20 | */
21 | public static void sort(int[] arr) {
22 | int n = arr.length;
23 | quickSort(arr, 0, n - 1);
24 | }
25 |
26 | /**
27 | * Recursively sorts the sub-array from index 'start' to index 'end' in non-decreasing order
28 | * using the QuickSort algorithm.
29 | *
30 | * @param arr the array containing the sub-array to be sorted.
31 | * @param start the starting index (inclusive) of the sub-array to be sorted.
32 | * @param end the ending index (inclusive) of the sub-array to be sorted.
33 | */
34 | private static void quickSort(int[] arr, int start, int end) {
35 | if (start < end) {
36 | int pIdx = partition(arr, start, end);
37 | quickSort(arr, start, pIdx - 1);
38 | quickSort(arr, pIdx + 1, end);
39 | }
40 | }
41 |
42 | /**
43 | * Partitions the sub-array from index 'start' to index 'end' around a randomly selected pivot element.
44 | * The elements less than or equal to the pivot are placed on the left side, and the elements greater than
45 | * the pivot are placed on the right side.
46 | *
47 | * Given a sub-array of length m, the time complexity of the partition subroutine is O(m) as we need to iterate
48 | * through every element in the sub-array once.
49 | *
50 | * @param arr the array containing the sub-array to be partitioned.
51 | * @param start the starting index (inclusive) of the sub-array to be partitioned.
52 | * @param end the ending index (inclusive) of the sub-array to be partitioned.
53 | * @return the index of the pivot element in its correct position after partitioning.
54 | */
55 | private static int partition(int[] arr, int start, int end) {
56 | int pivot = arr[start];
57 | int low = start;
58 | int high = end + 1;
59 |
60 | while (low < high) {
61 | do {
62 | low++;
63 | } while (low < high && arr[low] <= pivot); // we use <= as opposed to < to pack duplicates to the left side
64 | // of the pivot
65 | do {
66 | high--;
67 | } while (low < high && arr[high] > pivot);
68 |
69 | if (low < high) {
70 | swap(arr, low, high);
71 | }
72 | }
73 | swap(arr, start, low - 1);
74 |
75 | return low - 1;
76 | }
77 |
78 | /**
79 | * Swaps the elements at indices 'i' and 'j' in the given array.
80 | *
81 | * @param arr the array in which the elements should be swapped.
82 | * @param i the index of the first element to be swapped.
83 | * @param j the index of the second element to be swapped.
84 | */
85 | private static void swap(int[] arr, int i, int j) {
86 | int temp = arr[i];
87 | arr[i] = arr[j];
88 | arr[j] = temp;
89 | }
90 |
91 | }
92 |
--------------------------------------------------------------------------------
/src/main/java/algorithms/sorting/quickSort/lomuto/QuickSort.java:
--------------------------------------------------------------------------------
1 | package algorithms.sorting.quickSort.lomuto;
2 |
3 | /**
4 | * Here, we are implementing Lomuto's QuickSort where we sort the array in increasing (or more precisely,
5 | * non-decreasing) order.
6 | */
7 |
8 | public class QuickSort {
9 | /**
10 | * Sorts the given array in-place in non-decreasing order.
11 | *
12 | * @param arr array to be sorted.
13 | */
14 | public static void sort(int[] arr) {
15 | int n = arr.length;
16 | quickSort(arr, 0, n - 1);
17 | }
18 |
19 | /**
20 | * Recursively sorts the sub-array from index 'start' to index 'end' in non-decreasing order
21 | * using the QuickSort algorithm.
22 | *
23 | * @param arr the array containing the sub-array to be sorted.
24 | * @param start the starting index (inclusive) of the sub-array to be sorted.
25 | * @param end the ending index (inclusive) of the sub-array to be sorted.
26 | */
27 | private static void quickSort(int[] arr, int start, int end) {
28 | if (start < end) {
29 | int pIdx = partition(arr, start, end);
30 | quickSort(arr, start, pIdx - 1);
31 | quickSort(arr, pIdx + 1, end);
32 | }
33 | }
34 |
35 | /**
36 | * Partitions the sub-array from index 'start' to index 'end' around a randomly selected pivot element.
37 | * The elements less than or equal to the pivot are placed on the left side, and the elements greater than
38 | * the pivot are placed on the right side.
39 | *
40 | * Given a sub-array of length m, the time complexity of the partition subroutine is O(m) as we need to iterate
41 | * through every element in the sub-array once.
42 | *
43 | * @param arr the array containing the sub-array to be partitioned.
44 | * @param start the starting index (inclusive) of the sub-array to be partitioned.
45 | * @param end the ending index (inclusive) of the sub-array to be partitioned.
46 | * @return the index of the pivot element in its correct position after partitioning.
47 | */
48 | private static int partition(int[] arr, int start, int end) {
49 | int pIdx = random(start, end);
50 | int pivot = arr[pIdx];
51 |
52 | swap(arr, start, pIdx); // swap the pivot to the start of the array
53 |
54 | int idx = start + 1; // interpret: at the end, all elements at indices less than this var is <= pivot
55 |
56 | for (int i = start + 1; i <= end; i++) {
57 | if (arr[i] <= pivot) {
58 | swap(arr, idx, i);
59 | idx++;
60 | }
61 | }
62 |
63 | swap(arr, idx - 1, start); // swap the pivot to its correct position
64 |
65 | return idx - 1;
66 | }
67 |
68 | /**
69 | * Swaps the elements at indices 'i' and 'j' in the given array.
70 | *
71 | * @param arr the array in which the elements should be swapped.
72 | * @param i the index of the first element to be swapped.
73 | * @param j the index of the second element to be swapped.
74 | */
75 | private static void swap(int[] arr, int i, int j) {
76 | int temp = arr[i];
77 | arr[i] = arr[j];
78 | arr[j] = temp;
79 | }
80 |
81 | /**
82 | * Generates a random integer within the range [start, end].
83 | *
84 | * @param start the lower bound of the random integer (inclusive).
85 | * @param end the upper bound of the random integer (inclusive).
86 | * @return a random integer within the specified range.
87 | */
88 | private static int random(int start, int end) {
89 | return (int) (Math.random() * (end - start + 1)) + start;
90 | }
91 |
92 | }
93 |
--------------------------------------------------------------------------------
/src/main/java/algorithms/sorting/quickSort/lomuto/README.md:
--------------------------------------------------------------------------------
1 | # Lomuto's QuickSort
2 |
3 | ## Background
4 | QuickSort is a divide-and-conquer sorting algorithm. The basic idea behind Quicksort is to choose a pivot element,
5 | places it in its correct position in the sorted array, and then recursively sorts the sub-arrays on either side of
6 | the pivot. When we introduce randomization in pivot selection, every element has equal probability of being
7 | selected as the pivot. This means the chance of an extreme element getting chosen as the pivot is decreased, so we
8 | reduce the probability of encountering the worst-case scenario of imbalanced partitioning.
9 |
10 | This is how QuickSort works if we always pick the first element as the pivot with Lomuto's partitioning.
11 |
12 | 
13 |
14 | Image Source: https://www.geeksforgeeks.org/implement-quicksort-with-first-element-as-pivot/
15 |
16 | If we use randomised pivot selection, the idea is very similar to the above implementation. All we
17 | need to do is to swap the random pivot to the first element in the array, then partition as per usual,
18 | then swap the pivot back to its correct position. Below is an illustration:
19 |
20 | 
21 |
22 | ## Implementation Invariant
23 | The pivot is in the correct position, with elements to its left being <= it, and elements to its right being > it.
24 |
25 | ## Complexity Analysis:
26 | * The complexity analysis for Lomuto's quicksort is the same as that of Hoare's quicksort.
27 | Time:
28 | - Expected worst case (poor choice of pivot): O(n^2)
29 | - Expected average case: O(nlogn)
30 | - Expected best case (balanced pivot): O(nlogn)
31 |
32 | In the best case of a balanced pivot, the partitioning process divides the array in half, which leads to log n
33 | levels of recursion. Given a sub-array of length m, the time complexity of the partition subroutine is O(m) as we
34 | need to iterate through every element in the sub-array once.
35 | Therefore, the recurrence relation is: T(n) = 2T(n/2) + O(n) => O(nlogn).
36 |
37 | Even in the average case where the chosen pivot partitions the array by a fraction, there will still be log n levels
38 | of recursion. (e.g. T(n) = T(n/10) + T(9n/10) + O(n) => O(nlogn))
39 |
40 | However, if there are many duplicates in the array, e.g. {1, 1, 1, 1}, the 1st pivot will be placed in the 3rd idx,
41 | and 2nd pivot in 2nd idx, 3rd pivot in the 1st idx and 4th pivot in the 0th idx. As we observe, the presence of many
42 | duplicates in the array leads to extremely unbalanced partitioning, leading to a O(n^2) time complexity.
43 |
44 | Space:
45 | - O(1) excluding memory allocated to the call stack, since partitioning is done in-place
46 |
47 | ## Notes
48 | ### Lomuto's vs Hoare's QuickSort
49 |
50 | Lomuto's partition scheme is in contrast to Hoare's partition scheme. Hoare's uses two pointers, while Lomuto's uses
51 | one. Hoare's partition scheme is generally more efficient as it requires less swaps. See more at
52 | https://www.geeksforgeeks.org/hoares-vs-lomuto-partition-scheme-quicksort/.
--------------------------------------------------------------------------------
/src/main/java/algorithms/sorting/quickSort/paranoid/README.md:
--------------------------------------------------------------------------------
1 | # Paranoid QuickSort
2 |
3 | ## Background
4 | Paranoid Quicksort is the naive quicksort with that allow additional attempts to guarantee a good pivot selection.
5 |
6 | 
7 |
8 | ## Complexity Analysis:
9 | Time: (this analysis assumes the absence of many duplicates in our array)
10 | - Expected worst case: O(nlogn)
11 | - Expected average case: O(nlogn)
12 | - Expected best case: O(nlogn)
13 |
14 | The additional check to guarantee a good pivot guards against the worst case scenario where the chosen pivot results
15 | in an extremely imbalanced partitioning. Since the chosen pivot has to at least partition the array into a
16 | 1/10, 9/10 split, the recurrence relation will be: T(n) = T(n/10) + T(9n/10) + n(# iterations of pivot selection).
17 |
18 | The number of iterations of pivot selection is expected to be <2 (more precisely, 1.25). This is because
19 | P(good pivot) = 8/10. Expected number of tries to get a good pivot = 1 / P(good pivot) = 10/8 = 1.25.
20 |
21 | Therefore, the expected time-complexity is: T(n) = T(n/10) + T(9n/10) + 1.25n => O(nlogn).
22 |
23 | - Edge case: does not terminate
24 | The presence of this additional check and repeating pivot selection means that if we have an array of
25 | length n >= 10 containing all/many duplicates of the same number, any pivot we pick will be a bad pivot and we will
26 | enter an infinite loop of repeating pivot selection.
27 |
28 | Space:
29 | - O(1) excluding memory allocated to the call stack, since partitioning is done in-place
--------------------------------------------------------------------------------
/src/main/java/algorithms/sorting/quickSort/threeWayPartitioning/README.md:
--------------------------------------------------------------------------------
1 | # Three-Way Partitioning
2 |
3 | ## Background
4 | Three-way partitioning is an improved partitioning scheme, used in QuickSort, to tackle the scenario where there are
5 | many duplicate elements. This partitioning scheme will resolve the infinite loop error possibly faced by
6 | Paranoid Quicksort.
7 |
8 | The idea behind three-way partitioning is to divide the array into three sections: elements less than the pivot,
9 | elements equal to the pivot, and elements greater than the pivot. By doing so, we can avoid unnecessary comparisons
10 | and swaps with duplicate elements, making the sorting process more efficient.
11 |
12 | Note that during the partitioning process, there would be a 4th region - 'In Progress' region that will hold elements
13 | that haven't yet been placed in the right section (see below).
14 |
15 | 
16 |
17 | ## Implementation Invariant:
18 | The pivot and any element numerically equal to the pivot will be in the correct positions in the array. Elements
19 | to their left are < them and elements to their right are > than them.
20 |
21 | ## Complexity Analysis:
22 | Time:
23 | - Worst case: O(nlogn)
24 | - Average case: O(nlogn)
25 | - Best case: O(nlogn)
26 |
27 | Space:
28 | - O(1) excluding memory allocated to the call stack, since partitioning is done in-place
29 |
30 |
--------------------------------------------------------------------------------
/src/main/java/algorithms/sorting/radixSort/RadixSort.java:
--------------------------------------------------------------------------------
1 | package algorithms.sorting.radixSort;
2 |
3 | /**
4 | * This class implements a Radix Sort Algorithm.
5 | */
6 | public class RadixSort {
7 |
8 | private static final int NUM_BITS = 8;
9 | private static final int NUM_SEGMENTS = 4;
10 |
11 | /**
12 | * Creates masking on the segment to obtain the value of the digit.
13 | *
14 | * @param num The number.
15 | * @param segment The segment we are interested in.
16 | * @return The value of the digit in the number at the given segment.
17 | */
18 | private static int getSegmentMasked(int num, int segment) {
19 | // bit masking here to extract each segment from the integer.
20 | int mask = (1 << NUM_BITS) - 1;
21 | return (num >> (segment * NUM_BITS)) & mask; // we do a right-shift on num to focus on the desired segment
22 | }
23 |
24 | /**
25 | * Radix sorts a given input array and updates the output array in-place.
26 | *
27 | * @param arr original input array.
28 | * @param sorted output array.
29 | */
30 | private static void radixSort(int[] arr, int[] sorted) {
31 | // Code in the loop is essentially counting sort; sort the N numbers by segments, starting from right-most
32 | for (int i = 0; i < NUM_SEGMENTS; i++) {
33 | int[] freqMap = new int[1 << NUM_BITS]; // at most this number of elements
34 |
35 | // count each element
36 | for (int num : arr) {
37 | freqMap[getSegmentMasked(num, i)]++;
38 | }
39 | // get prefix sum
40 | for (int j = 1; j < freqMap.length; j++) {
41 | freqMap[j] += freqMap[j - 1];
42 | }
43 | // place each number in its correct sorted position up until the given segment
44 | for (int k = arr.length - 1; k >= 0; k--) {
45 | int curr = arr[k];
46 | int id = getSegmentMasked(curr, i);
47 | sorted[freqMap[id] - 1] = curr;
48 | freqMap[id]--;
49 | }
50 | // We do a swap so that our results above for this segment is
51 | // saved and passed as input to the next segment.
52 | // By doing this we no longer need to create a new array
53 | // every time we shift to a new segment to sort.
54 | // We can constantly reuse the array, allowing us to only use O(n) space.
55 | int[] tmp = arr;
56 | arr = sorted;
57 | sorted = tmp;
58 | }
59 | sorted = arr;
60 | }
61 |
62 | /**
63 | * Calls radix sort inplace on a given array.
64 | *
65 | * @param arr The array to be sorted.
66 | */
67 | public static void radixSort(int[] arr) {
68 | int[] sorted = new int[arr.length];
69 | radixSort(arr, sorted);
70 | arr = sorted; // swap back lol
71 | }
72 | }
73 |
--------------------------------------------------------------------------------
/src/main/java/algorithms/sorting/selectionSort/README.md:
--------------------------------------------------------------------------------
1 | # Selection Sort
2 |
3 | ## Background
4 |
5 | Selection sort is another intuitive comparison-based sorting algorithm. It works similarly to other sorting algorithms
6 | like bubble and insertion in the sense that it maintains a sorted and unsorted region. It does so by repeatedly finding
7 | smallest (or largest) element in the unsorted region, and places the element in the correct and final position as it
8 | would be in the sorted array.
9 |
10 | 
11 |
12 | ### Implementation Invariant
13 | Let the array of length n to be sorted be A.
14 |
15 | The loop invariant is:
16 | **At the end of the kth iteration, the smallest k items are correctly sorted in the first k positions of the array**.
17 |
18 | So, at the end of the (n-1)th iteration of the loop, the smallest (n-1) items are correctly sorted in the first (n-1)
19 | positions of the array, leaving the last item correctly positioned in the last index of the array. Therefore,
20 | (n-1) iterations of the loop is sufficient.
21 |
22 | ## Complexity Analysis
23 |
24 | **Time**:
25 |
26 | - Worst case: O(n^2)
27 | - Average case: O(n^2)
28 | - Best case: O(n^2)
29 |
30 | Regardless of how sorted the input array is, selectionSort will run the minimum element finding algorithm (n-1)
31 | times. For an input array of length m, finding the minimum element necessarily takes O(m) time. Therefore, the
32 | time complexity of selectionSort is n + (n-1) + (n-2) + ... + 2 = O(n^2)
33 |
34 | **Space**: O(1) since sorting is done in-place
35 |
36 | Image Source: https://www.hackerearth.com/practice/algorithms/sorting/selection-sort/tutorial/
37 |
38 | ## Notes
39 | The number of swaps made is always O(n) (careful not to confuse this with the number of comparisons).
40 |
--------------------------------------------------------------------------------
/src/main/java/algorithms/sorting/selectionSort/SelectionSort.java:
--------------------------------------------------------------------------------
1 | package algorithms.sorting.selectionSort;
2 |
3 | /**
4 | * Here, we are implementing SelectionSort where we sort the array in increasing (or more precisely, non-decreasing)
5 | * order.
6 | */
7 |
8 | public class SelectionSort {
9 | /**
10 | * Sorts the given array in-place in non-decreasing order.
11 | *
12 | * @param arr array to be sorted.
13 | * @return the same array arr that is sorted.
14 | */
15 | public static int[] sort(int[] arr) {
16 | int n = arr.length;
17 | for (int i = 0; i < n - 1; i++) { //loop which supports the invariant
18 | int minElemIdx = minElemIdx(i, n, arr);
19 | int temp = arr[i];
20 | arr[i] = arr[minElemIdx];
21 | arr[minElemIdx] = temp;
22 | }
23 | return arr;
24 | }
25 |
26 | /**
27 | * Finds the index of the minimum element within the specified range of the array.
28 | * The range is from 'start' (inclusive) to 'end' (exclusive).
29 | *
30 | * @param start the starting index (inclusive) of the range to be considered.
31 | * @param end the ending index (exclusive) of the range to be considered.
32 | * @param arr the array to be sorted.
33 | * @return the index of the minimum element within the range.
34 | *
35 | * We can easily modify this method to find maxElemIdx instead to sort the array in non-increasing order.
36 | */
37 | private static int minElemIdx(int start, int end, int[] arr) {
38 | int min = Integer.MAX_VALUE;
39 | int idx = -1;
40 | for (int i = start; i < end; i++) {
41 | if (arr[i] < min) {
42 | min = arr[i];
43 | idx = i;
44 | }
45 | }
46 | return idx;
47 | }
48 | }
49 |
--------------------------------------------------------------------------------
/src/main/java/dataStructures/avlTree/Node.java:
--------------------------------------------------------------------------------
1 | package dataStructures.avlTree;
2 |
3 | /**
4 | * TreeNode implementation for AVL Tree.
5 | * Note: Properties should rightfully be kept private
6 | * and accessed/modified via public getters/setters.
7 | * But it was left as such to avoid clutter.
8 | *
9 | * @param generic type of objects to be stored in the tree; must be comparable
10 | */
11 | public class Node> {
12 | private T key;
13 | private Node left;
14 | private Node right;
15 | private Node parent;
16 | private int height;
17 | /*
18 | * Can insert more properties here for augmentation
19 | * e.g. If key is not unique, introduce a value property as a tie-breaker
20 | * or weight property for order statistics
21 | */
22 |
23 | public Node(T key) {
24 | this.key = key;
25 | }
26 |
27 | public boolean isLeaf() {
28 | return this.left == null && this.right == null;
29 | }
30 |
31 | public T getKey() {
32 | return key;
33 | }
34 |
35 | public void setKey(T key) {
36 | this.key = key;
37 | }
38 |
39 | public Node getLeft() {
40 | return left;
41 | }
42 |
43 | public void setLeft(Node left) {
44 | this.left = left;
45 | }
46 |
47 | public Node getRight() {
48 | return right;
49 | }
50 |
51 | public void setRight(Node right) {
52 | this.right = right;
53 | }
54 |
55 | public Node getParent() {
56 | return parent;
57 | }
58 |
59 | public void setParent(Node parent) {
60 | this.parent = parent;
61 | }
62 |
63 | public int getHeight() {
64 | return height;
65 | }
66 |
67 | public void setHeight(int height) {
68 | this.height = height;
69 | }
70 |
71 | @Override
72 | public String toString() {
73 | return key.toString();
74 | }
75 | }
76 |
--------------------------------------------------------------------------------
/src/main/java/dataStructures/binarySearchTree/Node.java:
--------------------------------------------------------------------------------
1 | package dataStructures.binarySearchTree;
2 |
3 | /**
4 | * Node implementation for Binary Search Tree.
5 | * Note: Properties should rightfully be kept private
6 | * and accessed/modified via public getters/setters.
7 | * But it was left as such to avoid clutter.
8 | *
9 | * @param generic type of objects to be stored in the tree; must be comparable
10 | */
11 | public class Node, V> {
12 | private T key;
13 | private Node left;
14 | private Node right;
15 | private Node parent;
16 | private V value;
17 |
18 | /**
19 | * Constructor for a BST node.
20 | * Can insert more properties here.
21 | * If key is not unique, introduce a value property, so when nodes are being compared, a distinction can be made.
22 | * @param key the key for the BST Node.
23 | * @param value the value encapsulated by the BST node.
24 | */
25 | public Node(T key, V value) {
26 | this.key = key;
27 | this.value = value;
28 | }
29 |
30 | /**
31 | * Determines whether the node is a leaf node.
32 | * @return true if the node is a leaf node, false if not.
33 | */
34 | public boolean isLeaf() {
35 | return this.left == null && this.right == null;
36 | }
37 |
38 | public T getKey() {
39 | return key;
40 | }
41 |
42 | public void setKey(T key) {
43 | this.key = key;
44 | }
45 |
46 | public Node getLeft() {
47 | return left;
48 | }
49 |
50 | public void setLeft(Node left) {
51 | this.left = left;
52 | }
53 |
54 | public Node getRight() {
55 | return right;
56 | }
57 |
58 | public void setRight(Node right) {
59 | this.right = right;
60 | }
61 |
62 | public Node getParent() {
63 | return parent;
64 | }
65 |
66 | public void setParent(Node parent) {
67 | this.parent = parent;
68 | }
69 |
70 | public V getValue() {
71 | return value;
72 | }
73 |
74 | public void setValue(V value) {
75 | this.value = value;
76 | }
77 |
78 | @Override
79 | public String toString() {
80 | return "Key: " + key.toString() + ", Value: " + (value == null ? "null" : value.toString());
81 | }
82 | }
83 |
--------------------------------------------------------------------------------
/src/main/java/dataStructures/binarySearchTree/README.md:
--------------------------------------------------------------------------------
1 | # Binary Search Tree
2 |
3 | ## Overview
4 |
5 | A Binary Search Tree (BST) is a tree-based data structure in which each node has at most two children, referred to as
6 | the left child and the right child. Each node in a BST contains a unique key and an associated value. The tree is
7 | structured so that, for any given node:
8 |
9 | 1. The left subtree contains nodes with keys less than the node's key.
10 | 2. The right subtree contains nodes with keys greater than the node's key.
11 |
12 | This property makes BSTs efficient for operations like searching, as the average time complexity for many operations is
13 | proportional to the tree's height.
14 |
15 | Note: in the following explanation a "smaller" node refers to a node with a smaller key and a "larger" node refers to a
16 | node with a larger key.
17 |
18 | ## Implementation
19 |
20 | ### BinarySearchTree Class
21 |
22 | The BinarySearchTree class is a generic implementation of a BST. It supports a variety of operations that allow
23 | interaction with the tree:
24 |
25 | - root(): Retrieve the root node of the tree.
26 | - insert(T key, V value): Insert a key-value pair into the tree.
27 | - delete(T key): Remove a key and its associated value from the tree.
28 | - search(T key): Find a node with a specified key.
29 | - predecessor(T key): Find the key of the predecessor of a specified key.
30 | - successor(T key): Find the key of the successor of a specified key.
31 | - searchMin(): Find the node with the minimum key in the tree.
32 | - searchMax(): Find the node with the maximum key in the tree.
33 | - getInorder(): Return an in-order traversal of the tree.
34 | - getPreorder(): Return a pre-order traversal of the tree.
35 | - getPostorder(): Return a post-order traversal of the tree.
36 | - getLevelorder(): Return a level-order traversal of the tree.
37 |
38 | We will expand on the delete implementation due to its relative complexity.
39 |
40 | #### Delete Implementation Details
41 |
42 | The delete operation is split into three different cases - when the node to be deleted has no children, one child or
43 | two children.
44 |
45 | **No children:** Simply delete the node.
46 |
47 | **One child:** Reassign the parent attribute of the child to the parent of the node to be deleted. This will not violate
48 | the binary search tree property as the right child will definitely be smaller than the parent of the deleted node.
49 |
50 | **Two children:** Replace the deleted node with its successor. This works because the binary search tree property is
51 | maintained:
52 |
53 | 1. the entire left subtree will definitely be smaller than the successor as the successor is larger than the deleted
54 | node
55 | 2. the entire right subtree will definitely be larger than the successor as the successor will be the smallest node in
56 | the right subtree
57 |
58 | ### Node
59 |
60 | The Node class represents the nodes within the BinarySearchTree. Each Node instance contains:
61 |
62 | - key: The unique key associated with the node.
63 | - value: The value associated with the key.
64 | - left: Reference to the left child.
65 | - right: Reference to the right child.
66 | - parent: Reference to the parent node.
67 |
68 | ## Complexity Analysis
69 |
70 | **Time Complexity:** For a balanced tree, most operations (insert, delete, search) can be performed in O(log n) time,
71 | except tree traversal operations which can be performed in O(n) time. However, in the worst case (an unbalanced tree),
72 | these operations may degrade to O(n).
73 |
74 | **Space Complexity:** O(n), where n is the number of elements in the tree.
75 |
--------------------------------------------------------------------------------
/src/main/java/dataStructures/disjointSet/README.md:
--------------------------------------------------------------------------------
1 | # Union Find / Disjoint Set
2 |
3 | ## Background
4 |
5 | A disjoint-set structure also known as a union-find or merge-find set, is a data structure that tracks a set of elements
6 | partitioned into a number of disjoint (non-overlapping) subsets. It is commonly used to check for connectivity
7 | (e.g. if two objects are 'grouped' together/belong to some component).
8 |
9 | In CS2040s, this is introduced in the context of checking for dynamic connectivity. For instance, Kruskal's algorithm
10 | in graph theory to find minimum spanning tree of a graph utilizes disjoint set to efficiently
11 | query if there already exists a path between 2 nodes.
12 |
13 | Generally, there are 2 main operations:
14 |
15 | 1. **Union**: Join two subsets into a single subset
16 | 2. **Find**: Determine which subset a particular element is in. In practice, this is often done to check
17 | if two elements are in the same subset or component.
18 |
19 | The Disjoint Set structure is often introduced in 3 parts, with each iteration being better than the
20 | previous either in time or space complexity (or both). More details can be found in the respective folders.
21 | Below is a brief overview:
22 |
23 | 1. **Quick Find** - Elements are assigned a component identity.
24 | Querying for connectivity and updating usually tracked with an internal array.
25 |
26 | 2. **Quick Union** - Component an element belongs to is now tracked with a tree structure. Nothing to enforce
27 | a balanced tree and hence complexity does not necessarily improve
28 | - Note, this is not implemented but details can be found under weighted union folder.
29 |
30 | 3. **Weighted Union** - Same idea of using a tree, but constructed in a way that the tree is balanced, leading to
31 | improved complexities.
32 | - Can be further augmented with path compression.
33 |
34 | ## Applications
35 | Because of its efficiency and simplicity in implementing, Disjoint Set structures are widely used in practice:
36 | 1. As mentioned, it is often used as a helper structure for Kruskal's MST algorithm
37 | 2. It can be used in the context of network connectivity
38 | - Managing a network of computers
39 | - Or even analyse social networks, finding communities and determining if two users are connected through a chain
40 | 3. Can be part of clustering algorithms to group data points based on similarity - useful for ML
41 | 4. It can be used to detect cycles in dependency graphs, e.g, software dependency management systems
42 | 1. Static analysis tools like `mypy` use this to identify circular dependencies!
43 | 5. It can be used for image processing, in labelling different connected components of an image
44 |
45 | ## Notes
46 | Disjoint Set is a data structure designed to keep track of a set of elements partitioned into a number of
47 | non-overlapping subsets. **It is not suited for handling duplicates**, so our implementation ignores duplicates.
48 |
--------------------------------------------------------------------------------
/src/main/java/dataStructures/disjointSet/quickFind/DisjointSet.java:
--------------------------------------------------------------------------------
1 | package dataStructures.disjointSet.quickFind;
2 |
3 | import java.util.ArrayList;
4 | import java.util.HashMap;
5 | import java.util.List;
6 | import java.util.Map;
7 |
8 | /**
9 | * Implementation of quick-find structure; Turns a list of objects into a data structure that supports union operations
10 | * Note DS structure is not suited with duplicate elements!
11 | *
12 | * @param generic type of object to be stored
13 | */
14 | public class DisjointSet {
15 | private final Map identifier;
16 |
17 | /**
18 | * Basic constructor to create the Disjoint Set data structure.
19 | */
20 | public DisjointSet() {
21 | identifier = new HashMap<>();
22 | }
23 |
24 | /**
25 | * Constructor to initialize Disjoint Set with a known list of objects.
26 | * @param objects
27 | */
28 | public DisjointSet(List objects) {
29 | identifier = new HashMap<>();
30 | int size = objects.size();
31 | for (int i = 0; i < size; i++) {
32 | // internally, component identity is tracked with integers
33 | identifier.put(objects.get(i), identifier.size()); // each obj initialize with a unique identity using size;
34 | }
35 | }
36 |
37 | /**
38 | * Constructor to initialize Disjoint Set with a known array of objects.
39 | * @param objects
40 | */
41 | public DisjointSet(T[] objects) {
42 | identifier = new HashMap<>();
43 | int size = objects.length;
44 | for (int i = 0; i < size; i++) {
45 | // internally, component identity is tracked with integers
46 | identifier.put(objects[i], identifier.size()); // each obj initialize with a unique identity using size;
47 | }
48 | }
49 |
50 | public int size() {
51 | return identifier.size();
52 | }
53 |
54 | /**
55 | * Adds an object into the structure.
56 | * @param obj
57 | */
58 | public void add(T obj) {
59 | identifier.put(obj, identifier.size());
60 | }
61 |
62 | /**
63 | * Checks if object a and object b are in the same component.
64 | * @param a
65 | * @param b
66 | * @return a boolean value
67 | */
68 | public boolean find(T a, T b) {
69 | if (!identifier.containsKey(a) || !identifier.containsKey(b)) { // key(s) does not even exist
70 | return false;
71 | }
72 | return identifier.get(a).equals(identifier.get(b));
73 | }
74 |
75 | /**
76 | * Merge the components of object a and object b.
77 | * @param a
78 | * @param b
79 | */
80 | public void union(T a, T b) {
81 | if (!identifier.containsKey(a) || !identifier.containsKey(b)) { // key(s) does not even exist; do nothing
82 | return;
83 | }
84 |
85 | if (identifier.get(a).equals(identifier.get(b))) { // already same; do nothing
86 | return;
87 | }
88 |
89 | int compOfA = identifier.get(a);
90 | int compOfB = identifier.get(b);
91 | for (T obj : identifier.keySet()) {
92 | if (identifier.get(obj).equals(compOfA)) {
93 | identifier.put(obj, compOfB);
94 | }
95 | }
96 | }
97 |
98 | /**
99 | * Retrieves all elements that are in the same component as the specified object. Not a typical operation
100 | * but here to illustrate other use case.
101 | * @param a
102 | * @return a list of objects
103 | */
104 | public List retrieveFromSameComponent(T a) {
105 | List ret = new ArrayList<>();
106 | for (T obj : identifier.keySet()) {
107 | if (find(a, obj)) {
108 | ret.add(obj);
109 | }
110 | }
111 | return ret;
112 | }
113 | }
114 |
--------------------------------------------------------------------------------
/src/main/java/dataStructures/disjointSet/quickFind/README.md:
--------------------------------------------------------------------------------
1 | # Quick Find
2 |
3 | ## Background
4 | Every object will be assigned a component identity. The implementation of Quick Find often involves
5 | an underlying array or hash map that tracks the component identity of each object.
6 | Our implementation uses a hash map (to easily handle the case when objects aren't integers).
7 |
8 |
9 |
10 |
11 | Credits: CS2040s Lecture Slides
12 |