Algo tutoria

Author: Koubae

Algorithms/Guides/00_algorithms_part_1/01_quick_find.java

@@ -0,0 +1,35 @@
+/*
+Quick Find: 
+    * Initialize O(N) - Linear
+    * Union O(N)      - Linear
+    * Find O(1)       - Constant
+
+Cons:
+    * Union too expensive (N array accesses)
+    * Trees are flat, but too expensive to keep them flat
+
+*/
+
+
+public class QuickFindUF {
+    private int[] id;
+
+    public QuickFindUF(int N) {  // O(N)
+        id = new int[n];
+        for (int i = 0; i < N; i++) 
+            id[i] = i;
+    }
+
+    public boolean connected(int p, int q) { // O(1)
+        return id[p] == id[q];
+    }
+
+    public void union(int p, int q) { // O(N)
+        int pid = id[p];
+        int qid = id[q];
+
+        for (int i = 0; i < id.length; i ++)
+            if (id[i] == pid) id[i] = qid;
+    }
+
+}

Algorithms/Guides/00_algorithms_part_1/02_quick_union.java

@@ -0,0 +1,116 @@
+/*
+Quick Find: 
+    * Initialize O(N) - Linear
+    * Union O(N)      - Linear
+    * Find O(N)       - Linear
+
+Cons:
+    * Trees can get too tal
+    * Find too expensive (could be N array acceses)
+*/
+public class QuickUnionUF {
+    private int[] id;
+
+    QuickUnionUF(int N) { // O(N)
+        id = new int[N];
+        for (int i = 0; i < N; i++) 
+            id[i] = i;
+    }
+
+    private int root(int i) { // O(N)
+        while (i != id[i])
+            i = id[i];
+        return i;
+    }
+
+    public boolean connected(int p, int q) { // O(N)
+        return root(p) == root(q);
+    }
+
+    public void union(int p, int q) { // O(N)
+        int i = root(p);
+        int j = root(q);
+        id[i] = j;
+    }
+
+}
+
+public class QuickUnionWeightedUF {
+    private int[] id;
+    private int[] size;
+
+    QuickUnionWeightedUF(int N) { // O(N) - Linear
+        id = new int[N];
+        size = new size[N]; 
+        for (int i = 0; i < N; i++) 
+            id[i] = i;
+    }
+
+    private int root(int i) { // O(N) - Linear
+        while (i != id[i])
+            i = id[i];
+        return i;
+    }
+
+    public boolean connected(int p, int q) { // O(log N) - Logarithm
+        return root(p) == root(q);
+    }
+
+    public void union(int p, int q) { // O(log N) - Logarithm
+        int i = root(p);
+        int j = root(q);
+
+        if (i == j) return;
+
+        if (size[i] < size[j]) {
+            id[i] = j;
+            size[j] += size[i];
+        } else {
+            id[j] = i;
+            size[i] += size[j];
+        }
+
+    }
+
+}
+
+
+public class QuickUnionWeightedPathComporessionUF {
+    private int[] id;
+    private int[] size;
+
+    QuickUnionWeightedUF(int N) { // O(N) - Linear
+        id = new int[N];
+        size = new size[N]; 
+        for (int i = 0; i < N; i++) 
+            id[i] = i;
+    }
+
+    private int root(int i) { // O(N) - Linear
+        while (i != id[i])
+            id[i] = id[id[i]]; // path compression
+            i = id[i];
+        return i;
+    }
+
+    public boolean connected(int p, int q) { // O(log N) - Logarithm
+        return root(p) == root(q);
+    }
+
+    public void union(int p, int q) { // O(log N) - Logarithm
+        int i = root(p);
+        int j = root(q);
+
+        if (i == j) return;
+
+        if (size[i] < size[j]) {
+            id[i] = j;
+            size[j] += size[i];
+        } else {
+            id[j] = i;
+            size[i] += size[j];
+        }
+
+    }
+
+}

Algorithms/Guides/00_algorithms_part_1/README.MD

@@ -0,0 +1,21 @@
+* [Algorithms part 1 complete](https://www.youtube.com/watch?v=9diDWV-fOnE&t=1374s)
+
+
+Quick Union Improvement
+-----------------------
+
+### 1 Weighting 
+
+#### Weighted quick-union
+
+Basically, when you union you connect the smaller --> bigger tree.
+
+
+![alt text](image.png)
+
+
+### 2 Path Compression
+
+Basically, it will 'level up' or 'flatten' the tree while scanning the tree!
+
+![alt text](image-1.png)

Algorithms/Guides/00_algorithms_part_1/image-1.png

@@ -25,6 +25,7 @@ Video Tutorials
 * [Professor Gerry Jenkins](https://www.youtube.com/c/GerryJenkins/playlists)
 * [Dynamic Programming - Learn to Solve Algorithmic Problems & Coding Challenges](https://www.youtube.com/watch?v=oBt53YbR9Kk)
 * [CS50 | Data structure Playlists](https://www.youtube.com/c/cs50/search?query=structure)
+* [Algorithms part 1 complete](https://www.youtube.com/watch?v=9diDWV-fOnE&t=1374s)
 
 
 ### Udemy