Add README

Author: junnengsoo

src/main/java/algorithms/minimumSpanningTree/README.md

@@ -0,0 +1,45 @@
+# Minimum Spanning Tree Algorithms
+
+## Background
+
+Minimum Spanning Tree (MST) algorithms are used to find the minimum spanning tree of a weighted, connected graph. A
+spanning tree of a graph is a connected, acyclic subgraph that includes all the vertices of the original graph. An MST 
+is a spanning tree with the minimum possible total edge weight.
+
+## Prim's Algorithm and Kruskal's Algorithm
+
+We will discuss more implementation-specific details and complexity analysis in the respective folders. In short,
+1. [Prim's Algorithm](prim) is a greedy algorithm that finds the minimum spanning tree of a graph by starting from an
+arbitrary node (vertex) and adding the edge with the minimum weight that connects the current tree to a new node, adding
+the node to the current tree, until all nodes are included in the tree.
+<<<<<<< HEAD
+2. [Kruskal's Algorithm](kruskal) is a greedy algorithm that finds the minimum spanning tree of a graph by sorting the
+edges by weight and adding the edge with the minimum weight that does not form a cycle into the current tree.
+
+## Notes
+
+### Difference in use of Priority Queue in Prim's and Kruskal's Algorithm
+Prim's Algorithm uses a priority queue to keep track of the minimum weight edge that connects the current tree to an
+unexplored node, which could possibly be updated each time a node is popped from the queue.
+
+Kruskal's Algorithm uses a priority queue to sort all the edges by weight and the elements will not be updated at any
+point in time.
+
+See the individual READMEs for more details.
+
+### Difference between Minimum Spanning Tree and Shortest Path
+It is important to note that a Minimum Spanning Tree of a graph does not represent the shortest path between all the
+nodes. See below for an example:
+
+The below graph is a weighted, connected graph with 5 nodes and 6 edges:
+![original graph img](../../../../../docs/assets/images/originalGraph.jpg)
+
+The following is the Minimum Spanning Tree of the above graph:
+![MST img](../../../../../docs/assets/images/MST.jpg)
+
+Taking node A and D into consideration, the shortest path between them is A -> D, with a total weight of 4.
+![SPOriginal img](../../../../../docs/assets/images/SPOriginal.jpg)
+
+However, the shortest path between A and D in the Minimum Spanning Tree is A -> C -> D, with a total weight of 5, which
+is not the shortest path in the original graph.
+![SPMST img](../../../../../docs/assets/images/SPMST.jpg)

src/main/java/algorithms/minimumSpanningTree/kruskal/README.md

@@ -0,0 +1,26 @@
+# Kruskal's Algorithm
+
+## Background
+Kruskal's Algorithm is a greedy algorithm used to find the minimum spanning tree (MST) of a connected, weighted graph.
+It works by sorting all the edges in the graph by their weight in non-decreasing order and then adding the smallest edge
+to the MST, provided it does not form a cycle with the already included edges. This is repeated until all vertices are
+included in the MST.
+
+## Implementation Details
+Similar to Prim's Algorithm, Kruskal's Algorithm uses a priority queue (binary heap). However, instead of comparing
+the minimum edge weight to each vertex, all the weights of the individual edges are compared instead. Note that we do
+not need any decrease key operations as all edges are considered independently and will not be updated at any point in
+time.
+
+A [disjoint set](/dataStructures/disjointSet/weightedUnion) data structure is used to keep track of the connectivity of
+vertices and detect cycles.
+
+## Complexity Analysis
+
+**Time Complexity:**
+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.
+Union-Find operations: O(E α(V)), where α is the inverse Ackermann function.
+Overall complexity: O(E log V)
+
+**Space Complexity:**
+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

@@ -0,0 +1,46 @@
+# Prim's Algorithm
+
+## Background
+
+Prim's Algorithm is a greedy algorithm that finds the minimum spanning tree of a graph by starting from an
+arbitrary node (vertex) and adding the edge, with the minimum weight that connects the current tree to an unexplored
+node, and the unexplored node to the current tree, until all nodes are included in the tree.
+
+### Implementation Details
+
+A priority queue (binary heap) is utilised to keep track of the minimum weight edge that connects the current tree to an
+unexplored node. In an ideal scenario, the minimum weight edge to each node in the priority queue should be updated each
+time a lighter edge is found to maintain a single unique node in the priority queue. This means that a decrease key
+operation is required. However, we know that the decrease key operation of a binary heap implementation of a priority
+queue will take O(V) time, which will result in a larger time complexity for the entire algorithm compared to using only
+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
+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,
+while leaving the old node in the queue. Additionally, we will track if a node has already been added into the MST to
+avoid adding duplicate nodes.
+
+Note that a priority queue is an abstract data type that can be implemented using different data structures. In this
+implementation, the default Java `PriorityQueue` is used, which is a binary heap. By implementing the priority queue
+with an AVL tree, a decrease key operation that has a time complexity of O(log V) can also be achieved.
+
+## Complexity Analysis
+
+**Time Complexity:**
+- O(V^2 log V) for the basic version with an adjacency matrix, where V is the number of vertices.
+- O(E log V) with a binary heap and adjacency list, where V and E is the number of vertices and edges
+respectively.
+
+**Space Complexity:**
+- O(V^2) for the adjacency matrix representation.
+- O(V + E) for the adjacency list representation.
+
+## Notes
+
+### Difference between Prim's Algorithm and Dijkstra's Algorithm
+
+|                                     | Prim's Algorithm                                                                | Dijkstra's Algorithm                                     |
+|-------------------------------------|---------------------------------------------------------------------------------|----------------------------------------------------------|
+| 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 |
+| Property Compared in Priority Queue | Minimum weight of incoming edge to a vertex                                     | Minimum distance from source vertex to current vertex    |
+