pull from upstream repo

Author: kanthuc

DIRECTORY.md

@@ -267,6 +267,7 @@
   * [Karger](https://github.com/TheAlgorithms/Python/blob/master/graphs/karger.py)
   * [Minimum Spanning Tree Boruvka](https://github.com/TheAlgorithms/Python/blob/master/graphs/minimum_spanning_tree_boruvka.py)
   * [Minimum Spanning Tree Kruskal](https://github.com/TheAlgorithms/Python/blob/master/graphs/minimum_spanning_tree_kruskal.py)
+  * [Minimum Spanning Tree Kruskal2](https://github.com/TheAlgorithms/Python/blob/master/graphs/minimum_spanning_tree_kruskal2.py)
   * [Minimum Spanning Tree Prims](https://github.com/TheAlgorithms/Python/blob/master/graphs/minimum_spanning_tree_prims.py)
   * [Multi Heuristic Astar](https://github.com/TheAlgorithms/Python/blob/master/graphs/multi_heuristic_astar.py)
   * [Page Rank](https://github.com/TheAlgorithms/Python/blob/master/graphs/page_rank.py)

data_structures/binary_tree/basic_binary_tree.py

@@ -5,6 +5,7 @@ class Node:
     """
     A Node has data variable and pointers to Nodes to its left and right.
     """
+
     def __init__(self, data: int) -> None:
         self.data = data
         self.left: Optional[Node] = None

graphs/minimum_spanning_tree_kruskal2.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+
+class DisjointSetTreeNode:
+    # Disjoint Set Node to store the parent and rank
+    def __init__(self, key: int) -> None:
+        self.key = key
+        self.parent = self
+        self.rank = 0
+
+
+class DisjointSetTree:
+    # Disjoint Set DataStructure
+    def __init__(self):
+        # map from node name to the node object
+        self.map = {}
+
+    def make_set(self, x: int) -> None:
+        # create a new set with x as its member
+        self.map[x] = DisjointSetTreeNode(x)
+
+    def find_set(self, x: int) -> DisjointSetTreeNode:
+        # find the set x belongs to (with path-compression)
+        elem_ref = self.map[x]
+        if elem_ref != elem_ref.parent:
+            elem_ref.parent = self.find_set(elem_ref.parent.key)
+        return elem_ref.parent
+
+    def link(self, x: int, y: int) -> None:
+        # helper function for union operation
+        if x.rank > y.rank:
+            y.parent = x
+        else:
+            x.parent = y
+            if x.rank == y.rank:
+                y.rank += 1
+
+    def union(self, x: int, y: int) -> None:
+        # merge 2 disjoint sets
+        self.link(self.find_set(x), self.find_set(y))
+
+
+class GraphUndirectedWeighted:
+    def __init__(self):
+        # connections: map from the node to the neighbouring nodes (with weights)
+        self.connections = {}
+
+    def add_node(self, node: int) -> None:
+        # add a node ONLY if its not present in the graph
+        if node not in self.connections:
+            self.connections[node] = {}
+
+    def add_edge(self, node1: int, node2: int, weight: int) -> None:
+        # add an edge with the given weight
+        self.add_node(node1)
+        self.add_node(node2)
+        self.connections[node1][node2] = weight
+        self.connections[node2][node1] = weight
+
+    def kruskal(self) -> GraphUndirectedWeighted:
+        # Kruskal's Algorithm to generate a Minimum Spanning Tree (MST) of a graph
+        """
+        Details: https://en.wikipedia.org/wiki/Kruskal%27s_algorithm
+
+        Example:
+
+        >>> graph = GraphUndirectedWeighted()
+        >>> graph.add_edge(1, 2, 1)
+        >>> graph.add_edge(2, 3, 2)
+        >>> graph.add_edge(3, 4, 1)
+        >>> graph.add_edge(3, 5, 100) # Removed in MST
+        >>> graph.add_edge(4, 5, 5)
+        >>> assert 5 in graph.connections[3]
+        >>> mst = graph.kruskal()
+        >>> assert 5 not in mst.connections[3]
+        """
+
+        # getting the edges in ascending order of weights
+        edges = []
+        seen = set()
+        for start in self.connections:
+            for end in self.connections[start]:
+                if (start, end) not in seen:
+                    seen.add((end, start))
+                    edges.append((start, end, self.connections[start][end]))
+        edges.sort(key=lambda x: x[2])
+        # creating the disjoint set
+        disjoint_set = DisjointSetTree()
+        [disjoint_set.make_set(node) for node in self.connections]
+        # MST generation
+        num_edges = 0
+        index = 0
+        graph = GraphUndirectedWeighted()
+        while num_edges < len(self.connections) - 1:
+            u, v, w = edges[index]
+            index += 1
+            parentu = disjoint_set.find_set(u)
+            parentv = disjoint_set.find_set(v)
+            if parentu != parentv:
+                num_edges += 1
+                graph.add_edge(u, v, w)
+                disjoint_set.union(u, v)
+        return graph
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

maths/number_of_digits.py

@@ -10,11 +10,20 @@ def num_digits(n: int) -> int:
     5
     >>> num_digits(123)
     3
+    >>> num_digits(0)
+    1
+    >>> num_digits(-1)
+    1
+    >>> num_digits(-123456)
+    6
     """
     digits = 0
-    while n > 0:
+    n = abs(n)
+    while True:
         n = n // 10
         digits += 1
+        if n == 0:
+            break
     return digits
 
 
@@ -27,8 +36,14 @@ def num_digits_fast(n: int) -> int:
     5
     >>> num_digits_fast(123)
     3
+    >>> num_digits_fast(0)
+    1
+    >>> num_digits_fast(-1)
+    1
+    >>> num_digits_fast(-123456)
+    6
     """
-    return math.floor(math.log(abs(n), 10) + 1)
+    return 1 if n == 0 else math.floor(math.log(abs(n), 10) + 1)
 
 
 def num_digits_faster(n: int) -> int:
@@ -40,6 +55,12 @@ def num_digits_faster(n: int) -> int:
     5
     >>> num_digits_faster(123)
     3
+    >>> num_digits_faster(0)
+    1
+    >>> num_digits_faster(-1)
+    1
+    >>> num_digits_faster(-123456)
+    6
     """
     return len(str(abs(n)))
 
@@ -133,3 +154,6 @@ def benchmark() -> None:
     medium_num = 1125899906842624
     large_num = 1267650600228229401496703205376
     benchmark()
+    import doctest
+
+    doctest.testmod()