https://danielmititelu.github.io/algorithms/Recent content in Algorithms on HomeHugo -- gohugo.ioen-usMon, 10 Oct 2022 19:40:42 +0300https://danielmititelu.github.io/algorithms/dijkstra-algorithm/Mon, 10 Oct 2022 19:40:42 +0300https://danielmititelu.github.io/algorithms/dijkstra-algorithm/Greedy algorithm used to find the shortest path in a weighted graph. Undirected Single source shortest paths with positive integer weights in linear time Time complexity: O(V + Elog(E)) Space complexity: O(V + E) Restrictions: only for non-decreasing weights (all weights >= 0) private Dictionary<int, int> Dijkstra( Dictionary<int, List<(int dest, int dist)>> graph, int source /*, int target*/) { var minHeap = new PriorityQueue<(int node, int dist), int>(); var distances = new Dictionary<int, int>(); var visited = new HashSet<int>(); // initialize every node with infinity foreach (var node in graph.https://danielmititelu.github.io/algorithms/binary-tree-traversals/Mon, 01 Jan 0001 00:00:00 +0000https://danielmititelu.github.io/algorithms/binary-tree-traversals/Preorder traversal Order of visiting: parent -> left child -> right child Recursive implementation: public IList<int> PreorderTraversal(TreeNode root) { var result = new List<int>(); Preorder(root, result); return result; } public void Preorder(TreeNode node, IList<int> result) { if(node == null) return; result.Add(node.val); Preorder(node.left, result); Preorder(node.right, result); } Iterative implementation: public IList<int> PreorderTraversal(TreeNode root) { var res = new List<int>(); if (root == null) return res; var stack = new Stack<TreeNode>(); stack.Push(root); while (stack.https://danielmititelu.github.io/algorithms/voting-algo/Mon, 01 Jan 0001 00:00:00 +0000https://danielmititelu.github.io/algorithms/voting-algo/Time complexity : O(n) Space complexity : O(1) The algorithm counts the majority of votes(elements) in an array by finding a part of the array (suffix) where the first element in array suffix is the majority. It does this by diregarding any prefix where the majority is equal to the minority of votes. public int MajorityElement(int[] nums) { int count = 0; int candidate = 0; foreach (int num in nums) { if (count == 0) { candidate = num; } count += (num == candidate) ?https://danielmititelu.github.io/algorithms/cycle-detection/Mon, 01 Jan 0001 00:00:00 +0000https://danielmititelu.github.io/algorithms/cycle-detection/public enum Colors { White, Gray, Black } public bool HasCycle(int[][] graph, int start, Colors[] colors) { if(colors[start] == Colors.Gray) return true; if(colors[start] == Colors.Black) return false; colors[start] = Colors.Gray; foreach(var neighbor in graph[start]) { if(HasCycle(graph, neighbor, colors)) return true; } colors[start] = Colors.Black; return false; } Problems https://leetcode.com/problems/find-eventual-safe-stateshttps://danielmititelu.github.io/algorithms/graph-traversals/Mon, 01 Jan 0001 00:00:00 +0000https://danielmititelu.github.io/algorithms/graph-traversals/Breadth-first search We scan through the graph level by level starting with the nodes closest to the starting node. Examples: BFS can only be implemented in iterative manner: public void BFS(Node node) { var queue = new Queue<Node>(); queue.Enqueue(node); while(queue.Count > 0) { const current = queue.Dequeue(); // visit node node.Visited = true; foreach(var child of node.Children) if(!child.Visited) stack.Enqueue(child); } } Depth-first search DFS for short is going to search a graph or matrix by depth first meaning it will pick a direction and go in that direction before coming back to visit other directionshttps://danielmititelu.github.io/algorithms/kruskal-algorithm/Mon, 01 Jan 0001 00:00:00 +0000https://danielmititelu.github.io/algorithms/kruskal-algorithm/Greedy alghorithm used to find the minimum spanning tree of a given graph Time complexity: O(Elog(E)) Space complexity: O(E + V) Minimum spanning tree A Minimum spanning tree(MST for short) is a subgraph of a cyclic, undirected graph that will connected all the vertices and contain no cycles. Number of edges of the MST is equal to V - 1 where V is the number of vertices of the bigger graphhttps://danielmititelu.github.io/algorithms/multi-source-bfs/Mon, 01 Jan 0001 00:00:00 +0000https://danielmititelu.github.io/algorithms/multi-source-bfs/Leetcode problems https://leetcode.com/problems/01-matrix/ https://leetcode.com/problems/rotting-oranges/https://danielmititelu.github.io/algorithms/quick-select/Mon, 01 Jan 0001 00:00:00 +0000https://danielmititelu.github.io/algorithms/quick-select/Quick select or Hoare’s selection algorithm Time complexity: - average case O(N) - worst case O(N^2) Algoritm steps: figure out k-th index(smallest: k, biggest: n - k) add 2 pointers (left and right) for the start and end of the array, similar to binary search while left is smaller than right pick a random index as pivot and partition: save the pivot in the right pointer starting from left with 2 pointers: storeIndex and i: move i forword untill it reaches the right pointer, every time i finds a value smaller than the pivot, swap it with storeIndex and increment storeIndex at the end swap storeIndex with the pivot stored in right pointer return storeIndex, this is our pivot in it’s final ordered position similar to binary search compare pivot index with the k-th index: if they are equal then we found the k-th element if pivot index is bigger, seach in the left part of the pivot where there are smaller values if pivot index is smaller, search in the right part int FindKthLargest(int[] nums, int k) { var kthIndex = nums.https://danielmititelu.github.io/algorithms/three-way-partitioning/Mon, 01 Jan 0001 00:00:00 +0000https://danielmititelu.github.io/algorithms/three-way-partitioning/A partition strategy that is sometime used in quicksort. Code example Dutch national flag problem // Dutch national flag problem (partition array into 3 parts: red, white, blue) // 0 -> red, 1 -> white, 2 -> blue void SortColors(int[] nums) { int red = 0, white = 0, blue = nums.Length - 1; // Traverse the array until we hit the blue part while(white <= blue) { // if the white iterator hit a red color // swap it with the red iterator and increment it // and the white iterator if(nums[white] == 0) { Swap(nums, red, white); red++; white++; } // if the white iterator hit a blue color // swap it with the blue iterator and // decrement the blue iterator else if(nums[white] == 2) { Swap(nums, white, blue); blue--; } // if white iterator hit a white color // it's already in the right place // so just increase the white iterator else { white++; } } } void Swap(int[] nums, int left, int i) { int temp = nums[left]; nums[left] = nums[i]; nums[i] = temp; } Partition around a range // Function to partition the array around the range such // that array is divided into three parts.https://danielmititelu.github.io/algorithms/topological-sort/Mon, 01 Jan 0001 00:00:00 +0000https://danielmititelu.github.io/algorithms/topological-sort/Time Complexity: O(V+E) // V = vertex (or node), E = edge Sort a graph so that any node on the left will point only to the nodes in the right cannot be done for graphs that have a cycle should be a DAG(directed acyclic graph) Khan’s algorithm private List<int> TopologicalSort(Dictionary<int, List<int>> graph) { var indegrees = CountIndegrees(graph); var queue = new Queue<int>(); foreach(var (course, count) in indegrees) { if(count == 0) { queue.