Implementation of Hopcroft–Karp algorithm.
The Hopcroft–Karp algorithm is an algorithm that takes as input a bipartite graph and produces as output a maximum cardinality matching, it runs in O(E√V) time in worst case.
-
+
Bipartite graph
A bipartite graph (or bigraph) is a graph whose vertices can be divided into two disjoint and independent sets U and V such that every edge connects a vertex in U to one in V. Vertex sets U and V are usually called the parts of the graph. Equivalently, a bipartite graph is a graph that does not contain any odd-length cycles.
-
+
Matching and Not-Matching edges
Given a matching M, edges that are part of matching are called Matching edges and edges that are not part of M (or connect free nodes) are called Not-Matching edges.
-
+
Maximum cardinality matching
Given a bipartite graphs G = ( V = ( X , Y ) , E ) whose partition has the parts X and Y, with E denoting the edges of the graph, the goal is to find a matching with as many edges as possible. Equivalently, a matching that covers as many vertices as possible.
-
+
Augmenting paths
Given a matching M, an augmenting path is an alternating path that starts from and ends on free vertices. All single edge paths that start and end with free vertices are augmenting paths.
-
+
Concept
A matching M is not maximum if there exists an augmenting path. It is also true other way, i.e, a matching is maximum if no augmenting path exists.
-
+
Algorithm
1) Initialize the Maximal Matching M as empty. 2) While there exists an Augmenting Path P Remove matching edges of P from M and add not-matching edges of P to M (This increases size of M by 1 as P starts and ends with a free vertex i.e. a node that is not part of matching.) 3) Return M.
diff --git a/d1/ded/windowed__median_8cpp.html b/d1/ded/windowed__median_8cpp.html index dc3fcacb9..38150141d 100644 --- a/d1/ded/windowed__median_8cpp.html +++ b/d1/ded/windowed__median_8cpp.html @@ -150,7 +150,7 @@ FunctionsDetailed Description
An implementation of a median calculation of a sliding window along a data stream.
Given a stream of integers, the algorithm calculates the median of a fixed size window at the back of the stream. The leading time complexity of this algorithm is O(log(N), and it is inspired by the known algorithm to [find median from (infinite) data stream](https://www.tutorialcup.com/interview/algorithm/find-median-from-data-stream.htm), with the proper modifications to account for the finite window size for which the median is requested
-
+
Algorithm
The sliding window is managed by a list, which guarantees O(1) for both pushing and popping. Each new value is pushed to the window back, while a value from the front of the window is popped. In addition, the algorithm manages a multi-value binary search tree (BST), implemented by std::multiset. For each new value that is inserted into the window, it is also inserted to the BST. When a value is popped from the window, it is also erased from the BST. Both insertion and erasion to/from the BST are O(logN) in time, with N the size of the window. Finally, the algorithm keeps a pointer to the root of the BST, and updates its position whenever values are inserted or erased to/from BST. The root of the tree is the median! Hence, median retrieval is always O(1)
Time complexity: O(logN). Space complexity: O(N). N - size of window
diff --git a/d2/d26/count__inversions_8cpp.html b/d2/d26/count__inversions_8cpp.html index a27e31079..e7f3ecfe8 100644 --- a/d2/d26/count__inversions_8cpp.html +++ b/d2/d26/count__inversions_8cpp.html @@ -151,7 +151,7 @@ Functionstwo elements a[i] and a[j] form an inversion if a[i] > a[j] and i < j
Time Complexity --> O(n.log n)
Space Complexity --> O(n) ; additional array temp[1..n]
+
Algorithm
- The idea is similar to merge sort, divide the array into two equal or almost equal halves in each step until the base case is reached.
diff --git a/d3/db3/lru__cache_8cpp.html b/d3/db3/lru__cache_8cpp.html
index 13ba019bb..2e23f5061 100644
--- a/d3/db3/lru__cache_8cpp.html
+++ b/d3/db3/lru__cache_8cpp.html
@@ -150,7 +150,7 @@ Functions
Detailed Description
An implementation of LRU Cache. Lru is a part of cache algorithms (also frequently called cache replacement algorithms or cache replacement policies).
-
+
Logic
- Discards the least recently used items first.
@@ -158,7 +158,7 @@ Logic
- General implementations of this technique require keeping "age bits" for cache-lines and track the "Least Recently Used" cache-line based on age-bits.
- In such an implementation, every time a cache-line is used, the age of all other cache-lines changes
-
+
Algorithm explanation
For a cache of page frame x:
- Check if the page is present in cache.
@@ -170,7 +170,7 @@ Algorithm explanation
Every time a requested page is not found in cache, that is a miss or page fault, and if the page is present in cache, then its a hit.
-
+
Data Structure used
- In the algorithm below we used two different data structure, one is linked list and other one is a hash map
diff --git a/d3/df9/recursive__bubble__sort_8cpp.html b/d3/df9/recursive__bubble__sort_8cpp.html
index aad58ffd2..63443ee72 100644
--- a/d3/df9/recursive__bubble__sort_8cpp.html
+++ b/d3/df9/recursive__bubble__sort_8cpp.html
@@ -135,7 +135,7 @@ Functions
The working principle of the Bubble sort algorithm.
Bubble sort is a simple sorting algorithm used to rearrange a set of ascending or descending order elements. Bubble sort gets its name from the fact that data "bubbles" to the top of the dataset.
-
+
Algorithm
What is Swap?
Swapping two numbers means that we interchange their values. Often, an additional variable is required for this operation. This is further illustrated in the following:
diff --git a/d4/d2f/fcfs__scheduling_8cpp__incl.map b/d4/d2f/fcfs__scheduling_8cpp__incl.map
new file mode 100644
index 000000000..3158f721e
--- /dev/null
+++ b/d4/d2f/fcfs__scheduling_8cpp__incl.map
@@ -0,0 +1,12 @@
+
diff --git a/d4/d2f/fcfs__scheduling_8cpp__incl.md5 b/d4/d2f/fcfs__scheduling_8cpp__incl.md5
new file mode 100644
index 000000000..6853309e3
--- /dev/null
+++ b/d4/d2f/fcfs__scheduling_8cpp__incl.md5
@@ -0,0 +1 @@
+0324174599ed13b0486f31d316384e99
\ No newline at end of file
diff --git a/d4/d2f/fcfs__scheduling_8cpp__incl.svg b/d4/d2f/fcfs__scheduling_8cpp__incl.svg
new file mode 100644
index 000000000..2f013e6d9
--- /dev/null
+++ b/d4/d2f/fcfs__scheduling_8cpp__incl.svg
@@ -0,0 +1,246 @@
+
+
+
+
+
+
diff --git a/d4/d2f/fcfs__scheduling_8cpp__incl_org.svg b/d4/d2f/fcfs__scheduling_8cpp__incl_org.svg
new file mode 100644
index 000000000..bd2095678
--- /dev/null
+++ b/d4/d2f/fcfs__scheduling_8cpp__incl_org.svg
@@ -0,0 +1,158 @@
+
+
+
+
+
diff --git a/d4/d32/inorder__successor__of__bst_8cpp.html b/d4/d32/inorder__successor__of__bst_8cpp.html
index 55ca6c210..187d5bead 100644
--- a/d4/d32/inorder__successor__of__bst_8cpp.html
+++ b/d4/d32/inorder__successor__of__bst_8cpp.html
@@ -163,21 +163,21 @@ Functions
Detailed Description
An implementation for finding the Inorder successor of a binary search tree Inorder successor of a node is the next node in Inorder traversal of the Binary Tree. Inorder Successor is NULL for the last node in Inorder traversal.
-
+
Case 1: The given node has the right node/subtree
* In this case, the left-most deepest node in the right subtree will
come just after the given node as we go to left deep in inorder.
- Go deep to left most node in right subtree. OR, we can also say in case if BST, find the minimum of the subtree for a given node.
-
+
Case 2: The given node does not have a right node/subtree
-
+
Method 1: Use parent pointer (store the address of parent nodes)
- If a node does not have the right subtree, and we already visited the node itself, then the next node will be its parent node according to inorder traversal, and if we are going to parent from left, then the parent would be unvisited.
- In other words, go to the nearest ancestor for which given node would be in left subtree.
-
+
Method 2: Search from the root node
- In case if there is no link from a child node to the parent node, we need to walk down the tree starting from the root node to the given node, by doing so, we are visiting every ancestor of the given node.
diff --git a/d4/d38/power__of__two_8cpp.html b/d4/d38/power__of__two_8cpp.html
index 2c3ca0248..7ee5b99a4 100644
--- a/d4/d38/power__of__two_8cpp.html
+++ b/d4/d38/power__of__two_8cpp.html
@@ -125,7 +125,7 @@ Functions
Detailed Description
Implementation to check whether a number is a power of 2 or not.
This algorithm uses bit manipulation to check if a number is a power of 2 or not.
-
+
Algorithm
Let the input number be n, then the bitwise and between n and n-1 will let us know whether the number is power of 2 or not
For Example, If N= 32 then N-1 is 31, if we perform bitwise and of these two numbers then the result will be zero, which indicates that it is the power of 2 If N=23 then N-1 is 22, if we perform bitwise and of these two numbers then the result will not be zero , which indicates that it is not the power of 2
- Note
- This implementation is better than naive recursive or iterative approach.
diff --git a/d4/d8d/jarvis__algorithm_8cpp.html b/d4/d8d/jarvis__algorithm_8cpp.html
index 9f186b043..2ea246476 100644
--- a/d4/d8d/jarvis__algorithm_8cpp.html
+++ b/d4/d8d/jarvis__algorithm_8cpp.html
@@ -136,7 +136,7 @@ Functions
Detailed Description
Implementation of Jarvis’s algorithm.
Given a set of points in the plane. the convex hull of the set is the smallest convex polygon that contains all the points of it.
-
+
Algorithm
The idea of Jarvis’s Algorithm is simple, we start from the leftmost point (or point with minimum x coordinate value) and we keep wrapping points in counterclockwise direction.
The idea is to use orientation() here. Next point is selected as the point that beats all other points at counterclockwise orientation, i.e., next point is q if for any other point r, we have “orientation(p, q, r) = counterclockwise”.
diff --git a/d4/d9f/selection__sort__recursive_8cpp.html b/d4/d9f/selection__sort__recursive_8cpp.html
index 69ee52e4e..1f12431b3 100644
--- a/d4/d9f/selection__sort__recursive_8cpp.html
+++ b/d4/d9f/selection__sort__recursive_8cpp.html
@@ -139,7 +139,7 @@ Functions
Detailed Description
Implementation of the Selection sort implementation using recursion.
The selection sort algorithm divides the input list into two parts: a sorted sublist of items which is built up from left to right at the front (left) of the list, and a sublist of the remaining unsorted items that occupy the rest of the list. Initially, the sorted sublist is empty, and the unsorted sublist is the entire input list. The algorithm proceeds by finding the smallest (or largest, depending on the sorting order) element in the unsorted sublist, exchanging (swapping) it with the leftmost unsorted element (putting it in sorted order), and moving the sublist boundaries one element to the right.
-
+
Implementation
FindMinIndex This function finds the minimum element of the array(list) recursively by simply comparing the minimum element of array reduced size by 1 and compares it to the last element of the array to find the minimum of the whole array.
SelectionSortRecursive Just like selection sort, it divides the list into two parts (i.e.: sorted and unsorted) and finds the minimum of the unsorted array. By calling the FindMinIndex function, it swaps the minimum element with the first element of the list, and then solves recursively for the remaining unsorted list.
diff --git a/d5/d33/gram__schmidt_8cpp.html b/d5/d33/gram__schmidt_8cpp.html
index f0a7fa6e8..c5a75e2e3 100644
--- a/d5/d33/gram__schmidt_8cpp.html
+++ b/d5/d33/gram__schmidt_8cpp.html
@@ -139,7 +139,7 @@ Functions
Detailed Description
Gram Schmidt Orthogonalisation Process
Takes the input of Linearly Independent Vectors, returns vectors orthogonal to each other.
-
+
Algorithm
Take the first vector of given LI vectors as first vector of Orthogonal vectors. Take projection of second input vector on the first vector of Orthogonal vector and subtract it from the 2nd LI vector. Take projection of third vector on the second vector of Othogonal vectors and subtract it from the 3rd LI vector. Keep repeating the above process until all the vectors in the given input array are exhausted.
For Example: In R2, Input LI Vectors={(3,1),(2,2)} then Orthogonal Vectors= {(3, 1),(-0.4, 1.2)}
diff --git a/d5/d45/sublist__search_8cpp.html b/d5/d45/sublist__search_8cpp.html
index 2d629b439..201817fd1 100644
--- a/d5/d45/sublist__search_8cpp.html
+++ b/d5/d45/sublist__search_8cpp.html
@@ -148,14 +148,14 @@ Functions
Detailed Description
Implementation of the Sublist Search Algorithm
-
+
Algorithm
- Sublist search is used to detect a presence of one list in another list.
- Suppose we have a single-node list (let's say the first list), and we want to ensure that the list is present in another list (let's say the second list), then we can perform the sublist search to find it.
- For instance, the first list contains these elements: 23 -> 30 -> 41, and the second list contains these elements: 10 -> 15 -> 23 -> 30 -> 41 -> 49. At a glance, we see that the first list presents in the second list.
-
+
Working
- The sublist search algorithm works by comparing the first element of the first list with the first element of the second list.
diff --git a/d5/d88/md__d_i_r_e_c_t_o_r_y.html b/d5/d88/md__d_i_r_e_c_t_o_r_y.html
index 514ce65b3..c5af30faa 100644
--- a/d5/d88/md__d_i_r_e_c_t_o_r_y.html
+++ b/d5/d88/md__d_i_r_e_c_t_o_r_y.html
@@ -128,6 +128,11 @@ Ciphers
- Xor Cipher
+Cpu Scheduling Algorithms
+
+
Data Structures
- Avltree
@@ -169,12 +174,12 @@ Data Structures
- Trie Tree
- Trie Using Hashmap
-
+
Divide And Conquer
-
+
Dynamic Programming
- 0 1 Knapsack
@@ -205,13 +210,13 @@ Dynamic Programming
- Tree Height
- Word Break
-
+
Geometry
-
+
Graph
- Bidirectional Dijkstra
@@ -235,12 +240,12 @@ Graph
- Topological Sort By Kahns Algo
- Travelling Salesman Problem
-
+
Graphics
-
+
Greedy Algorithms
- Dijkstra
@@ -250,7 +255,7 @@ Greedy Algorithms
- Kruskals Minimum Spanning Tree
- Prims Minimum Spanning Tree
-
+
Hashing
- Chaining
@@ -260,12 +265,12 @@ Hashing
- Quadratic Probing Hash Table
- Sha1
-
+
Linear Algebra
-
+
Machine Learning
- A Star Search
@@ -276,7 +281,7 @@ Machine Learning
- Ordinary Least Squares Regressor
- Vector Ops
-
+
Math
- Armstrong Number
@@ -330,7 +335,7 @@ Math
- Sum Of Digits
- Vector Cross Product
-
+
Numerical Methods
- Bisection Method
@@ -351,7 +356,7 @@ Numerical Methods
- Rungekutta
- Successive Approximation
-
+
Operations On Datastructures
- Array Left Rotation
@@ -366,7 +371,7 @@ Operations On Datastructures
- Trie Multiple Search
- Union Of 2 Arrays
-
+
Others
- Buzz Number
@@ -391,7 +396,7 @@ Others
- Tower Of Hanoi
- Vector Important Functions
-
+
Probability
- Addition Rule
@@ -401,7 +406,7 @@ Probability
- Poisson Dist
- Windowed Median
-
+
Range Queries
- Fenwick Tree
@@ -412,7 +417,7 @@ Range Queries
- Segtree
- Sparse Table
-
+
Search
- Binary Search
@@ -430,7 +435,7 @@ Search
- Ternary Search
- Text Search
-
+
Sorting
- Bead Sort
@@ -473,7 +478,7 @@ Sorting
- Wave Sort
- Wiggle Sort
-
+
Strings
- Brute Force String Searching
diff --git a/d5/d96/md5_8cpp.html b/d5/d96/md5_8cpp.html
index fcef37251..653b5c1fe 100644
--- a/d5/d96/md5_8cpp.html
+++ b/d5/d96/md5_8cpp.html
@@ -164,7 +164,7 @@ Functions
- Store salted password
However MD5 has be know to be cryptographically weak for quite some time, yet it is still widely used. This weakness was exploited by the Flame Malware in 2012
-
+
Algorithm
First of all, all values are expected to be in little endian. This is especially important when using part of the bytestring as an integer.
The first step of the algorithm is to pad the message for its length to be a multiple of 64 (bytes). This is done by first adding 0x80 (10000000) and then only zeroes until the last 8 bytes must be filled, where then the 64 bit size of the input will be added
diff --git a/d5/ddb/bogo__sort_8cpp.html b/d5/ddb/bogo__sort_8cpp.html
index 5fca0b893..30e0a0c78 100644
--- a/d5/ddb/bogo__sort_8cpp.html
+++ b/d5/ddb/bogo__sort_8cpp.html
@@ -135,7 +135,7 @@ Functions
Detailed Description
Implementation of Bogosort algorithm
In computer science, bogosort (also known as permutation sort, stupid sort, slowsort, shotgun sort, random sort, monkey sort, bobosort or shuffle sort) is a highly inefficient sorting algorithm based on the generate and test paradigm. Two versions of this algorithm exist: a deterministic version that enumerates all permutations until it hits a sorted one, and a randomized version that randomly permutes its input.Randomized version is implemented here.
-
+
Algorithm
Shuffle the array untill array is sorted.
diff --git a/d6/d10/cut__rod_8cpp.html b/d6/d10/cut__rod_8cpp.html
index 5da32cc73..e6dad50c4 100644
--- a/d6/d10/cut__rod_8cpp.html
+++ b/d6/d10/cut__rod_8cpp.html
@@ -135,7 +135,7 @@ Functions
Detailed Description
Implementation of cutting a rod problem.
Given a rod of length n inches and an array of prices that contains prices of all pieces of size<=n. Determine the maximum profit obtainable by cutting up the rod and selling the pieces.
-
+
Algorithm
The idea is to break the given rod into every smaller piece as possible and then check profit for each piece, by calculating maximum profit for smaller pieces we will build the solution for larger pieces in bottom-up manner.
- Capitalize zero or more of
a's lowercase letters.
- Delete all of the remaining lowercase letters in
a.
-
+
Algorithm
The idea is in the problem statement itself: iterate through characters of string a and b (for character indexes i and j respectively):
- If
a[i] and b[j] are equal, then move to next position
diff --git a/d8/d7a/sha1_8cpp.html b/d8/d7a/sha1_8cpp.html
index 011c7725c..4a75469bc 100644
--- a/d8/d7a/sha1_8cpp.html
+++ b/d8/d7a/sha1_8cpp.html
@@ -150,7 +150,7 @@ Functions
Simple C++ implementation of the SHA-1 Hashing Algorithm
SHA-1 is a cryptographic hash function that was developped by the NSA 1995. SHA-1 is not considered secure since around 2010.
-
+
Algorithm
The first step of the algorithm is to pad the message for its length to be a multiple of 64 (bytes). This is done by first adding 0x80 (10000000) and then only zeroes until the last 8 bytes must be filled, where then the 64 bit size of the input will be added
Once this is done, the algo breaks down this padded message into 64 bytes chunks. Each chunk is used for one round, a round breaks the chunk into 16 blocks of 4 bytes. These 16 blocks are then extended to 80 blocks using XOR operations on existing blocks (see code for more details). The algorithm will then update its 160-bit state (here represented used 5 32-bits integer) using partial hashes computed using special functions on the blocks previously built. Please take a look at the wikipedia article for more precision on these operations
- Note
- This is a simple implementation for a byte string but some implmenetations can work on bytestream, messages of unknown length.
diff --git a/d8/d90/iterative__tree__traversals_8cpp.html b/d8/d90/iterative__tree__traversals_8cpp.html
index 73ac4c543..3efdda89b 100644
--- a/d8/d90/iterative__tree__traversals_8cpp.html
+++ b/d8/d90/iterative__tree__traversals_8cpp.html
@@ -157,13 +157,13 @@ Functions
Detailed Description
Iterative version of Preorder, Postorder, and preorder Traversal of the Tree
-
+
Iterative Preorder Traversal of a tree
Create a Stack that will store the Node of Tree. Push the root node into the stack. Save the root into the variabe named as current, and pop and elemnt from the stack. Store the data of current into the result array, and start traversing from it. Push both the child node of the current node into the stack, first right child then left child. Repeat the same set of steps untill the Stack becomes empty. And return the result array as the preorder traversal of a tree.
-
+
Iterative Postorder Traversal of a tree
Create a Stack that will store the Node of Tree. Push the root node into the stack. Save the root into the variabe named as current, and pop and elemnt from the stack. Store the data of current into the result array, and start traversing from it. Push both the child node of the current node into the stack, first left child then right child. Repeat the same set of steps untill the Stack becomes empty. Now reverse the result array and then return it to the calling function as a postorder traversal of a tree.
-
+
Iterative Inorder Traversal of a tree
Create a Stack that will store the Node of Tree. Push the root node into the stack. Save the root into the variabe named as current. Now iterate and take the current to the extreme left of the tree by traversing only to its left. Pop the elemnt from the stack and assign it to the current. Store the data of current into the result array. Repeat the same set of steps until the Stack becomes empty or the current becomes NULL. And return the result array as the inorder traversal of a tree.
Function Documentation
diff --git a/d8/d99/connected__components__with__dsu_8cpp.html b/d8/d99/connected__components__with__dsu_8cpp.html
index 75568d7b0..ab127c3d4 100644
--- a/d8/d99/connected__components__with__dsu_8cpp.html
+++ b/d8/d99/connected__components__with__dsu_8cpp.html
@@ -155,7 +155,7 @@ uint32_t graph::disjoint_u
Detailed Description
The Disjoint union is the technique to find connected component in graph efficiently.
-
+
Algorithm
In Graph, if you have to find out the number of connected components, there are 2 options
- Depth first search
diff --git a/d8/dc8/class_compare-members.html b/d8/dc8/class_compare-members.html
new file mode 100644
index 000000000..84ead1ecc
--- /dev/null
+++ b/d8/dc8/class_compare-members.html
@@ -0,0 +1,109 @@
+
+
+
+
+
+
+
+Algorithms_in_C++: Member List
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Algorithms_in_C++ 1.0.0
+
+ Set of algorithms implemented in C++.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Compare< S, T, E > Member List
+
+
+
+This is the complete list of members for Compare< S, T, E >, including all inherited members.
+
+ operator()(tuple< S, T, E, double, double, double > &t1, tuple< S, T, E, double, double, double > &t2) Compare< S, T, E > inline
+
+
+
+
+ - Generated by
1.9.2
+
+
+
+
diff --git a/d9/dfd/comb__sort_8cpp.html b/d9/dfd/comb__sort_8cpp.html
index 871becef3..117c91753 100644
--- a/d9/dfd/comb__sort_8cpp.html
+++ b/d9/dfd/comb__sort_8cpp.html
@@ -172,7 +172,7 @@ Functions
Initialize swapped as true to make sure that loop runs
Keep running until gap = 1 or none elements were swapped
Find next gap
-Compare all elements with current gap
+Compare all elements with current gap
diff --git a/da/d52/minimum__edit__distance_8cpp.html b/da/d52/minimum__edit__distance_8cpp.html
index 3567f6cd6..624a0f246 100644
--- a/da/d52/minimum__edit__distance_8cpp.html
+++ b/da/d52/minimum__edit__distance_8cpp.html
@@ -136,7 +136,7 @@ Functions
Detailed Description
Implementation of Minimum Edit Distance using Dynamic Programing.
Given two strings str1 & str2 and we have to calculate the minimum number of operations (Insert, Remove, Replace) required to convert str1 to str2.
-
+
Algorithm
We will solve this problem using Naive recursion. But as we are approaching with a DP solution. So, we will take a DP array to store the solution of all sub-problems so that we don't have to perform recursion again and again. Now to solve the problem, We can traverse all characters from either right side of the strings or left side. Suppose we will do it from the right side. So, there are two possibilities for every pair of characters being traversed.
- If the last characters of two strings are the same, Ignore the characters and get the count for the remaining string. So, we get the solution for lengths m-1 and n-1 in a DP array.
diff --git a/db/d16/0__1__knapsack_8cpp.html b/db/d16/0__1__knapsack_8cpp.html
index 433c48500..cfcf6167c 100644
--- a/db/d16/0__1__knapsack_8cpp.html
+++ b/db/d16/0__1__knapsack_8cpp.html
@@ -135,7 +135,7 @@ Functions
Detailed Description
Implementation of 0-1 Knapsack Problem
Given weights and values of n items, put these items in a knapsack of capacity W to get the maximum total value in the knapsack. In other words, given two integer arrays val[0..n-1] and wt[0..n-1] which represent values and weights associated with n items respectively. Also given an integer W which represents knapsack capacity, find out the maximum value subset of val[] such that sum of the weights of this subset is smaller than or equal to W. You cannot break an item, either pick the complete item or don’t pick it (0-1 property)
-
+
Algorithm
The idea is to consider all subsets of items and calculate the total weight and value of all subsets. Consider the only subsets whose total weight is smaller than W. From all such subsets, pick the maximum value subset.
- Author
- Anmol
diff --git a/db/dca/kadane2_8cpp.html b/db/dca/kadane2_8cpp.html
index 35dd96829..1dbb15c18 100644
--- a/db/dca/kadane2_8cpp.html
+++ b/db/dca/kadane2_8cpp.html
@@ -131,7 +131,7 @@ Functions
Detailed Description
Implementation of Kadane Algorithm
Kadane algorithm is used to find the maximum sum subarray in an array and maximum sum subarray problem is the task of finding a contiguous subarray with the largest sum
-
+
Algorithm
The simple idea of the algorithm is to search for all positive contiguous segments of the array and keep track of maximum sum contiguous segment among all positive segments(curr_sum is used for this) Each time we get a positive sum we compare it with max_sum and update max_sum if it is greater than curr_sum
diff --git a/dd/d47/namespacemath.html b/dd/d47/namespacemath.html
index c23f2ccf6..1d04b6d46 100644
--- a/dd/d47/namespacemath.html
+++ b/dd/d47/namespacemath.html
@@ -145,7 +145,7 @@ Functions
Mathematical algorithms
Given a recurrence relation; evaluate the value of nth term. For e.g., For fibonacci series, recurrence series is f(n) = f(n-1) + f(n-2) where f(0) = 0 and f(1) = 1. Note that the method used only demonstrates recurrence relation with one variable (n), unlike nCr problem, since it has two (n, r)
-
+
Algorithm
This problem can be solved using matrix exponentiation method.
- See also
- here for simple number exponentiation algorithm or explaination here.
diff --git a/dd/dca/class_f_c_f_s.html b/dd/dca/class_f_c_f_s.html
new file mode 100644
index 000000000..cc5a819ff
--- /dev/null
+++ b/dd/dca/class_f_c_f_s.html
@@ -0,0 +1,376 @@
+
+
+
+
+
+
+
+Algorithms_in_C++: FCFS< S, T, E > Class Template Reference
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Algorithms_in_C++ 1.0.0
+
+ Set of algorithms implemented in C++.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ FCFS< S, T, E > Class Template Reference
+
+
+
+Class which implements the FCFS scheduling algorithm.
+ More...
+
+
+Public Member Functions
void addProcess (S id, T arrival, E burst) Adds the process to the ready queue if it isn't already there. More...
vector< tuple< S, T, E, double, double, double > > scheduleForFcfs () Algorithm for scheduling CPU processes according to the First Come First Serve(FCFS) scheduling algorithm. More...
void printResult () Utility function for printing the status of each process after execution. More...
+
+Private Attributes
priority_queue< tuple< S, T, E, double, double, double >, vector< tuple< S, T, E, double, double, double > >, Compare< S, T, E > > schedule
+vector< tuple< S, T, E, double, double, double > > result
+unordered_set< S > idList
+Detailed Description
+template<typename S, typename T, typename E>
+class FCFS< S, T, E >Class which implements the FCFS scheduling algorithm.
+- Template Parameters
-
+
+ S Data type of Process ID T Data type of Arrival time E Data type of Burst time
+
+
+Member Function Documentation
+
+◆ addProcess()
+
+
+
+
+template<typename S , typename T , typename E >
+
+
+
+
+
+ void FCFS< S, T, E >::addProcess
+ (
+ S
+ id,
+
+
+ T
+ arrival,
+
+
+ E
+ burst
+
+
+ )
+
+
+
+
+inline
+
+
+
+
+Adds the process to the ready queue if it isn't already there.
+- Parameters
-
+
+ id Process ID arrival Arrival time of the process burst Burst time of the process
+
+
+- Returns
- void
+
+
+
+
+
+
+
+
+
+priority_queue< tuple< S, T, E, double, double, double >, vector< tuple< S, T, E, double, double, double > >, Compare< S, T, E > > scheduleDefinition: fcfs_scheduling.cpp:111
+T make_tuple(T... args)
+
+
+Here is the call graph for this function:
+
+
+
+
+
+
+
+
+◆ printResult()
+
+
+
+
+template<typename S , typename T , typename E >
+
+
+
+
+
+ void FCFS< S, T, E >::printResult
+ (
+ )
+
+
+
+
+inline
+
+
+
+
+Utility function for printing the status of each process after execution.
+- Returns
- void
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+T fixed(T... args)
+T left(T... args)
+
+T setprecision(T... args)
+T setw(T... args)
+
+Here is the call graph for this function:
+
+
+
+
+
+
+
+
+◆ scheduleForFcfs()
+
+
+
+
+template<typename S , typename T , typename E >
+
+
+
+
+
+ vector< tuple< S, T, E, double, double, double > > FCFS< S, T, E >::scheduleForFcfs
+ (
+ )
+
+
+
+
+inline
+
+
+
+
+Algorithm for scheduling CPU processes according to the First Come First Serve(FCFS) scheduling algorithm.
+FCFS is a non-preemptive algorithm in which the process which arrives first gets executed first. If two or more processes arrive together then the process with smaller process ID runs first (each process has a unique proces ID).
+I used a min priority queue of tuples to accomplish this task. The processes are ordered by their arrival times. If arrival times of some processes are equal, then they are ordered by their process ID.
+- Returns
- void
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Member Data Documentation
+
+◆ schedule
+
+
+
+
+template<typename S , typename T , typename E >
+
+
+
+
+
+ priority_queue<tuple<S, T, E, double, double, double>, vector<tuple<S, T, E, double, double, double> >, Compare<S, T, E> > FCFS< S, T, E >::schedule
+
+
+
+
+private
+
+
+
+Priority queue of schedules(stored as tuples) of processes. In each tuple 1st element: Process ID 2nd element: Arrival Time 3rd element: Burst time 4th element: Completion time 5th element: Turnaround time 6th element: Waiting time
+
+
+
+
The documentation for this class was generated from the following file:
+- cpu_scheduling_algorithms/fcfs_scheduling.cpp
+
+
+
+
+
+
+
+ - Generated by 1.9.2
+
+
+
+
diff --git a/dd/dca/class_f_c_f_s.js b/dd/dca/class_f_c_f_s.js
new file mode 100644
index 000000000..3c4ded1da
--- /dev/null
+++ b/dd/dca/class_f_c_f_s.js
@@ -0,0 +1,7 @@
+var class_f_c_f_s =
+[
+ [ "addProcess", "dd/dca/class_f_c_f_s.html#a8fbfe4d85f7576b4a7aade07d29fbd69", null ],
+ [ "printResult", "dd/dca/class_f_c_f_s.html#abb361a612b18bb189aa6d3c49288b793", null ],
+ [ "scheduleForFcfs", "dd/dca/class_f_c_f_s.html#aa25dbe30ba9930b5a7c1a6d11758bd91", null ],
+ [ "schedule", "dd/dca/class_f_c_f_s.html#af2594e22a867b308e027623940193d46", null ]
+];
\ No newline at end of file
diff --git a/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.map b/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.map
new file mode 100644
index 000000000..5ff1060ab
--- /dev/null
+++ b/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.map
@@ -0,0 +1,6 @@
+
diff --git a/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.md5 b/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.md5
new file mode 100644
index 000000000..f960e4771
--- /dev/null
+++ b/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.md5
@@ -0,0 +1 @@
+40be8724cd3544d6f4f7db4d23d50120
\ No newline at end of file
diff --git a/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.svg b/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.svg
new file mode 100644
index 000000000..4e2da5e1f
--- /dev/null
+++ b/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.svg
@@ -0,0 +1,69 @@
+
+
+
+
+
diff --git a/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.map b/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.map
new file mode 100644
index 000000000..bf9103337
--- /dev/null
+++ b/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.map
@@ -0,0 +1,6 @@
+
diff --git a/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.md5 b/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.md5
new file mode 100644
index 000000000..da9dbaf40
--- /dev/null
+++ b/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.md5
@@ -0,0 +1 @@
+fbc7b8c39328fdeb00baa02dadb94ca6
\ No newline at end of file
diff --git a/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.svg b/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.svg
new file mode 100644
index 000000000..e611a5eb6
--- /dev/null
+++ b/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.svg
@@ -0,0 +1,67 @@
+
+
+
+
+
diff --git a/de/d4a/class_compare.html b/de/d4a/class_compare.html
new file mode 100644
index 000000000..3bea0dd03
--- /dev/null
+++ b/de/d4a/class_compare.html
@@ -0,0 +1,195 @@
+
+
+
+
+
+
+
+Algorithms_in_C++: Compare< S, T, E > Class Template Reference
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Algorithms_in_C++ 1.0.0
+
+ Set of algorithms implemented in C++.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Compare< S, T, E > Class Template Reference
+
+
+
+Comparator class for priority queue.
+ More...
+
+
+Public Member Functions
bool operator() (tuple< S, T, E, double, double, double > &t1, tuple< S, T, E, double, double, double > &t2) A comparator function that checks whether to swap the two tuples or not. to https://www.geeksforgeeks.org/comparator-class-in-c-with-examples/ for detailed description of comparator. More...
+Detailed Description
+template<typename S, typename T, typename E>
+class Compare< S, T, E >Comparator class for priority queue.
+- Template Parameters
-
+
+ S Data type of Process ID T Data type of Arrival time E Data type of Burst time
+
+
+Member Function Documentation
+
+◆ operator()()
+
+
+
+
+template<typename S , typename T , typename E >
+
+
+
+
+
+ bool Compare< S, T, E >::operator()
+ (
+ tuple< S, T, E, double, double, double > &
+ t1,
+
+
+ tuple< S, T, E, double, double, double > &
+ t2
+
+
+ )
+
+
+
+
+inline
+
+
+
+
+A comparator function that checks whether to swap the two tuples or not. to https://www.geeksforgeeks.org/comparator-class-in-c-with-examples/ for detailed description of comparator.
+- Parameters
-
+
+ t1 First tuple t2 Second tuple
+
+
+- Returns
- true if the tuples SHOULD be swapped
+-
+false if the tuples SHOULDN'T be swapped
+
+
+
+
The documentation for this class was generated from the following file:
+- cpu_scheduling_algorithms/fcfs_scheduling.cpp
+
+
+
+
+
+
+
+ - Generated by 1.9.2
+
+
+
+
diff --git a/de/d4a/class_compare.js b/de/d4a/class_compare.js
new file mode 100644
index 000000000..f123aff03
--- /dev/null
+++ b/de/d4a/class_compare.js
@@ -0,0 +1,4 @@
+var class_compare =
+[
+ [ "operator()", "de/d4a/class_compare.html#afbdf9a44adb49728dc704155d7d1570c", null ]
+];
\ No newline at end of file
diff --git a/de/d8d/class_f_c_f_s-members.html b/de/d8d/class_f_c_f_s-members.html
new file mode 100644
index 000000000..5afa21c6c
--- /dev/null
+++ b/de/d8d/class_f_c_f_s-members.html
@@ -0,0 +1,114 @@
+
+
+
+
+
+
+
+Algorithms_in_C++: Member List
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Algorithms_in_C++ 1.0.0
+
+ Set of algorithms implemented in C++.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ FCFS< S, T, E > Member List
+
+
+
+This is the complete list of members for FCFS< S, T, E >, including all inherited members.
+
+ addProcess(S id, T arrival, E burst) FCFS< S, T, E > inline idList (defined in FCFS< S, T, E >) FCFS< S, T, E > private printResult() FCFS< S, T, E > inline result (defined in FCFS< S, T, E >) FCFS< S, T, E > private schedule FCFS< S, T, E > private scheduleForFcfs() FCFS< S, T, E > inline
+
+
+
+
+ - Generated by 1.9.2
+
+
+
+
diff --git a/df/d47/fcfs__scheduling_8cpp.html b/df/d47/fcfs__scheduling_8cpp.html
new file mode 100644
index 000000000..298493c7c
--- /dev/null
+++ b/df/d47/fcfs__scheduling_8cpp.html
@@ -0,0 +1,376 @@
+
+
+
+
+
+
+
+Algorithms_in_C++: cpu_scheduling_algorithms/fcfs_scheduling.cpp File Reference
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Algorithms_in_C++ 1.0.0
+
+ Set of algorithms implemented in C++.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Implementation of FCFS CPU scheduling algorithm.
+More...
+#include <algorithm>
+#include <cassert>
+#include <cstdlib>
+#include <ctime>
+#include <iomanip>
+#include <iostream>
+#include <queue>
+#include <unordered_set>
+#include <vector>
+
+Include dependency graph for fcfs_scheduling.cpp:
+
+
+
+
+
+
+Classes
class Compare< S, T, E > Comparator class for priority queue. More...
class FCFS< S, T, E > Class which implements the FCFS scheduling algorithm. More...
+
+Functions
template<typename S , typename T , typename E > bool sortcol (tuple< S, T, E > &t1, tuple< S, T, E > &t2) Comparator function for sorting a vector. More...
template<typename S , typename T , typename E > vector< tuple< S, T, E, double, double, double > > get_final_status (vector< tuple< uint32_t, uint32_t, uint32_t > > input) Function to be used for testing purposes. This function guarantees the correct solution for FCFS scheduling algorithm. More...
static void test () Self-test implementations. More...
int main () Entry point of the program. More...
+Detailed Description
+Implementation of FCFS CPU scheduling algorithm.
+FCFS is a non-preemptive CPU scheduling algorithm in which whichever process arrives first, gets executed first. If two or more processes arrive simultaneously, the process with smaller process ID gets executed first. https://bit.ly/3ABNXOCPratyush Vatsa
+Function Documentation
+
+◆ get_final_status()
+
+
+
+
+template<typename S , typename T , typename E >
+
+
+ vector< tuple< S, T, E, double, double, double > > get_final_status
+ (
+ vector< tuple< uint32_t, uint32_t, uint32_t > >
+ input )
+
+
+
+
+Function to be used for testing purposes. This function guarantees the correct solution for FCFS scheduling algorithm.
+- Parameters
-
+
+ input the input data
+
+
+Sorts the input vector according to arrival time. Processes whose arrival times are same get sorted according to process ID For each process, completion time, turnaround time and completion time are calculated, inserted in a tuple, which is added to the vector result.
- Returns
- A vector of tuples consisting of process ID, arrival time, burst time, completion time, turnaround time and waiting time for each process.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+T begin(T... args)
+T end(T... args)
+
+T size(T... args)
+T sort(T... args)
+
+
+
+
+
+◆ main()
+
+
+
+
+
+ int main
+ (
+ void
+ )
+
+
+
+
+
+◆ sortcol()
+
+
+
+
+template<typename S , typename T , typename E >
+
+
+ bool sortcol
+ (
+ tuple< S, T, E > &
+ t1,
+
+
+ tuple< S, T, E > &
+ t2
+
+
+ )
+
+
+
+
+Comparator function for sorting a vector.
+- Template Parameters
-
+
+ S Data type of Process ID T Data type of Arrival time E Data type of Burst time
+
+
+- Parameters
-
+
+ t1 First tuple t2 Second tuple
+
+
+- Returns
- true if t1 and t2 are in the CORRECT order
+-
+false if t1 and t2 are in the INCORRECT order
+
+
+
+
+◆ test()
+
+
+
+
+
+
+
+
+ static void test
+ (
+ )
+
+
+
+
+static
+
+
+
+
+Self-test implementations.
+- Returns
- void
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+void addProcess(S id, T arrival, E burst)Adds the process to the ready queue if it isn't already there.Definition: fcfs_scheduling.cpp:129
+vector< tuple< S, T, E, double, double, double > > scheduleForFcfs()Algorithm for scheduling CPU processes according to the First Come First Serve(FCFS) scheduling algor...Definition: fcfs_scheduling.cpp:154
+
+T rand(T... args)
+T srand(T... args)
+T time(T... args)
+
+Here is the call graph for this function:
+
+
+
+
+
+
+
+
+
+
+
+
+
+ - Generated by 1.9.2
+
+
+
+
diff --git a/df/d47/fcfs__scheduling_8cpp.js b/df/d47/fcfs__scheduling_8cpp.js
new file mode 100644
index 000000000..3ab097c7e
--- /dev/null
+++ b/df/d47/fcfs__scheduling_8cpp.js
@@ -0,0 +1,9 @@
+var fcfs__scheduling_8cpp =
+[
+ [ "Compare< S, T, E >", "de/d4a/class_compare.html", "de/d4a/class_compare" ],
+ [ "FCFS< S, T, E >", "dd/dca/class_f_c_f_s.html", "dd/dca/class_f_c_f_s" ],
+ [ "get_final_status", "df/d47/fcfs__scheduling_8cpp.html#a8f2b90cb64d63a7080965e66a05ccf86", null ],
+ [ "main", "df/d47/fcfs__scheduling_8cpp.html#ae66f6b31b5ad750f1fe042a706a4e3d4", null ],
+ [ "sortcol", "df/d47/fcfs__scheduling_8cpp.html#a18920aa331faf4476b251c8cdb2c2bec", null ],
+ [ "test", "df/d47/fcfs__scheduling_8cpp.html#aa8dca7b867074164d5f45b0f3851269d", null ]
+];
\ No newline at end of file
diff --git a/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.map b/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.map
new file mode 100644
index 000000000..fac5223b9
--- /dev/null
+++ b/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.map
@@ -0,0 +1,8 @@
+
diff --git a/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.md5 b/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.md5
new file mode 100644
index 000000000..60334c7c9
--- /dev/null
+++ b/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.md5
@@ -0,0 +1 @@
+eb25f61bb3c01f732953e7b177f935be
\ No newline at end of file
diff --git a/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.svg b/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.svg
new file mode 100644
index 000000000..861a9adf2
--- /dev/null
+++ b/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.svg
@@ -0,0 +1,99 @@
+
+
+
+
+
diff --git a/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.map b/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.map
new file mode 100644
index 000000000..ae5ce9e63
--- /dev/null
+++ b/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.map
@@ -0,0 +1,9 @@
+
diff --git a/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.md5 b/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.md5
new file mode 100644
index 000000000..ad9c7536b
--- /dev/null
+++ b/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.md5
@@ -0,0 +1 @@
+d1153ad5effebcdd01be2ae30d68c8af
\ No newline at end of file
diff --git a/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.svg b/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.svg
new file mode 100644
index 000000000..d4ff69629
--- /dev/null
+++ b/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.svg
@@ -0,0 +1,114 @@
+
+
+
+
+
diff --git a/df/d66/vector__cross__product_8cpp.html b/df/d66/vector__cross__product_8cpp.html
index 71f0fb3b7..cc70bdf6c 100644
--- a/df/d66/vector__cross__product_8cpp.html
+++ b/df/d66/vector__cross__product_8cpp.html
@@ -144,7 +144,7 @@ Functions
The direction ratios (DR) are calculated as follows: 1st DR, J: (b * z) - (c * y) 2nd DR, A: -((a * z) - (c * x)) 3rd DR, N: (a * y) - (b * x)
Therefore, the direction ratios of the cross product are: J, A, N The following C++ Program calculates the direction ratios of the cross products of two vector. The program uses a function, cross() for doing so. The direction ratios for the first and the second vector has to be passed one by one seperated by a space character.
Magnitude of a vector is the square root of the sum of the squares of the direction ratios.
-
+
Example:
An example of a running instance of the executable program:
Pass the first Vector: 1 2 3
Pass the second Vector: 4 5 6 The cross product is: -3 6 -3 Magnitude: 7.34847
diff --git a/dir_000002_000016.html b/dir_000002_000017.html
similarity index 100%
rename from dir_000002_000016.html
rename to dir_000002_000017.html
diff --git a/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.map b/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.map
index 623879934..72fef3963 100644
--- a/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.map
+++ b/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.map
@@ -1,5 +1,5 @@
diff --git a/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.md5 b/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.md5
index 5fd2b3301..257e4dba0 100644
--- a/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.md5
+++ b/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.md5
@@ -1 +1 @@
-92fa4d7ae23a16161aeff73e457c6e1f
\ No newline at end of file
+76e5d78bae3066db57a72fde536d8c2e
\ No newline at end of file
diff --git a/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.svg b/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.svg
index d7d51943b..7af541bfb 100644
--- a/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.svg
+++ b/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.svg
@@ -32,7 +32,7 @@
dir_4d6e05837bf820fb089a8a8cdf2f42b7->dir_9c6faab82c22511b50177aa2e38e2780
+
1
diff --git a/dir_cc8e79ed9d2b7756c78e8d0c87c6c0c7.html b/dir_cc8e79ed9d2b7756c78e8d0c87c6c0c7.html
new file mode 100644
index 000000000..7068e3381
--- /dev/null
+++ b/dir_cc8e79ed9d2b7756c78e8d0c87c6c0c7.html
@@ -0,0 +1,113 @@
+
+
+
+
+
+
+
+Algorithms_in_C++: cpu_scheduling_algorithms Directory Reference
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Algorithms_in_C++ 1.0.0
+
+ Set of algorithms implemented in C++.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ cpu_scheduling_algorithms Directory Reference
+
+
+
+
+Files
file fcfs_scheduling.cpp Implementation of FCFS CPU scheduling algorithm.
+
+
+
+
+
+
+ - Generated by
1.9.2
+
+
+
+
diff --git a/dir_cc8e79ed9d2b7756c78e8d0c87c6c0c7.js b/dir_cc8e79ed9d2b7756c78e8d0c87c6c0c7.js
new file mode 100644
index 000000000..804b70f89
--- /dev/null
+++ b/dir_cc8e79ed9d2b7756c78e8d0c87c6c0c7.js
@@ -0,0 +1,4 @@
+var dir_cc8e79ed9d2b7756c78e8d0c87c6c0c7 =
+[
+ [ "fcfs_scheduling.cpp", "df/d47/fcfs__scheduling_8cpp.html", "df/d47/fcfs__scheduling_8cpp" ]
+];
\ No newline at end of file
diff --git a/files.html b/files.html
index d3fdd7b77..6eaa50aa5 100644
--- a/files.html
+++ b/files.html
@@ -121,232 +121,234 @@ solve-a-rat-in-a-maze-c-java-pytho/"
- ► data_structures ► divide_and_conquer ► dynamic_programming ► geometry ► graph ► graphics ► greedy_algorithms ► hashing ► linear_algebra ► machine_learning ► math ► numerical_methods ► operations_on_datastructures ► others ► probability ► range_queries ► search ► sorting ► strings ► cpu_scheduling_algorithms ► data_structures ► divide_and_conquer ► dynamic_programming ► geometry ► graph ► graphics ► greedy_algorithms ► hashing ► linear_algebra ► machine_learning ► math ► numerical_methods ► operations_on_datastructures ► others ► probability ► range_queries ► search ► sorting ► strings
diff --git a/files_dup.js b/files_dup.js
index 927c6694b..685144116 100644
--- a/files_dup.js
+++ b/files_dup.js
@@ -3,6 +3,7 @@ var files_dup =
[ "backtracking", "dir_c11585dfcef32a26e29098facab6c144.html", "dir_c11585dfcef32a26e29098facab6c144" ],
[ "bit_manipulation", "dir_f3c4fbc4e901afa0a54d0623c5574aa7.html", "dir_f3c4fbc4e901afa0a54d0623c5574aa7" ],
[ "ciphers", "dir_4d6e05837bf820fb089a8a8cdf2f42b7.html", "dir_4d6e05837bf820fb089a8a8cdf2f42b7" ],
+ [ "cpu_scheduling_algorithms", "dir_cc8e79ed9d2b7756c78e8d0c87c6c0c7.html", "dir_cc8e79ed9d2b7756c78e8d0c87c6c0c7" ],
[ "data_structures", "dir_2e746e9d06bf2d8ff842208bcc6ebcfc.html", "dir_2e746e9d06bf2d8ff842208bcc6ebcfc" ],
[ "divide_and_conquer", "dir_93bc990c5cceb745f78af6949e9ef947.html", "dir_93bc990c5cceb745f78af6949e9ef947" ],
[ "dynamic_programming", "dir_8a20dd5bfd5341a725342bf72b6b686f.html", "dir_8a20dd5bfd5341a725342bf72b6b686f" ],
diff --git a/functions_a.html b/functions_a.html
index b6c1b9164..56bd8eb2f 100644
--- a/functions_a.html
+++ b/functions_a.html
@@ -103,6 +103,7 @@ $(document).ready(function(){initNavTree('functions_a.html',''); initResizable()
- add_digit() : large_number
- add_edge() : graph::Graph< T >, range_queries::heavy_light_decomposition::Tree< X >
- addEdge() : Graph, graph::HKGraph, graph::is_graph_bipartite::Graph
+- addProcess() : FCFS< S, T, E >
- addVertices() : Graph
- adj : graph::HKGraph, graph::is_graph_bipartite::Graph
- adjacency_list : graph::Graph< T >
diff --git a/functions_func_a.html b/functions_func_a.html
index 895b8d7b2..ce7a6fe56 100644
--- a/functions_func_a.html
+++ b/functions_func_a.html
@@ -101,6 +101,7 @@ $(document).ready(function(){initNavTree('functions_func_a.html',''); initResiza
- add_digit() : large_number
- add_edge() : graph::Graph< T >, range_queries::heavy_light_decomposition::Tree< X >
- addEdge() : Graph, graph::HKGraph, graph::is_graph_bipartite::Graph
+- addProcess() : FCFS< S, T, E >
- addVertices() : Graph
- arg() : Complex
- AyStarSearch() : machine_learning::aystar_search::AyStarSearch< Puzzle >
diff --git a/functions_func_i.html b/functions_func_i.html
index f6c10499c..b46256971 100644
--- a/functions_func_i.html
+++ b/functions_func_i.html
@@ -99,7 +99,7 @@ $(document).ready(function(){initNavTree('functions_func_i.html',''); initResiza
- init() : range_queries::heavy_light_decomposition::HLD< X >, range_queries::heavy_light_decomposition::Tree< X >
- inOrderIterative() : others::iterative_tree_traversals::BinaryTree
- insert() : binary_search_tree< T >, data_structures::linked_list::list, data_structures::list_array::list
-- Insert() : data_structures::tree_234::Tree234
+- Insert() : data_structures::tree_234::Tree234
- insert() : data_structures::trie, data_structures::trie_using_hashmap::Trie
- Insert() : operations_on_datastructures::trie_operations::Tnode
- insert() : probability::windowed_median::WindowedMedian, Trie
diff --git a/functions_func_o.html b/functions_func_o.html
index 2d36ddc58..524631ee8 100644
--- a/functions_func_o.html
+++ b/functions_func_o.html
@@ -105,7 +105,7 @@ $(document).ready(function(){initNavTree('functions_func_o.html',''); initResiza
- operator&() : uint128_t, uint256_t
- operator&&() : uint128_t, uint256_t
- operator&=() : uint128_t, uint256_t
-- operator()() : uint128_t, uint256_t
+- operator()() : Compare< S, T, E >, uint128_t, uint256_t
- operator*() : Complex, uint128_t, uint256_t
- operator*=() : large_number, uint128_t, uint256_t
- operator+() : Complex, uint128_t, uint256_t
diff --git a/functions_func_p.html b/functions_func_p.html
index 03847d40c..23611cdc6 100644
--- a/functions_func_p.html
+++ b/functions_func_p.html
@@ -103,6 +103,7 @@ $(document).ready(function(){initNavTree('functions_func_p.html',''); initResiza
- preOrderIterative() : others::iterative_tree_traversals::BinaryTree
- Print() : data_structures::tree_234::Tree234
- PrintNode() : data_structures::tree_234::Tree234
+- printResult() : FCFS< S, T, E >
- probability_density() : probability::geometric_dist::geometric_distribution
- push() : stack< Type >
- push_back() : data_structures::linked_list::list
diff --git a/functions_func_s.html b/functions_func_s.html
index 093c5d0f6..45a5ca001 100644
--- a/functions_func_s.html
+++ b/functions_func_s.html
@@ -94,6 +94,7 @@ $(document).ready(function(){initNavTree('functions_func_s.html',''); initResiza
- s -
- save_model() : machine_learning::neural_network::NeuralNetwork
+- scheduleForFcfs() : FCFS< S, T, E >
- search() : data_structures::linked_list::list, data_structures::trie, data_structures::trie_using_hashmap::Trie, Trie
- searchElement() : data_structures::SkipList
- SearchFreqSuggestions() : operations_on_datastructures::trie_operations::Tnode
diff --git a/functions_i.html b/functions_i.html
index 9c44e9eba..7f28ec0c7 100644
--- a/functions_i.html
+++ b/functions_i.html
@@ -99,7 +99,7 @@ $(document).ready(function(){initNavTree('functions_i.html',''); initResizable()
- init() : range_queries::heavy_light_decomposition::HLD< X >, range_queries::heavy_light_decomposition::Tree< X >
- inOrderIterative() : others::iterative_tree_traversals::BinaryTree
- insert() : binary_search_tree< T >, data_structures::linked_list::list, data_structures::list_array::list
-- Insert() : data_structures::tree_234::Tree234
+- Insert() : data_structures::tree_234::Tree234
- insert() : data_structures::trie, data_structures::trie_using_hashmap::Trie
- Insert() : operations_on_datastructures::trie_operations::Tnode
- insert() : probability::windowed_median::WindowedMedian, Trie
diff --git a/functions_o.html b/functions_o.html
index 6ac295c79..837e3e696 100644
--- a/functions_o.html
+++ b/functions_o.html
@@ -105,7 +105,7 @@ $(document).ready(function(){initNavTree('functions_o.html',''); initResizable()
- operator&() : uint128_t, uint256_t
- operator&&() : uint128_t, uint256_t
- operator&=() : uint128_t, uint256_t
-- operator()() : uint128_t, uint256_t
+- operator()() : Compare< S, T, E >, uint128_t, uint256_t
- operator*() : Complex, uint128_t, uint256_t
- operator*=() : large_number, uint128_t, uint256_t
- operator+() : Complex, large_number, uint128_t, uint256_t
diff --git a/functions_p.html b/functions_p.html
index 90430b6ff..183e64c23 100644
--- a/functions_p.html
+++ b/functions_p.html
@@ -110,6 +110,7 @@ $(document).ready(function(){initNavTree('functions_p.html',''); initResizable()
- preOrderIterative() : others::iterative_tree_traversals::BinaryTree
- Print() : data_structures::tree_234::Tree234
- PrintNode() : data_structures::tree_234::Tree234
+- printResult() : FCFS< S, T, E >
- probability_density() : probability::geometric_dist::geometric_distribution
- psucc : data_structures::linked_list::link
- ptrs : range_queries::perSegTree
diff --git a/functions_s.html b/functions_s.html
index d4dd818d0..32e7c85b4 100644
--- a/functions_s.html
+++ b/functions_s.html
@@ -96,6 +96,8 @@ $(document).ready(function(){initNavTree('functions_s.html',''); initResizable()
- s_size : range_queries::heavy_light_decomposition::SG< X >
- s_tree : range_queries::heavy_light_decomposition::SG< X >
- save_model() : machine_learning::neural_network::NeuralNetwork
+- schedule : FCFS< S, T, E >
+- scheduleForFcfs() : FCFS< S, T, E >
- search() : data_structures::linked_list::list, data_structures::trie, data_structures::trie_using_hashmap::Trie, Trie
- searchElement() : data_structures::SkipList
- SearchFreqSuggestions() : operations_on_datastructures::trie_operations::Tnode
diff --git a/functions_vars.html b/functions_vars.html
index 9752b512f..a47e938f3 100644
--- a/functions_vars.html
+++ b/functions_vars.html
@@ -217,6 +217,7 @@ $(document).ready(function(){initNavTree('functions_vars.html',''); initResizabl
- s -
- s_size : range_queries::heavy_light_decomposition::SG< X >
- s_tree : range_queries::heavy_light_decomposition::SG< X >
+- schedule : FCFS< S, T, E >
- side : graph::is_graph_bipartite::Graph
- size : stack< Type >
- size_ : binary_search_tree< T >
diff --git a/globals_func_g.html b/globals_func_g.html
index b8a49306e..dd9a8ec0e 100644
--- a/globals_func_g.html
+++ b/globals_func_g.html
@@ -96,6 +96,7 @@ $(document).ready(function(){initNavTree('globals_func_g.html',''); initResizabl
- gcd() : gcd_iterative_euclidean.cpp, gcd_of_n_numbers.cpp, gcd_recursive_euclidean.cpp, least_common_multiple.cpp
- genArray() : spiral_print.cpp
- get_clock_diff() : kohonen_som_topology.cpp, kohonen_som_trace.cpp
+- get_final_status() : fcfs_scheduling.cpp
- get_input() : ternary_search.cpp
- get_inverse() : ordinary_least_squares_regressor.cpp
- get_min_2d() : kohonen_som_topology.cpp
diff --git a/globals_func_i.html b/globals_func_i.html
index 7ce39a9c8..eaac1ff58 100644
--- a/globals_func_i.html
+++ b/globals_func_i.html
@@ -104,8 +104,8 @@ $(document).ready(function(){initNavTree('globals_func_i.html',''); initResizabl
- is_happy() : happy_number.cpp
- is_prime() : check_prime.cpp
- is_square() : ordinary_least_squares_regressor.cpp
-- isPrime() : modular_inverse_fermat_little_theorem.cpp
- IsPrime() : primality_test.cpp
+- isPrime() : modular_inverse_fermat_little_theorem.cpp
- it_ternary_search() : ternary_search.cpp
diff --git a/globals_func_m.html b/globals_func_m.html
index d58fdf390..875a674bd 100644
--- a/globals_func_m.html
+++ b/globals_func_m.html
@@ -93,7 +93,7 @@ $(document).ready(function(){initNavTree('globals_func_m.html',''); initResizabl
- m -
-- main() : graph_coloring.cpp, knight_tour.cpp, minimax.cpp, n_queens.cpp, n_queens_all_solution_optimised.cpp, nqueen_print_all_solutions.cpp, rat_maze.cpp, subarray_sum.cpp, subset_sum.cpp, sudoku_solve.cpp, wildcard_matching.cpp, count_of_set_bits.cpp, count_of_trailing_ciphers_in_factorial_n.cpp, hamming_distance.cpp, caesar_cipher.cpp, elliptic_curve_key_exchange.cpp, hill_cipher.cpp, morse_code.cpp, vigenere_cipher.cpp, xor_cipher.cpp, avltree.cpp, disjoint_set.cpp, linked_list.cpp, linkedlist_implentation_usingarray.cpp, list_array.cpp, queue_using_array.cpp, queue_using_two_stacks.cpp, reverse_a_linked_list.cpp, skip_list.cpp, sparse_table.cpp, tree_234.cpp, trie_modern.cpp, trie_tree.cpp, trie_using_hashmap.cpp, karatsuba_algorithm_for_fast_multiplication.cpp, 0_1_knapsack.cpp, abbreviation.cpp, coin_change_topdown.cpp, cut_rod.cpp, house_robber.cpp, kadane2.cpp, longest_increasing_subsequence.cpp, longest_palindromic_subsequence.cpp, minimum_edit_distance.cpp, palindrome_partitioning.cpp, shortest_common_supersequence.cpp, word_break.cpp, jarvis_algorithm.cpp, line_segment_intersection.cpp, bidirectional_dijkstra.cpp, breadth_first_search.cpp, connected_components.cpp, connected_components_with_dsu.cpp, depth_first_search.cpp, depth_first_search_with_stack.cpp, dijkstra.cpp, hamiltons_cycle.cpp, hopcroft_karp.cpp, is_graph_bipartite.cpp, lowest_common_ancestor.cpp, travelling_salesman_problem.cpp, spirograph.cpp, jumpgame.cpp, chaining.cpp, double_hash_hash_table.cpp, linear_probing_hash_table.cpp, md5.cpp, quadratic_probing_hash_table.cpp, sha1.cpp, gram_schmidt.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, neural_network.cpp, ordinary_least_squares_regressor.cpp, armstrong_number.cpp, binary_exponent.cpp, binomial_calculate.cpp, check_amicable_pair.cpp, check_factorial.cpp, check_prime.cpp, complex_numbers.cpp, double_factorial.cpp, eulers_totient_function.cpp, extended_euclid_algorithm.cpp, factorial.cpp, fast_power.cpp, fibonacci.cpp, fibonacci_fast.cpp, fibonacci_matrix_exponentiation.cpp, fibonacci_sum.cpp, finding_number_of_digits_in_a_number.cpp, gcd_iterative_euclidean.cpp, gcd_of_n_numbers.cpp, gcd_recursive_euclidean.cpp, integral_approximation.cpp, inv_sqrt.cpp, large_factorial.cpp, largest_power.cpp, lcm_sum.cpp, least_common_multiple.cpp, magic_number.cpp, miller_rabin.cpp, modular_division.cpp, modular_exponentiation.cpp, modular_inverse_fermat_little_theorem.cpp, n_bonacci.cpp, n_choose_r.cpp, ncr_modulo_p.cpp, number_of_positive_divisors.cpp, power_for_huge_numbers.cpp, power_of_two.cpp, prime_factorization.cpp, prime_numbers.cpp, primes_up_to_billion.cpp, realtime_stats.cpp, sieve_of_eratosthenes.cpp, sqrt_double.cpp, string_fibonacci.cpp, sum_of_binomial_coefficient.cpp, sum_of_digits.cpp, vector_cross_product.cpp, bisection_method.cpp, brent_method_extrema.cpp, false_position.cpp, gaussian_elimination.cpp, golden_search_extrema.cpp, lu_decompose.cpp, newton_raphson_method.cpp, ode_forward_euler.cpp, ode_midpoint_euler.cpp, ode_semi_implicit_euler.cpp, qr_decomposition.cpp, qr_eigen_values.cpp, rungekutta.cpp, successive_approximation.cpp, inorder_successor_of_bst.cpp, trie_multiple_search.cpp, buzz_number.cpp, decimal_to_hexadecimal.cpp, decimal_to_roman_numeral.cpp, fast_integer_input.cpp, happy_number.cpp, iterative_tree_traversals.cpp, kadanes3.cpp, lru_cache.cpp, matrix_exponentiation.cpp, palindrome_of_number.cpp, pascal_triangle.cpp, postfix_evaluation.cpp, primality_test.cpp, smallest_circle.cpp, sparse_matrix.cpp, spiral_print.cpp, stairs_pattern.cpp, tower_of_hanoi.cpp, vector_important_functions.cpp, addition_rule.cpp, bayes_theorem.cpp, binomial_dist.cpp, geometric_dist.cpp, poisson_dist.cpp, windowed_median.cpp, fenwick_tree.cpp, heavy_light_decomposition.cpp, persistent_seg_tree_lazy_prop.cpp, prefix_sum_array.cpp, sparse_table.cpp, binary_search.cpp, exponential_search.cpp, fibonacci_search.cpp, floyd_cycle_detection_algo.cpp, hash_search.cpp, interpolation_search.cpp, interpolation_search2.cpp, linear_search.cpp, median_search.cpp, saddleback_search.cpp, sublist_search.cpp, ternary_search.cpp, text_search.cpp, bogo_sort.cpp, comb_sort.cpp, count_inversions.cpp, cycle_sort.cpp, dnf_sort.cpp, gnome_sort.cpp, heap_sort.cpp, insertion_sort.cpp, merge_insertion_sort.cpp, merge_sort.cpp, pancake_sort.cpp, pigeonhole_sort.cpp, quick_sort.cpp, quick_sort_3.cpp, radix_sort2.cpp, random_pivot_quick_sort.cpp, recursive_bubble_sort.cpp, selection_sort_recursive.cpp, shell_sort2.cpp, strand_sort.cpp, wave_sort.cpp, brute_force_string_searching.cpp, horspool.cpp, knuth_morris_pratt.cpp, manacher_algorithm.cpp, rabin_karp.cpp, z_function.cpp
+- main() : graph_coloring.cpp, knight_tour.cpp, minimax.cpp, n_queens.cpp, n_queens_all_solution_optimised.cpp, nqueen_print_all_solutions.cpp, rat_maze.cpp, subarray_sum.cpp, subset_sum.cpp, sudoku_solve.cpp, wildcard_matching.cpp, count_of_set_bits.cpp, count_of_trailing_ciphers_in_factorial_n.cpp, hamming_distance.cpp, caesar_cipher.cpp, elliptic_curve_key_exchange.cpp, hill_cipher.cpp, morse_code.cpp, vigenere_cipher.cpp, xor_cipher.cpp, fcfs_scheduling.cpp, avltree.cpp, disjoint_set.cpp, linked_list.cpp, linkedlist_implentation_usingarray.cpp, list_array.cpp, queue_using_array.cpp, queue_using_two_stacks.cpp, reverse_a_linked_list.cpp, skip_list.cpp, sparse_table.cpp, tree_234.cpp, trie_modern.cpp, trie_tree.cpp, trie_using_hashmap.cpp, karatsuba_algorithm_for_fast_multiplication.cpp, 0_1_knapsack.cpp, abbreviation.cpp, coin_change_topdown.cpp, cut_rod.cpp, house_robber.cpp, kadane2.cpp, longest_increasing_subsequence.cpp, longest_palindromic_subsequence.cpp, minimum_edit_distance.cpp, palindrome_partitioning.cpp, shortest_common_supersequence.cpp, word_break.cpp, jarvis_algorithm.cpp, line_segment_intersection.cpp, bidirectional_dijkstra.cpp, breadth_first_search.cpp, connected_components.cpp, connected_components_with_dsu.cpp, depth_first_search.cpp, depth_first_search_with_stack.cpp, dijkstra.cpp, hamiltons_cycle.cpp, hopcroft_karp.cpp, is_graph_bipartite.cpp, lowest_common_ancestor.cpp, travelling_salesman_problem.cpp, spirograph.cpp, jumpgame.cpp, chaining.cpp, double_hash_hash_table.cpp, linear_probing_hash_table.cpp, md5.cpp, quadratic_probing_hash_table.cpp, sha1.cpp, gram_schmidt.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, neural_network.cpp, ordinary_least_squares_regressor.cpp, armstrong_number.cpp, binary_exponent.cpp, binomial_calculate.cpp, check_amicable_pair.cpp, check_factorial.cpp, check_prime.cpp, complex_numbers.cpp, double_factorial.cpp, eulers_totient_function.cpp, extended_euclid_algorithm.cpp, factorial.cpp, fast_power.cpp, fibonacci.cpp, fibonacci_fast.cpp, fibonacci_matrix_exponentiation.cpp, fibonacci_sum.cpp, finding_number_of_digits_in_a_number.cpp, gcd_iterative_euclidean.cpp, gcd_of_n_numbers.cpp, gcd_recursive_euclidean.cpp, integral_approximation.cpp, inv_sqrt.cpp, large_factorial.cpp, largest_power.cpp, lcm_sum.cpp, least_common_multiple.cpp, magic_number.cpp, miller_rabin.cpp, modular_division.cpp, modular_exponentiation.cpp, modular_inverse_fermat_little_theorem.cpp, n_bonacci.cpp, n_choose_r.cpp, ncr_modulo_p.cpp, number_of_positive_divisors.cpp, power_for_huge_numbers.cpp, power_of_two.cpp, prime_factorization.cpp, prime_numbers.cpp, primes_up_to_billion.cpp, realtime_stats.cpp, sieve_of_eratosthenes.cpp, sqrt_double.cpp, string_fibonacci.cpp, sum_of_binomial_coefficient.cpp, sum_of_digits.cpp, vector_cross_product.cpp, bisection_method.cpp, brent_method_extrema.cpp, false_position.cpp, gaussian_elimination.cpp, golden_search_extrema.cpp, lu_decompose.cpp, newton_raphson_method.cpp, ode_forward_euler.cpp, ode_midpoint_euler.cpp, ode_semi_implicit_euler.cpp, qr_decomposition.cpp, qr_eigen_values.cpp, rungekutta.cpp, successive_approximation.cpp, inorder_successor_of_bst.cpp, trie_multiple_search.cpp, buzz_number.cpp, decimal_to_hexadecimal.cpp, decimal_to_roman_numeral.cpp, fast_integer_input.cpp, happy_number.cpp, iterative_tree_traversals.cpp, kadanes3.cpp, lru_cache.cpp, matrix_exponentiation.cpp, palindrome_of_number.cpp, pascal_triangle.cpp, postfix_evaluation.cpp, primality_test.cpp, smallest_circle.cpp, sparse_matrix.cpp, spiral_print.cpp, stairs_pattern.cpp, tower_of_hanoi.cpp, vector_important_functions.cpp, addition_rule.cpp, bayes_theorem.cpp, binomial_dist.cpp, geometric_dist.cpp, poisson_dist.cpp, windowed_median.cpp, fenwick_tree.cpp, heavy_light_decomposition.cpp, persistent_seg_tree_lazy_prop.cpp, prefix_sum_array.cpp, sparse_table.cpp, binary_search.cpp, exponential_search.cpp, fibonacci_search.cpp, floyd_cycle_detection_algo.cpp, hash_search.cpp, interpolation_search.cpp, interpolation_search2.cpp, linear_search.cpp, median_search.cpp, saddleback_search.cpp, sublist_search.cpp, ternary_search.cpp, text_search.cpp, bogo_sort.cpp, comb_sort.cpp, count_inversions.cpp, cycle_sort.cpp, dnf_sort.cpp, gnome_sort.cpp, heap_sort.cpp, insertion_sort.cpp, merge_insertion_sort.cpp, merge_sort.cpp, pancake_sort.cpp, pigeonhole_sort.cpp, quick_sort.cpp, quick_sort_3.cpp, radix_sort2.cpp, random_pivot_quick_sort.cpp, recursive_bubble_sort.cpp, selection_sort_recursive.cpp, shell_sort2.cpp, strand_sort.cpp, wave_sort.cpp, brute_force_string_searching.cpp, horspool.cpp, knuth_morris_pratt.cpp, manacher_algorithm.cpp, rabin_karp.cpp, z_function.cpp
- mat_mul() : qr_eigen_values.cpp
- max_subarray_sum() : kadanes3.cpp
- merge() : merge_sort.cpp
diff --git a/globals_func_s.html b/globals_func_s.html
index a466aaaa6..660161a70 100644
--- a/globals_func_s.html
+++ b/globals_func_s.html
@@ -104,9 +104,10 @@ $(document).ready(function(){initNavTree('globals_func_s.html',''); initResizabl
- show_array() : bogo_sort.cpp
- show_data() : shell_sort2.cpp
- show_pascal() : pascal_triangle.cpp
-- sieve() : sieve_of_eratosthenes.cpp
- Sieve() : primes_up_to_billion.cpp
+- sieve() : sieve_of_eratosthenes.cpp
- SieveOfEratosthenes() : prime_factorization.cpp
+- sortcol() : fcfs_scheduling.cpp
- spiralPrint() : spiral_print.cpp
- Sqrt() : sqrt_double.cpp
- Standard_InvSqrt() : inv_sqrt.cpp
diff --git a/globals_func_t.html b/globals_func_t.html
index 71ab7f4f2..bc57baac7 100644
--- a/globals_func_t.html
+++ b/globals_func_t.html
@@ -94,7 +94,7 @@ $(document).ready(function(){initNavTree('globals_func_t.html',''); initResizabl
- t -
- ternary_search() : ternary_search.cpp
-- test() : rat_maze.cpp, subarray_sum.cpp, subset_sum.cpp, wildcard_matching.cpp, count_of_set_bits.cpp, count_of_trailing_ciphers_in_factorial_n.cpp, hamming_distance.cpp, caesar_cipher.cpp, elliptic_curve_key_exchange.cpp, morse_code.cpp, vigenere_cipher.cpp, xor_cipher.cpp, list_array.cpp, reverse_a_linked_list.cpp, sparse_table.cpp, trie_tree.cpp, trie_using_hashmap.cpp, karatsuba_algorithm_for_fast_multiplication.cpp, 0_1_knapsack.cpp, abbreviation.cpp, coin_change_topdown.cpp, cut_rod.cpp, house_robber.cpp, longest_increasing_subsequence.cpp, longest_palindromic_subsequence.cpp, minimum_edit_distance.cpp, palindrome_partitioning.cpp, shortest_common_supersequence.cpp, word_break.cpp, jarvis_algorithm.cpp, connected_components_with_dsu.cpp, is_graph_bipartite.cpp, jumpgame.cpp, md5.cpp, sha1.cpp, gram_schmidt.cpp, neural_network.cpp, armstrong_number.cpp, check_amicable_pair.cpp, double_factorial.cpp, fibonacci.cpp, fibonacci_matrix_exponentiation.cpp, fibonacci_sum.cpp, finding_number_of_digits_in_a_number.cpp, inv_sqrt.cpp, largest_power.cpp, lcm_sum.cpp, modular_division.cpp, modular_exponentiation.cpp, n_bonacci.cpp, n_choose_r.cpp, sum_of_binomial_coefficient.cpp, sum_of_digits.cpp, vector_cross_product.cpp, rungekutta.cpp, inorder_successor_of_bst.cpp, trie_multiple_search.cpp, kadanes3.cpp, smallest_circle.cpp, geometric_dist.cpp, windowed_median.cpp, persistent_seg_tree_lazy_prop.cpp, prefix_sum_array.cpp, floyd_cycle_detection_algo.cpp, median_search.cpp, saddleback_search.cpp, sublist_search.cpp, text_search.cpp, bogo_sort.cpp, count_inversions.cpp, cycle_sort.cpp, dnf_sort.cpp, gnome_sort.cpp, heap_sort.cpp, merge_insertion_sort.cpp, pancake_sort.cpp, random_pivot_quick_sort.cpp, recursive_bubble_sort.cpp, selection_sort_recursive.cpp, strand_sort.cpp, wave_sort.cpp, wiggle_sort.cpp, horspool.cpp, manacher_algorithm.cpp, z_function.cpp
+- test() : rat_maze.cpp, subarray_sum.cpp, subset_sum.cpp, wildcard_matching.cpp, count_of_set_bits.cpp, count_of_trailing_ciphers_in_factorial_n.cpp, hamming_distance.cpp, caesar_cipher.cpp, elliptic_curve_key_exchange.cpp, morse_code.cpp, vigenere_cipher.cpp, xor_cipher.cpp, fcfs_scheduling.cpp, list_array.cpp, reverse_a_linked_list.cpp, sparse_table.cpp, trie_tree.cpp, trie_using_hashmap.cpp, karatsuba_algorithm_for_fast_multiplication.cpp, 0_1_knapsack.cpp, abbreviation.cpp, coin_change_topdown.cpp, cut_rod.cpp, house_robber.cpp, longest_increasing_subsequence.cpp, longest_palindromic_subsequence.cpp, minimum_edit_distance.cpp, palindrome_partitioning.cpp, shortest_common_supersequence.cpp, word_break.cpp, jarvis_algorithm.cpp, connected_components_with_dsu.cpp, is_graph_bipartite.cpp, jumpgame.cpp, md5.cpp, sha1.cpp, gram_schmidt.cpp, neural_network.cpp, armstrong_number.cpp, check_amicable_pair.cpp, double_factorial.cpp, fibonacci.cpp, fibonacci_matrix_exponentiation.cpp, fibonacci_sum.cpp, finding_number_of_digits_in_a_number.cpp, inv_sqrt.cpp, largest_power.cpp, lcm_sum.cpp, modular_division.cpp, modular_exponentiation.cpp, n_bonacci.cpp, n_choose_r.cpp, sum_of_binomial_coefficient.cpp, sum_of_digits.cpp, vector_cross_product.cpp, rungekutta.cpp, inorder_successor_of_bst.cpp, trie_multiple_search.cpp, kadanes3.cpp, smallest_circle.cpp, geometric_dist.cpp, windowed_median.cpp, persistent_seg_tree_lazy_prop.cpp, prefix_sum_array.cpp, floyd_cycle_detection_algo.cpp, median_search.cpp, saddleback_search.cpp, sublist_search.cpp, text_search.cpp, bogo_sort.cpp, count_inversions.cpp, cycle_sort.cpp, dnf_sort.cpp, gnome_sort.cpp, heap_sort.cpp, merge_insertion_sort.cpp, pancake_sort.cpp, random_pivot_quick_sort.cpp, recursive_bubble_sort.cpp, selection_sort_recursive.cpp, strand_sort.cpp, wave_sort.cpp, wiggle_sort.cpp, horspool.cpp, manacher_algorithm.cpp, z_function.cpp
- test1() : hill_cipher.cpp, tree_234.cpp, hamiltons_cycle.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, large_factorial.cpp, sum_of_digits.cpp, brent_method_extrema.cpp, durand_kerner_roots.cpp, golden_search_extrema.cpp, lu_decompose.cpp, qr_eigen_values.cpp, iterative_tree_traversals.cpp
- test2() : hill_cipher.cpp, tree_234.cpp, hamiltons_cycle.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, large_factorial.cpp, sum_of_digits.cpp, brent_method_extrema.cpp, durand_kerner_roots.cpp, golden_search_extrema.cpp, lu_decompose.cpp, qr_eigen_values.cpp, iterative_tree_traversals.cpp, smallest_circle.cpp
- test3() : hamiltons_cycle.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, brent_method_extrema.cpp, golden_search_extrema.cpp, iterative_tree_traversals.cpp, smallest_circle.cpp
diff --git a/globals_g.html b/globals_g.html
index 3ac0c9f47..5ba25513f 100644
--- a/globals_g.html
+++ b/globals_g.html
@@ -96,6 +96,7 @@ $(document).ready(function(){initNavTree('globals_g.html',''); initResizable();
- gcd() : gcd_iterative_euclidean.cpp, gcd_of_n_numbers.cpp, gcd_recursive_euclidean.cpp, least_common_multiple.cpp
- genArray() : spiral_print.cpp
- get_clock_diff() : kohonen_som_topology.cpp, kohonen_som_trace.cpp
+- get_final_status() : fcfs_scheduling.cpp
- get_input() : ternary_search.cpp
- get_inverse() : ordinary_least_squares_regressor.cpp
- get_min_2d() : kohonen_som_topology.cpp
diff --git a/globals_i.html b/globals_i.html
index b5d750823..d3d28f433 100644
--- a/globals_i.html
+++ b/globals_i.html
@@ -105,9 +105,9 @@ $(document).ready(function(){initNavTree('globals_i.html',''); initResizable();
- is_happy() : happy_number.cpp
- is_prime() : check_prime.cpp
- is_square() : ordinary_least_squares_regressor.cpp
-- isprime : prime_factorization.cpp
-- isPrime() : modular_inverse_fermat_little_theorem.cpp
- IsPrime() : primality_test.cpp
+- isPrime() : modular_inverse_fermat_little_theorem.cpp
+- isprime : prime_factorization.cpp
- it_ternary_search() : ternary_search.cpp
diff --git a/globals_m.html b/globals_m.html
index 535edf2d6..20a5e3871 100644
--- a/globals_m.html
+++ b/globals_m.html
@@ -93,7 +93,7 @@ $(document).ready(function(){initNavTree('globals_m.html',''); initResizable();
Here is a list of all documented file members with links to the documentation:
- m -
-- main() : graph_coloring.cpp, knight_tour.cpp, minimax.cpp, n_queens.cpp, n_queens_all_solution_optimised.cpp, nqueen_print_all_solutions.cpp, rat_maze.cpp, subarray_sum.cpp, subset_sum.cpp, sudoku_solve.cpp, wildcard_matching.cpp, count_of_set_bits.cpp, count_of_trailing_ciphers_in_factorial_n.cpp, hamming_distance.cpp, caesar_cipher.cpp, elliptic_curve_key_exchange.cpp, hill_cipher.cpp, morse_code.cpp, vigenere_cipher.cpp, xor_cipher.cpp, avltree.cpp, disjoint_set.cpp, linked_list.cpp, linkedlist_implentation_usingarray.cpp, list_array.cpp, queue_using_array.cpp, queue_using_two_stacks.cpp, reverse_a_linked_list.cpp, skip_list.cpp, sparse_table.cpp, tree_234.cpp, trie_modern.cpp, trie_tree.cpp, trie_using_hashmap.cpp, karatsuba_algorithm_for_fast_multiplication.cpp, 0_1_knapsack.cpp, abbreviation.cpp, coin_change_topdown.cpp, cut_rod.cpp, house_robber.cpp, kadane2.cpp, longest_increasing_subsequence.cpp, longest_palindromic_subsequence.cpp, minimum_edit_distance.cpp, palindrome_partitioning.cpp, shortest_common_supersequence.cpp, word_break.cpp, jarvis_algorithm.cpp, line_segment_intersection.cpp, bidirectional_dijkstra.cpp, breadth_first_search.cpp, connected_components.cpp, connected_components_with_dsu.cpp, depth_first_search.cpp, depth_first_search_with_stack.cpp, dijkstra.cpp, hamiltons_cycle.cpp, hopcroft_karp.cpp, is_graph_bipartite.cpp, lowest_common_ancestor.cpp, travelling_salesman_problem.cpp, spirograph.cpp, jumpgame.cpp, chaining.cpp, double_hash_hash_table.cpp, linear_probing_hash_table.cpp, md5.cpp, quadratic_probing_hash_table.cpp, sha1.cpp, gram_schmidt.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, neural_network.cpp, ordinary_least_squares_regressor.cpp, armstrong_number.cpp, binary_exponent.cpp, binomial_calculate.cpp, check_amicable_pair.cpp, check_factorial.cpp, check_prime.cpp, complex_numbers.cpp, double_factorial.cpp, eulers_totient_function.cpp, extended_euclid_algorithm.cpp, factorial.cpp, fast_power.cpp, fibonacci.cpp, fibonacci_fast.cpp, fibonacci_matrix_exponentiation.cpp, fibonacci_sum.cpp, finding_number_of_digits_in_a_number.cpp, gcd_iterative_euclidean.cpp, gcd_of_n_numbers.cpp, gcd_recursive_euclidean.cpp, integral_approximation.cpp, inv_sqrt.cpp, large_factorial.cpp, largest_power.cpp, lcm_sum.cpp, least_common_multiple.cpp, magic_number.cpp, miller_rabin.cpp, modular_division.cpp, modular_exponentiation.cpp, modular_inverse_fermat_little_theorem.cpp, n_bonacci.cpp, n_choose_r.cpp, ncr_modulo_p.cpp, number_of_positive_divisors.cpp, power_for_huge_numbers.cpp, power_of_two.cpp, prime_factorization.cpp, prime_numbers.cpp, primes_up_to_billion.cpp, realtime_stats.cpp, sieve_of_eratosthenes.cpp, sqrt_double.cpp, string_fibonacci.cpp, sum_of_binomial_coefficient.cpp, sum_of_digits.cpp, vector_cross_product.cpp, bisection_method.cpp, brent_method_extrema.cpp, false_position.cpp, gaussian_elimination.cpp, golden_search_extrema.cpp, lu_decompose.cpp, newton_raphson_method.cpp, ode_forward_euler.cpp, ode_midpoint_euler.cpp, ode_semi_implicit_euler.cpp, qr_decomposition.cpp, qr_eigen_values.cpp, rungekutta.cpp, successive_approximation.cpp, inorder_successor_of_bst.cpp, trie_multiple_search.cpp, buzz_number.cpp, decimal_to_hexadecimal.cpp, decimal_to_roman_numeral.cpp, fast_integer_input.cpp, happy_number.cpp, iterative_tree_traversals.cpp, kadanes3.cpp, lru_cache.cpp, matrix_exponentiation.cpp, palindrome_of_number.cpp, pascal_triangle.cpp, postfix_evaluation.cpp, primality_test.cpp, smallest_circle.cpp, sparse_matrix.cpp, spiral_print.cpp, stairs_pattern.cpp, tower_of_hanoi.cpp, vector_important_functions.cpp, addition_rule.cpp, bayes_theorem.cpp, binomial_dist.cpp, geometric_dist.cpp, poisson_dist.cpp, windowed_median.cpp, fenwick_tree.cpp, heavy_light_decomposition.cpp, persistent_seg_tree_lazy_prop.cpp, prefix_sum_array.cpp, sparse_table.cpp, binary_search.cpp, exponential_search.cpp, fibonacci_search.cpp, floyd_cycle_detection_algo.cpp, hash_search.cpp, interpolation_search.cpp, interpolation_search2.cpp, linear_search.cpp, median_search.cpp, saddleback_search.cpp, sublist_search.cpp, ternary_search.cpp, text_search.cpp, bogo_sort.cpp, comb_sort.cpp, count_inversions.cpp, cycle_sort.cpp, dnf_sort.cpp, gnome_sort.cpp, heap_sort.cpp, insertion_sort.cpp, merge_insertion_sort.cpp, merge_sort.cpp, pancake_sort.cpp, pigeonhole_sort.cpp, quick_sort.cpp, quick_sort_3.cpp, radix_sort2.cpp, random_pivot_quick_sort.cpp, recursive_bubble_sort.cpp, selection_sort_recursive.cpp, shell_sort2.cpp, strand_sort.cpp, wave_sort.cpp, brute_force_string_searching.cpp, horspool.cpp, knuth_morris_pratt.cpp, manacher_algorithm.cpp, rabin_karp.cpp, z_function.cpp
+- main() : graph_coloring.cpp, knight_tour.cpp, minimax.cpp, n_queens.cpp, n_queens_all_solution_optimised.cpp, nqueen_print_all_solutions.cpp, rat_maze.cpp, subarray_sum.cpp, subset_sum.cpp, sudoku_solve.cpp, wildcard_matching.cpp, count_of_set_bits.cpp, count_of_trailing_ciphers_in_factorial_n.cpp, hamming_distance.cpp, caesar_cipher.cpp, elliptic_curve_key_exchange.cpp, hill_cipher.cpp, morse_code.cpp, vigenere_cipher.cpp, xor_cipher.cpp, fcfs_scheduling.cpp, avltree.cpp, disjoint_set.cpp, linked_list.cpp, linkedlist_implentation_usingarray.cpp, list_array.cpp, queue_using_array.cpp, queue_using_two_stacks.cpp, reverse_a_linked_list.cpp, skip_list.cpp, sparse_table.cpp, tree_234.cpp, trie_modern.cpp, trie_tree.cpp, trie_using_hashmap.cpp, karatsuba_algorithm_for_fast_multiplication.cpp, 0_1_knapsack.cpp, abbreviation.cpp, coin_change_topdown.cpp, cut_rod.cpp, house_robber.cpp, kadane2.cpp, longest_increasing_subsequence.cpp, longest_palindromic_subsequence.cpp, minimum_edit_distance.cpp, palindrome_partitioning.cpp, shortest_common_supersequence.cpp, word_break.cpp, jarvis_algorithm.cpp, line_segment_intersection.cpp, bidirectional_dijkstra.cpp, breadth_first_search.cpp, connected_components.cpp, connected_components_with_dsu.cpp, depth_first_search.cpp, depth_first_search_with_stack.cpp, dijkstra.cpp, hamiltons_cycle.cpp, hopcroft_karp.cpp, is_graph_bipartite.cpp, lowest_common_ancestor.cpp, travelling_salesman_problem.cpp, spirograph.cpp, jumpgame.cpp, chaining.cpp, double_hash_hash_table.cpp, linear_probing_hash_table.cpp, md5.cpp, quadratic_probing_hash_table.cpp, sha1.cpp, gram_schmidt.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, neural_network.cpp, ordinary_least_squares_regressor.cpp, armstrong_number.cpp, binary_exponent.cpp, binomial_calculate.cpp, check_amicable_pair.cpp, check_factorial.cpp, check_prime.cpp, complex_numbers.cpp, double_factorial.cpp, eulers_totient_function.cpp, extended_euclid_algorithm.cpp, factorial.cpp, fast_power.cpp, fibonacci.cpp, fibonacci_fast.cpp, fibonacci_matrix_exponentiation.cpp, fibonacci_sum.cpp, finding_number_of_digits_in_a_number.cpp, gcd_iterative_euclidean.cpp, gcd_of_n_numbers.cpp, gcd_recursive_euclidean.cpp, integral_approximation.cpp, inv_sqrt.cpp, large_factorial.cpp, largest_power.cpp, lcm_sum.cpp, least_common_multiple.cpp, magic_number.cpp, miller_rabin.cpp, modular_division.cpp, modular_exponentiation.cpp, modular_inverse_fermat_little_theorem.cpp, n_bonacci.cpp, n_choose_r.cpp, ncr_modulo_p.cpp, number_of_positive_divisors.cpp, power_for_huge_numbers.cpp, power_of_two.cpp, prime_factorization.cpp, prime_numbers.cpp, primes_up_to_billion.cpp, realtime_stats.cpp, sieve_of_eratosthenes.cpp, sqrt_double.cpp, string_fibonacci.cpp, sum_of_binomial_coefficient.cpp, sum_of_digits.cpp, vector_cross_product.cpp, bisection_method.cpp, brent_method_extrema.cpp, false_position.cpp, gaussian_elimination.cpp, golden_search_extrema.cpp, lu_decompose.cpp, newton_raphson_method.cpp, ode_forward_euler.cpp, ode_midpoint_euler.cpp, ode_semi_implicit_euler.cpp, qr_decomposition.cpp, qr_eigen_values.cpp, rungekutta.cpp, successive_approximation.cpp, inorder_successor_of_bst.cpp, trie_multiple_search.cpp, buzz_number.cpp, decimal_to_hexadecimal.cpp, decimal_to_roman_numeral.cpp, fast_integer_input.cpp, happy_number.cpp, iterative_tree_traversals.cpp, kadanes3.cpp, lru_cache.cpp, matrix_exponentiation.cpp, palindrome_of_number.cpp, pascal_triangle.cpp, postfix_evaluation.cpp, primality_test.cpp, smallest_circle.cpp, sparse_matrix.cpp, spiral_print.cpp, stairs_pattern.cpp, tower_of_hanoi.cpp, vector_important_functions.cpp, addition_rule.cpp, bayes_theorem.cpp, binomial_dist.cpp, geometric_dist.cpp, poisson_dist.cpp, windowed_median.cpp, fenwick_tree.cpp, heavy_light_decomposition.cpp, persistent_seg_tree_lazy_prop.cpp, prefix_sum_array.cpp, sparse_table.cpp, binary_search.cpp, exponential_search.cpp, fibonacci_search.cpp, floyd_cycle_detection_algo.cpp, hash_search.cpp, interpolation_search.cpp, interpolation_search2.cpp, linear_search.cpp, median_search.cpp, saddleback_search.cpp, sublist_search.cpp, ternary_search.cpp, text_search.cpp, bogo_sort.cpp, comb_sort.cpp, count_inversions.cpp, cycle_sort.cpp, dnf_sort.cpp, gnome_sort.cpp, heap_sort.cpp, insertion_sort.cpp, merge_insertion_sort.cpp, merge_sort.cpp, pancake_sort.cpp, pigeonhole_sort.cpp, quick_sort.cpp, quick_sort_3.cpp, radix_sort2.cpp, random_pivot_quick_sort.cpp, recursive_bubble_sort.cpp, selection_sort_recursive.cpp, shell_sort2.cpp, strand_sort.cpp, wave_sort.cpp, brute_force_string_searching.cpp, horspool.cpp, knuth_morris_pratt.cpp, manacher_algorithm.cpp, rabin_karp.cpp, z_function.cpp
- mat_mul() : qr_eigen_values.cpp
- mat_size : matrix_exponentiation.cpp
- matrix : lu_decomposition.h
diff --git a/globals_p.html b/globals_p.html
index 0e47ba48a..73d842724 100644
--- a/globals_p.html
+++ b/globals_p.html
@@ -105,8 +105,8 @@ $(document).ready(function(){initNavTree('globals_p.html',''); initResizable();
- pop() : paranthesis_matching.cpp
- power() : power_for_huge_numbers.cpp, matrix_exponentiation.cpp
- predict_OLS_regressor() : ordinary_least_squares_regressor.cpp
-- prime : primes_up_to_billion.cpp
- PRIME : rabin_karp.cpp
+- prime : primes_up_to_billion.cpp
- prime_factorization() : prime_factorization.cpp
- prime_numbers : prime_factorization.cpp
- primes() : prime_numbers.cpp
diff --git a/globals_s.html b/globals_s.html
index f161f7de4..d77d8bf54 100644
--- a/globals_s.html
+++ b/globals_s.html
@@ -104,9 +104,10 @@ $(document).ready(function(){initNavTree('globals_s.html',''); initResizable();
- show_array() : bogo_sort.cpp
- show_data() : shell_sort2.cpp
- show_pascal() : pascal_triangle.cpp
-- sieve() : sieve_of_eratosthenes.cpp
- Sieve() : primes_up_to_billion.cpp
+- sieve() : sieve_of_eratosthenes.cpp
- SieveOfEratosthenes() : prime_factorization.cpp
+- sortcol() : fcfs_scheduling.cpp
- spiralPrint() : spiral_print.cpp
- Sqrt() : sqrt_double.cpp
- stack : paranthesis_matching.cpp
diff --git a/globals_t.html b/globals_t.html
index e9776bdb2..4be523508 100644
--- a/globals_t.html
+++ b/globals_t.html
@@ -94,7 +94,7 @@ $(document).ready(function(){initNavTree('globals_t.html',''); initResizable();
- t -
- ternary_search() : ternary_search.cpp
-- test() : rat_maze.cpp, subarray_sum.cpp, subset_sum.cpp, wildcard_matching.cpp, count_of_set_bits.cpp, count_of_trailing_ciphers_in_factorial_n.cpp, hamming_distance.cpp, caesar_cipher.cpp, elliptic_curve_key_exchange.cpp, morse_code.cpp, vigenere_cipher.cpp, xor_cipher.cpp, list_array.cpp, reverse_a_linked_list.cpp, sparse_table.cpp, trie_tree.cpp, trie_using_hashmap.cpp, karatsuba_algorithm_for_fast_multiplication.cpp, 0_1_knapsack.cpp, abbreviation.cpp, coin_change_topdown.cpp, cut_rod.cpp, house_robber.cpp, longest_increasing_subsequence.cpp, longest_palindromic_subsequence.cpp, minimum_edit_distance.cpp, palindrome_partitioning.cpp, shortest_common_supersequence.cpp, word_break.cpp, jarvis_algorithm.cpp, connected_components_with_dsu.cpp, is_graph_bipartite.cpp, jumpgame.cpp, md5.cpp, sha1.cpp, gram_schmidt.cpp, neural_network.cpp, armstrong_number.cpp, check_amicable_pair.cpp, double_factorial.cpp, fibonacci.cpp, fibonacci_matrix_exponentiation.cpp, fibonacci_sum.cpp, finding_number_of_digits_in_a_number.cpp, inv_sqrt.cpp, largest_power.cpp, lcm_sum.cpp, modular_division.cpp, modular_exponentiation.cpp, n_bonacci.cpp, n_choose_r.cpp, sum_of_binomial_coefficient.cpp, sum_of_digits.cpp, vector_cross_product.cpp, rungekutta.cpp, inorder_successor_of_bst.cpp, trie_multiple_search.cpp, kadanes3.cpp, smallest_circle.cpp, geometric_dist.cpp, windowed_median.cpp, persistent_seg_tree_lazy_prop.cpp, prefix_sum_array.cpp, floyd_cycle_detection_algo.cpp, median_search.cpp, saddleback_search.cpp, sublist_search.cpp, text_search.cpp, bogo_sort.cpp, count_inversions.cpp, cycle_sort.cpp, dnf_sort.cpp, gnome_sort.cpp, heap_sort.cpp, merge_insertion_sort.cpp, pancake_sort.cpp, random_pivot_quick_sort.cpp, recursive_bubble_sort.cpp, selection_sort_recursive.cpp, strand_sort.cpp, wave_sort.cpp, wiggle_sort.cpp, horspool.cpp, manacher_algorithm.cpp, z_function.cpp
+- test() : rat_maze.cpp, subarray_sum.cpp, subset_sum.cpp, wildcard_matching.cpp, count_of_set_bits.cpp, count_of_trailing_ciphers_in_factorial_n.cpp, hamming_distance.cpp, caesar_cipher.cpp, elliptic_curve_key_exchange.cpp, morse_code.cpp, vigenere_cipher.cpp, xor_cipher.cpp, fcfs_scheduling.cpp, list_array.cpp, reverse_a_linked_list.cpp, sparse_table.cpp, trie_tree.cpp, trie_using_hashmap.cpp, karatsuba_algorithm_for_fast_multiplication.cpp, 0_1_knapsack.cpp, abbreviation.cpp, coin_change_topdown.cpp, cut_rod.cpp, house_robber.cpp, longest_increasing_subsequence.cpp, longest_palindromic_subsequence.cpp, minimum_edit_distance.cpp, palindrome_partitioning.cpp, shortest_common_supersequence.cpp, word_break.cpp, jarvis_algorithm.cpp, connected_components_with_dsu.cpp, is_graph_bipartite.cpp, jumpgame.cpp, md5.cpp, sha1.cpp, gram_schmidt.cpp, neural_network.cpp, armstrong_number.cpp, check_amicable_pair.cpp, double_factorial.cpp, fibonacci.cpp, fibonacci_matrix_exponentiation.cpp, fibonacci_sum.cpp, finding_number_of_digits_in_a_number.cpp, inv_sqrt.cpp, largest_power.cpp, lcm_sum.cpp, modular_division.cpp, modular_exponentiation.cpp, n_bonacci.cpp, n_choose_r.cpp, sum_of_binomial_coefficient.cpp, sum_of_digits.cpp, vector_cross_product.cpp, rungekutta.cpp, inorder_successor_of_bst.cpp, trie_multiple_search.cpp, kadanes3.cpp, smallest_circle.cpp, geometric_dist.cpp, windowed_median.cpp, persistent_seg_tree_lazy_prop.cpp, prefix_sum_array.cpp, floyd_cycle_detection_algo.cpp, median_search.cpp, saddleback_search.cpp, sublist_search.cpp, text_search.cpp, bogo_sort.cpp, count_inversions.cpp, cycle_sort.cpp, dnf_sort.cpp, gnome_sort.cpp, heap_sort.cpp, merge_insertion_sort.cpp, pancake_sort.cpp, random_pivot_quick_sort.cpp, recursive_bubble_sort.cpp, selection_sort_recursive.cpp, strand_sort.cpp, wave_sort.cpp, wiggle_sort.cpp, horspool.cpp, manacher_algorithm.cpp, z_function.cpp
- test1() : hill_cipher.cpp, tree_234.cpp, hamiltons_cycle.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, large_factorial.cpp, sum_of_digits.cpp, brent_method_extrema.cpp, durand_kerner_roots.cpp, golden_search_extrema.cpp, lu_decompose.cpp, qr_eigen_values.cpp, iterative_tree_traversals.cpp
- test2() : hill_cipher.cpp, tree_234.cpp, hamiltons_cycle.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, large_factorial.cpp, sum_of_digits.cpp, brent_method_extrema.cpp, durand_kerner_roots.cpp, golden_search_extrema.cpp, lu_decompose.cpp, qr_eigen_values.cpp, iterative_tree_traversals.cpp, smallest_circle.cpp
- test3() : hamiltons_cycle.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, brent_method_extrema.cpp, golden_search_extrema.cpp, iterative_tree_traversals.cpp, smallest_circle.cpp
diff --git a/hierarchy.html b/hierarchy.html
index 6cdc2a251..15fb8a93a 100644
--- a/hierarchy.html
+++ b/hierarchy.html
@@ -104,92 +104,94 @@ This inheritance list is sorted roughly, but not completely, alphabetically: Cbinary_search_tree< T >::bst_node A struct to represent a node in the Binary Search Tree
CBtree Ccll Ccompare Cmachine_learning::aystar_search::AyStarSearch< Puzzle >::comparison_operator Custom comparator for open_list CComplex Class Complex to represent complex numbers as a field Cgeometry::jarvis::Convexhull CCycleCheck Cmachine_learning::neural_network::layers::DenseLayer Cdouble_linked_list CEdge Cmachine_learning::aystar_search::EightPuzzle< N > A class defining EightPuzzle/15-Puzzle game Cdouble_hashing::Entry Clinear_probing::Entry Cquadratic_probing::Entry CFenwickTree Cprobability::geometric_dist::geometric_distribution A class to model the geometric distribution CGraph ▼Cgraph::Graph< T > Cgraph::RootedTree Cgraph::is_graph_bipartite::Graph Class for representing graph as an adjacency list Chash_chain Chain class with a given modulus Cciphers::HillCipher Implementation of Hill Cipher algorithm Cgraph::HKGraph Represents Bipartite graph for Hopcroft Karp implementation Cmachine_learning::aystar_search::AyStarSearch< Puzzle >::Info Struct that handles all the information related to the current state CItem Clarge_number Cdata_structures::linked_list::link Clinkedlist Cdata_structures::linked_list::list Cdata_structures::list_array::list Structure of List with supporting methods Clist Cgraph::LowestCommonAncestor Cothers::lru_cache::LRUCache LRU cache class CMinHeap CMinHeapNode Cmst Cmath::ncr_modulo_p::NCRModuloP Class which contains all methods required for calculating nCr mod p Cmachine_learning::neural_network::NeuralNetwork Cdata_structures::linked_list::Node Cdata_structures::Node Cdata_structures::tree_234::Node 2-3-4 tree node class Cdata_structures::trie_using_hashmap::Trie::Node Struct representing a trie node CNode Cnode< Kind > Coperations_on_datastructures::inorder_traversal_of_bst::Node A Node structure representing a single node in BST Cothers::iterative_tree_traversals::Node Defines the structure of a node of the tree Crange_queries::perSegTree::Node Csearch::sublist_search::Node A Node structure representing a single link Node in a linked list Crange_queries::perSegTree Range query here is range sum, but the code can be modified to make different queries like range max or min Cciphers::elliptic_curve_key_exchange::Point Definition of struct Point Cgeometry::jarvis::Point CPoint Cquery Cqueue< Kind > CQueue Cdata_structures::queue_using_array::Queue_Array Queue_Array class containing the main data and also index of head and tail of the array CRBtree CSegmentIntersection ▼Crange_queries::heavy_light_decomposition::SG< X > Segment Tree, to store heavy chains Crange_queries::heavy_light_decomposition::HLD< X > The Heavy-Light Decomposition class Cdata_structures::SkipList CSolution Cdata_structures::sparse_table::Sparse_table Cothers::postfix_expression::Stack Creates an array to be used as stack for storing values Cstack< Type > Cstack_linkedList Cstatistics::stats_computer1< T > Cstatistics::stats_computer2< T > CTestCases Class encapsulating the necessary test cases Coperations_on_datastructures::trie_operations::Tnode Class defining the structure of trie node and containing the methods to perform operations on them Ctower ▼Crange_queries::heavy_light_decomposition::Tree< X > A Basic Tree, which supports binary lifting Crange_queries::heavy_light_decomposition::HLD< X > The Heavy-Light Decomposition class Cdata_structures::tree_234::Tree234 2-3-4 tree class Cdata_structures::trie Trie implementation for small-case English alphabets a-z Cdata_structures::trie_using_hashmap::Trie Trie class, implementation of trie using hashmap in each trie node for all the characters of char16_t(UTF-16)type with methods to insert, delete, search, start with and to recommend words based on a given prefix CTrie CTrie::TrieNode ▼Cstd::true_type [external] Cstd::is_arithmetic< uint128_t > Cstd::is_arithmetic< uint256_t > Cstd::is_integral< uint128_t > Cstd::is_integral< uint256_t > Cstd::is_unsigned< uint128_t > Cstd::is_unsigned< uint256_t > Cuint128_t Class for 128-bit unsigned integer Cuint256_t Class for 256-bit unsigned integer Cprobability::windowed_median::WindowedMedian A class to calculate the median of a leading sliding window at the back of a stream of integer values CCompare< S, T, E > Comparator class for priority queue Ccompare Cmachine_learning::aystar_search::AyStarSearch< Puzzle >::comparison_operator Custom comparator for open_list CComplex Class Complex to represent complex numbers as a field Cgeometry::jarvis::Convexhull CCycleCheck Cmachine_learning::neural_network::layers::DenseLayer Cdouble_linked_list CEdge Cmachine_learning::aystar_search::EightPuzzle< N > A class defining EightPuzzle/15-Puzzle game Cdouble_hashing::Entry Clinear_probing::Entry Cquadratic_probing::Entry CFCFS< S, T, E > Class which implements the FCFS scheduling algorithm CFenwickTree Cprobability::geometric_dist::geometric_distribution A class to model the geometric distribution CGraph ▼Cgraph::Graph< T > Cgraph::RootedTree Cgraph::is_graph_bipartite::Graph Class for representing graph as an adjacency list Chash_chain Chain class with a given modulus Cciphers::HillCipher Implementation of Hill Cipher algorithm Cgraph::HKGraph Represents Bipartite graph for Hopcroft Karp implementation Cmachine_learning::aystar_search::AyStarSearch< Puzzle >::Info Struct that handles all the information related to the current state CItem Clarge_number Cdata_structures::linked_list::link Clinkedlist Cdata_structures::linked_list::list Cdata_structures::list_array::list Structure of List with supporting methods Clist Cgraph::LowestCommonAncestor Cothers::lru_cache::LRUCache LRU cache class CMinHeap CMinHeapNode Cmst Cmath::ncr_modulo_p::NCRModuloP Class which contains all methods required for calculating nCr mod p Cmachine_learning::neural_network::NeuralNetwork Cdata_structures::linked_list::Node Cdata_structures::Node Cdata_structures::tree_234::Node 2-3-4 tree node class Cdata_structures::trie_using_hashmap::Trie::Node Struct representing a trie node CNode Cnode< Kind > Coperations_on_datastructures::inorder_traversal_of_bst::Node A Node structure representing a single node in BST Cothers::iterative_tree_traversals::Node Defines the structure of a node of the tree Crange_queries::perSegTree::Node Csearch::sublist_search::Node A Node structure representing a single link Node in a linked list Crange_queries::perSegTree Range query here is range sum, but the code can be modified to make different queries like range max or min Cciphers::elliptic_curve_key_exchange::Point Definition of struct Point Cgeometry::jarvis::Point CPoint Cquery Cqueue< Kind > CQueue Cdata_structures::queue_using_array::Queue_Array Queue_Array class containing the main data and also index of head and tail of the array CRBtree CSegmentIntersection ▼Crange_queries::heavy_light_decomposition::SG< X > Segment Tree, to store heavy chains Crange_queries::heavy_light_decomposition::HLD< X > The Heavy-Light Decomposition class Cdata_structures::SkipList CSolution Cdata_structures::sparse_table::Sparse_table Cothers::postfix_expression::Stack Creates an array to be used as stack for storing values Cstack< Type > Cstack_linkedList Cstatistics::stats_computer1< T > Cstatistics::stats_computer2< T > CTestCases Class encapsulating the necessary test cases Coperations_on_datastructures::trie_operations::Tnode Class defining the structure of trie node and containing the methods to perform operations on them Ctower ▼Crange_queries::heavy_light_decomposition::Tree< X > A Basic Tree, which supports binary lifting Crange_queries::heavy_light_decomposition::HLD< X > The Heavy-Light Decomposition class Cdata_structures::tree_234::Tree234 2-3-4 tree class Cdata_structures::trie Trie implementation for small-case English alphabets a-z Cdata_structures::trie_using_hashmap::Trie Trie class, implementation of trie using hashmap in each trie node for all the characters of char16_t(UTF-16)type with methods to insert, delete, search, start with and to recommend words based on a given prefix CTrie CTrie::TrieNode ▼Cstd::true_type [external] Cstd::is_arithmetic< uint128_t > Cstd::is_arithmetic< uint256_t > Cstd::is_integral< uint128_t > Cstd::is_integral< uint256_t > Cstd::is_unsigned< uint128_t > Cstd::is_unsigned< uint256_t > Cuint128_t Class for 128-bit unsigned integer Cuint256_t Class for 256-bit unsigned integer Cprobability::windowed_median::WindowedMedian A class to calculate the median of a leading sliding window at the back of a stream of integer values
diff --git a/hierarchy.js b/hierarchy.js
index cc5d4c317..d62633ce2 100644
--- a/hierarchy.js
+++ b/hierarchy.js
@@ -7,6 +7,7 @@ var hierarchy =
[ "binary_search_tree< T >::bst_node", "dd/db6/structbinary__search__tree_1_1bst__node.html", null ],
[ "Btree", "d9/d90/struct_btree.html", null ],
[ "cll", "d5/d15/classcll.html", null ],
+ [ "Compare< S, T, E >", "de/d4a/class_compare.html", null ],
[ "compare", "d1/db3/structcompare.html", null ],
[ "machine_learning::aystar_search::AyStarSearch< Puzzle >::comparison_operator", "d3/d2a/structmachine__learning_1_1aystar__search_1_1_ay_star_search_1_1comparison__operator.html", null ],
[ "Complex", "da/d5a/class_complex.html", null ],
@@ -19,6 +20,7 @@ var hierarchy =
[ "double_hashing::Entry", "d9/dde/structdouble__hashing_1_1_entry.html", null ],
[ "linear_probing::Entry", "db/d19/structlinear__probing_1_1_entry.html", null ],
[ "quadratic_probing::Entry", "da/dd1/structquadratic__probing_1_1_entry.html", null ],
+ [ "FCFS< S, T, E >", "dd/dca/class_f_c_f_s.html", null ],
[ "FenwickTree", "dd/d91/class_fenwick_tree.html", null ],
[ "probability::geometric_dist::geometric_distribution", "da/d19/classprobability_1_1geometric__dist_1_1geometric__distribution.html", null ],
[ "Graph", "da/d9a/class_graph.html", null ],
diff --git a/index.html b/index.html
index 9b5825758..538225e93 100644
--- a/index.html
+++ b/index.html
@@ -95,10 +95,10 @@ $(document).ready(function(){initNavTree('index.html',''); initResizable(); });
-
+
Overview
This repository is a collection of open-source implementation of a variety of algorithms implemented in C++ and licensed under MIT License. These algorithms span a variety of topics from computer science, mathematics and statistics, data science, machine learning, engineering, etc.. The implementations and the associated documentation are meant to provide a learning resource for educators and students. Hence, one may find more than one implementation for the same objective but using a different algorithm strategies and optimizations.
-
+
Features
- The repository provides implementations of various algorithms in one of the most fundamental general purpose languages - C++.
@@ -109,12 +109,12 @@ Features
- Self-checks within programs ensure correct implementations with confidence.
- Modular implementations and OpenSource licensing enable the functions to be utilized conveniently in other applications.
-
+
Documentation
Online Documentation is generated from the repository source codes directly. The documentation contains all resources including source code snippets, details on execution of the programs, diagrammatic representation of program flow, and links to external resources where necessary. The documentation also introduces interactive source code with links to documentation for C++ STL library functions used. Click on Files menu to see the list of all the files documented with the code.
Documentation of Algorithms in C++ by The Algorithms Contributors is licensed under CC BY-SA 4.0
-
+
Contributions
As a community developed and maintained repository, we welcome new un-plagiarized quality contributions. Please read our Contribution Guidelines.
diff --git a/inherit_graph_10.map b/inherit_graph_10.map
index 32a286108..e3ea338d1 100644
--- a/inherit_graph_10.map
+++ b/inherit_graph_10.map
@@ -1,3 +1,3 @@
diff --git a/inherit_graph_10.md5 b/inherit_graph_10.md5
index 679531e7b..7bca58621 100644
--- a/inherit_graph_10.md5
+++ b/inherit_graph_10.md5
@@ -1 +1 @@
-5eb287a2fb56ae0e7e71100d4f42a21c
\ No newline at end of file
+5320309e3bffbba4f4360758b1ad97f4
\ No newline at end of file
diff --git a/inherit_graph_10.svg b/inherit_graph_10.svg
index 66bb71fe6..4ad91dbea 100644
--- a/inherit_graph_10.svg
+++ b/inherit_graph_10.svg
@@ -12,10 +12,10 @@
Node0
-
+
data_structures::linked
-_list::list
+_list::link
diff --git a/inherit_graph_11.map b/inherit_graph_11.map
index 7d4ec9a8d..32a286108 100644
--- a/inherit_graph_11.map
+++ b/inherit_graph_11.map
@@ -1,3 +1,3 @@
diff --git a/inherit_graph_11.md5 b/inherit_graph_11.md5
index c563a0c98..679531e7b 100644
--- a/inherit_graph_11.md5
+++ b/inherit_graph_11.md5
@@ -1 +1 @@
-d57400eb9de671d3442759337d4a98a7
\ No newline at end of file
+5eb287a2fb56ae0e7e71100d4f42a21c
\ No newline at end of file
diff --git a/inherit_graph_11.svg b/inherit_graph_11.svg
index 5e4880e22..66bb71fe6 100644
--- a/inherit_graph_11.svg
+++ b/inherit_graph_11.svg
@@ -12,10 +12,10 @@
Node0
-
+
data_structures::linked
-_list::Node
+_list::list
diff --git a/inherit_graph_12.map b/inherit_graph_12.map
index 087a17e54..7d4ec9a8d 100644
--- a/inherit_graph_12.map
+++ b/inherit_graph_12.map
@@ -1,3 +1,3 @@
diff --git a/inherit_graph_12.md5 b/inherit_graph_12.md5
index fed441c74..c563a0c98 100644
--- a/inherit_graph_12.md5
+++ b/inherit_graph_12.md5
@@ -1 +1 @@
-8b10ed21001ae43ebb02b0fc74f2c517
\ No newline at end of file
+d57400eb9de671d3442759337d4a98a7
\ No newline at end of file
diff --git a/inherit_graph_12.svg b/inherit_graph_12.svg
index 62e00425f..5e4880e22 100644
--- a/inherit_graph_12.svg
+++ b/inherit_graph_12.svg
@@ -4,18 +4,18 @@
-
Detailed Description
An implementation of LRU Cache. Lru is a part of cache algorithms (also frequently called cache replacement algorithms or cache replacement policies).
-
+
Logic
- Discards the least recently used items first.
@@ -158,7 +158,7 @@ Logic
+
Algorithm explanation
For a cache of page frame x:
- Check if the page is present in cache. @@ -170,7 +170,7 @@ Algorithm explanation
Every time a requested page is not found in cache, that is a miss or page fault, and if the page is present in cache, then its a hit.
-
+
Data Structure used
- In the algorithm below we used two different data structure, one is linked list and other one is a hash map
diff --git a/d3/df9/recursive__bubble__sort_8cpp.html b/d3/df9/recursive__bubble__sort_8cpp.html
index aad58ffd2..63443ee72 100644
--- a/d3/df9/recursive__bubble__sort_8cpp.html
+++ b/d3/df9/recursive__bubble__sort_8cpp.html
@@ -135,7 +135,7 @@ Functions
The working principle of the Bubble sort algorithm.
Bubble sort is a simple sorting algorithm used to rearrange a set of ascending or descending order elements. Bubble sort gets its name from the fact that data "bubbles" to the top of the dataset.
-
+
Algorithm
What is Swap?
Swapping two numbers means that we interchange their values. Often, an additional variable is required for this operation. This is further illustrated in the following:
diff --git a/d4/d2f/fcfs__scheduling_8cpp__incl.map b/d4/d2f/fcfs__scheduling_8cpp__incl.map new file mode 100644 index 000000000..3158f721e --- /dev/null +++ b/d4/d2f/fcfs__scheduling_8cpp__incl.map @@ -0,0 +1,12 @@ + diff --git a/d4/d2f/fcfs__scheduling_8cpp__incl.md5 b/d4/d2f/fcfs__scheduling_8cpp__incl.md5 new file mode 100644 index 000000000..6853309e3 --- /dev/null +++ b/d4/d2f/fcfs__scheduling_8cpp__incl.md5 @@ -0,0 +1 @@ +0324174599ed13b0486f31d316384e99 \ No newline at end of file diff --git a/d4/d2f/fcfs__scheduling_8cpp__incl.svg b/d4/d2f/fcfs__scheduling_8cpp__incl.svg new file mode 100644 index 000000000..2f013e6d9 --- /dev/null +++ b/d4/d2f/fcfs__scheduling_8cpp__incl.svg @@ -0,0 +1,246 @@ + + + + + + diff --git a/d4/d2f/fcfs__scheduling_8cpp__incl_org.svg b/d4/d2f/fcfs__scheduling_8cpp__incl_org.svg new file mode 100644 index 000000000..bd2095678 --- /dev/null +++ b/d4/d2f/fcfs__scheduling_8cpp__incl_org.svg @@ -0,0 +1,158 @@ + + + + + diff --git a/d4/d32/inorder__successor__of__bst_8cpp.html b/d4/d32/inorder__successor__of__bst_8cpp.html index 55ca6c210..187d5bead 100644 --- a/d4/d32/inorder__successor__of__bst_8cpp.html +++ b/d4/d32/inorder__successor__of__bst_8cpp.html @@ -163,21 +163,21 @@ FunctionsDetailed Description
An implementation for finding the Inorder successor of a binary search tree Inorder successor of a node is the next node in Inorder traversal of the Binary Tree. Inorder Successor is NULL for the last node in Inorder traversal.
-
+
Case 1: The given node has the right node/subtree
* In this case, the left-most deepest node in the right subtree will
come just after the given node as we go to left deep in inorder.
- Go deep to left most node in right subtree. OR, we can also say in case if BST, find the minimum of the subtree for a given node.
+
Case 2: The given node does not have a right node/subtree
-
+
Method 1: Use parent pointer (store the address of parent nodes)
- If a node does not have the right subtree, and we already visited the node itself, then the next node will be its parent node according to inorder traversal, and if we are going to parent from left, then the parent would be unvisited.
- In other words, go to the nearest ancestor for which given node would be in left subtree.
-
+
Method 2: Search from the root node
- In case if there is no link from a child node to the parent node, we need to walk down the tree starting from the root node to the given node, by doing so, we are visiting every ancestor of the given node.
diff --git a/d4/d38/power__of__two_8cpp.html b/d4/d38/power__of__two_8cpp.html
index 2c3ca0248..7ee5b99a4 100644
--- a/d4/d38/power__of__two_8cpp.html
+++ b/d4/d38/power__of__two_8cpp.html
@@ -125,7 +125,7 @@ Functions
Detailed Description
Implementation to check whether a number is a power of 2 or not.
This algorithm uses bit manipulation to check if a number is a power of 2 or not.
-
+
Algorithm
Let the input number be n, then the bitwise and between n and n-1 will let us know whether the number is power of 2 or not
For Example, If N= 32 then N-1 is 31, if we perform bitwise and of these two numbers then the result will be zero, which indicates that it is the power of 2 If N=23 then N-1 is 22, if we perform bitwise and of these two numbers then the result will not be zero , which indicates that it is not the power of 2
- Note
- This implementation is better than naive recursive or iterative approach.
diff --git a/d4/d8d/jarvis__algorithm_8cpp.html b/d4/d8d/jarvis__algorithm_8cpp.html
index 9f186b043..2ea246476 100644
--- a/d4/d8d/jarvis__algorithm_8cpp.html
+++ b/d4/d8d/jarvis__algorithm_8cpp.html
@@ -136,7 +136,7 @@ Functions
Detailed Description
Implementation of Jarvis’s algorithm.
Given a set of points in the plane. the convex hull of the set is the smallest convex polygon that contains all the points of it.
-
+
Algorithm
The idea of Jarvis’s Algorithm is simple, we start from the leftmost point (or point with minimum x coordinate value) and we keep wrapping points in counterclockwise direction.
The idea is to use orientation() here. Next point is selected as the point that beats all other points at counterclockwise orientation, i.e., next point is q if for any other point r, we have “orientation(p, q, r) = counterclockwise”.
diff --git a/d4/d9f/selection__sort__recursive_8cpp.html b/d4/d9f/selection__sort__recursive_8cpp.html
index 69ee52e4e..1f12431b3 100644
--- a/d4/d9f/selection__sort__recursive_8cpp.html
+++ b/d4/d9f/selection__sort__recursive_8cpp.html
@@ -139,7 +139,7 @@ Functions
Detailed Description
Implementation of the Selection sort implementation using recursion.
The selection sort algorithm divides the input list into two parts: a sorted sublist of items which is built up from left to right at the front (left) of the list, and a sublist of the remaining unsorted items that occupy the rest of the list. Initially, the sorted sublist is empty, and the unsorted sublist is the entire input list. The algorithm proceeds by finding the smallest (or largest, depending on the sorting order) element in the unsorted sublist, exchanging (swapping) it with the leftmost unsorted element (putting it in sorted order), and moving the sublist boundaries one element to the right.
-
+
Implementation
FindMinIndex This function finds the minimum element of the array(list) recursively by simply comparing the minimum element of array reduced size by 1 and compares it to the last element of the array to find the minimum of the whole array.
SelectionSortRecursive Just like selection sort, it divides the list into two parts (i.e.: sorted and unsorted) and finds the minimum of the unsorted array. By calling the FindMinIndex function, it swaps the minimum element with the first element of the list, and then solves recursively for the remaining unsorted list.
diff --git a/d5/d33/gram__schmidt_8cpp.html b/d5/d33/gram__schmidt_8cpp.html
index f0a7fa6e8..c5a75e2e3 100644
--- a/d5/d33/gram__schmidt_8cpp.html
+++ b/d5/d33/gram__schmidt_8cpp.html
@@ -139,7 +139,7 @@ Functions
Detailed Description
Gram Schmidt Orthogonalisation Process
Takes the input of Linearly Independent Vectors, returns vectors orthogonal to each other.
-
+
Algorithm
Take the first vector of given LI vectors as first vector of Orthogonal vectors. Take projection of second input vector on the first vector of Orthogonal vector and subtract it from the 2nd LI vector. Take projection of third vector on the second vector of Othogonal vectors and subtract it from the 3rd LI vector. Keep repeating the above process until all the vectors in the given input array are exhausted.
For Example: In R2, Input LI Vectors={(3,1),(2,2)} then Orthogonal Vectors= {(3, 1),(-0.4, 1.2)}
diff --git a/d5/d45/sublist__search_8cpp.html b/d5/d45/sublist__search_8cpp.html
index 2d629b439..201817fd1 100644
--- a/d5/d45/sublist__search_8cpp.html
+++ b/d5/d45/sublist__search_8cpp.html
@@ -148,14 +148,14 @@ Functions
Detailed Description
Implementation of the Sublist Search Algorithm
-
+
Algorithm
- Sublist search is used to detect a presence of one list in another list.
- Suppose we have a single-node list (let's say the first list), and we want to ensure that the list is present in another list (let's say the second list), then we can perform the sublist search to find it.
- For instance, the first list contains these elements: 23 -> 30 -> 41, and the second list contains these elements: 10 -> 15 -> 23 -> 30 -> 41 -> 49. At a glance, we see that the first list presents in the second list.
-
+
Working
- The sublist search algorithm works by comparing the first element of the first list with the first element of the second list.
diff --git a/d5/d88/md__d_i_r_e_c_t_o_r_y.html b/d5/d88/md__d_i_r_e_c_t_o_r_y.html
index 514ce65b3..c5af30faa 100644
--- a/d5/d88/md__d_i_r_e_c_t_o_r_y.html
+++ b/d5/d88/md__d_i_r_e_c_t_o_r_y.html
@@ -128,6 +128,11 @@ Ciphers
- Xor Cipher
+Cpu Scheduling Algorithms
+
+
Data Structures
- Avltree
@@ -169,12 +174,12 @@ Data Structures
- Trie Tree
- Trie Using Hashmap
-
+
Divide And Conquer
-
+
Dynamic Programming
- 0 1 Knapsack
@@ -205,13 +210,13 @@ Dynamic Programming
- Tree Height
- Word Break
-
+
Geometry
-
+
Graph
- Bidirectional Dijkstra
@@ -235,12 +240,12 @@ Graph
- Topological Sort By Kahns Algo
- Travelling Salesman Problem
-
+
Graphics
-
+
Greedy Algorithms
- Dijkstra
@@ -250,7 +255,7 @@ Greedy Algorithms
- Kruskals Minimum Spanning Tree
- Prims Minimum Spanning Tree
-
+
Hashing
- Chaining
@@ -260,12 +265,12 @@ Hashing
- Quadratic Probing Hash Table
- Sha1
-
+
Linear Algebra
-
+
Machine Learning
- A Star Search
@@ -276,7 +281,7 @@ Machine Learning
- Ordinary Least Squares Regressor
- Vector Ops
-
+
Math
- Armstrong Number
@@ -330,7 +335,7 @@ Math
- Sum Of Digits
- Vector Cross Product
-
+
Numerical Methods
- Bisection Method
@@ -351,7 +356,7 @@ Numerical Methods
- Rungekutta
- Successive Approximation
-
+
Operations On Datastructures
- Array Left Rotation
@@ -366,7 +371,7 @@ Operations On Datastructures
- Trie Multiple Search
- Union Of 2 Arrays
-
+
Others
- Buzz Number
@@ -391,7 +396,7 @@ Others
- Tower Of Hanoi
- Vector Important Functions
-
+
Probability
- Addition Rule
@@ -401,7 +406,7 @@ Probability
- Poisson Dist
- Windowed Median
-
+
Range Queries
- Fenwick Tree
@@ -412,7 +417,7 @@ Range Queries
- Segtree
- Sparse Table
-
+
Search
- Binary Search
@@ -430,7 +435,7 @@ Search
- Ternary Search
- Text Search
-
+
Sorting
- Bead Sort
@@ -473,7 +478,7 @@ Sorting
- Wave Sort
- Wiggle Sort
-
+
Strings
- Brute Force String Searching
diff --git a/d5/d96/md5_8cpp.html b/d5/d96/md5_8cpp.html
index fcef37251..653b5c1fe 100644
--- a/d5/d96/md5_8cpp.html
+++ b/d5/d96/md5_8cpp.html
@@ -164,7 +164,7 @@ Functions
- Store salted password
However MD5 has be know to be cryptographically weak for quite some time, yet it is still widely used. This weakness was exploited by the Flame Malware in 2012
-
+
Algorithm
First of all, all values are expected to be in little endian. This is especially important when using part of the bytestring as an integer.
The first step of the algorithm is to pad the message for its length to be a multiple of 64 (bytes). This is done by first adding 0x80 (10000000) and then only zeroes until the last 8 bytes must be filled, where then the 64 bit size of the input will be added
diff --git a/d5/ddb/bogo__sort_8cpp.html b/d5/ddb/bogo__sort_8cpp.html
index 5fca0b893..30e0a0c78 100644
--- a/d5/ddb/bogo__sort_8cpp.html
+++ b/d5/ddb/bogo__sort_8cpp.html
@@ -135,7 +135,7 @@ Functions
Detailed Description
Implementation of Bogosort algorithm
In computer science, bogosort (also known as permutation sort, stupid sort, slowsort, shotgun sort, random sort, monkey sort, bobosort or shuffle sort) is a highly inefficient sorting algorithm based on the generate and test paradigm. Two versions of this algorithm exist: a deterministic version that enumerates all permutations until it hits a sorted one, and a randomized version that randomly permutes its input.Randomized version is implemented here.
-
+
Algorithm
Shuffle the array untill array is sorted.
diff --git a/d6/d10/cut__rod_8cpp.html b/d6/d10/cut__rod_8cpp.html
index 5da32cc73..e6dad50c4 100644
--- a/d6/d10/cut__rod_8cpp.html
+++ b/d6/d10/cut__rod_8cpp.html
@@ -135,7 +135,7 @@ Functions
Detailed Description
Implementation of cutting a rod problem.
Given a rod of length n inches and an array of prices that contains prices of all pieces of size<=n. Determine the maximum profit obtainable by cutting up the rod and selling the pieces.
-
+
Algorithm
The idea is to break the given rod into every smaller piece as possible and then check profit for each piece, by calculating maximum profit for smaller pieces we will build the solution for larger pieces in bottom-up manner.
- Capitalize zero or more of
a's lowercase letters.
- Delete all of the remaining lowercase letters in
a.
-
+
Algorithm
The idea is in the problem statement itself: iterate through characters of string a and b (for character indexes i and j respectively):
- If
a[i] and b[j] are equal, then move to next position
diff --git a/d8/d7a/sha1_8cpp.html b/d8/d7a/sha1_8cpp.html
index 011c7725c..4a75469bc 100644
--- a/d8/d7a/sha1_8cpp.html
+++ b/d8/d7a/sha1_8cpp.html
@@ -150,7 +150,7 @@ Functions
Simple C++ implementation of the SHA-1 Hashing Algorithm
SHA-1 is a cryptographic hash function that was developped by the NSA 1995. SHA-1 is not considered secure since around 2010.
-
+
Algorithm
The first step of the algorithm is to pad the message for its length to be a multiple of 64 (bytes). This is done by first adding 0x80 (10000000) and then only zeroes until the last 8 bytes must be filled, where then the 64 bit size of the input will be added
Once this is done, the algo breaks down this padded message into 64 bytes chunks. Each chunk is used for one round, a round breaks the chunk into 16 blocks of 4 bytes. These 16 blocks are then extended to 80 blocks using XOR operations on existing blocks (see code for more details). The algorithm will then update its 160-bit state (here represented used 5 32-bits integer) using partial hashes computed using special functions on the blocks previously built. Please take a look at the wikipedia article for more precision on these operations
- Note
- This is a simple implementation for a byte string but some implmenetations can work on bytestream, messages of unknown length.
diff --git a/d8/d90/iterative__tree__traversals_8cpp.html b/d8/d90/iterative__tree__traversals_8cpp.html
index 73ac4c543..3efdda89b 100644
--- a/d8/d90/iterative__tree__traversals_8cpp.html
+++ b/d8/d90/iterative__tree__traversals_8cpp.html
@@ -157,13 +157,13 @@ Functions
Detailed Description
Iterative version of Preorder, Postorder, and preorder Traversal of the Tree
-
+
Iterative Preorder Traversal of a tree
Create a Stack that will store the Node of Tree. Push the root node into the stack. Save the root into the variabe named as current, and pop and elemnt from the stack. Store the data of current into the result array, and start traversing from it. Push both the child node of the current node into the stack, first right child then left child. Repeat the same set of steps untill the Stack becomes empty. And return the result array as the preorder traversal of a tree.
-
+
Iterative Postorder Traversal of a tree
Create a Stack that will store the Node of Tree. Push the root node into the stack. Save the root into the variabe named as current, and pop and elemnt from the stack. Store the data of current into the result array, and start traversing from it. Push both the child node of the current node into the stack, first left child then right child. Repeat the same set of steps untill the Stack becomes empty. Now reverse the result array and then return it to the calling function as a postorder traversal of a tree.
-
+
Iterative Inorder Traversal of a tree
Create a Stack that will store the Node of Tree. Push the root node into the stack. Save the root into the variabe named as current. Now iterate and take the current to the extreme left of the tree by traversing only to its left. Pop the elemnt from the stack and assign it to the current. Store the data of current into the result array. Repeat the same set of steps until the Stack becomes empty or the current becomes NULL. And return the result array as the inorder traversal of a tree.
Function Documentation
diff --git a/d8/d99/connected__components__with__dsu_8cpp.html b/d8/d99/connected__components__with__dsu_8cpp.html
index 75568d7b0..ab127c3d4 100644
--- a/d8/d99/connected__components__with__dsu_8cpp.html
+++ b/d8/d99/connected__components__with__dsu_8cpp.html
@@ -155,7 +155,7 @@ uint32_t graph::disjoint_u
Detailed Description
The Disjoint union is the technique to find connected component in graph efficiently.
-
+
Algorithm
In Graph, if you have to find out the number of connected components, there are 2 options
- Depth first search
diff --git a/d8/dc8/class_compare-members.html b/d8/dc8/class_compare-members.html
new file mode 100644
index 000000000..84ead1ecc
--- /dev/null
+++ b/d8/dc8/class_compare-members.html
@@ -0,0 +1,109 @@
+
+
+
+
+
+
+
+Algorithms_in_C++: Member List
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Algorithms_in_C++ 1.0.0
+
+ Set of algorithms implemented in C++.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Compare< S, T, E > Member List
+
+
+
+This is the complete list of members for Compare< S, T, E >, including all inherited members.
+
+ operator()(tuple< S, T, E, double, double, double > &t1, tuple< S, T, E, double, double, double > &t2) Compare< S, T, E > inline
+
+
+
+
+ - Generated by 1.9.2
+
+
+
+
diff --git a/d9/dfd/comb__sort_8cpp.html b/d9/dfd/comb__sort_8cpp.html
index 871becef3..117c91753 100644
--- a/d9/dfd/comb__sort_8cpp.html
+++ b/d9/dfd/comb__sort_8cpp.html
@@ -172,7 +172,7 @@ Functions
Initialize swapped as true to make sure that loop runs
Keep running until gap = 1 or none elements were swapped
Find next gap
-Compare all elements with current gap
+Compare all elements with current gap
diff --git a/da/d52/minimum__edit__distance_8cpp.html b/da/d52/minimum__edit__distance_8cpp.html
index 3567f6cd6..624a0f246 100644
--- a/da/d52/minimum__edit__distance_8cpp.html
+++ b/da/d52/minimum__edit__distance_8cpp.html
@@ -136,7 +136,7 @@ Functions
Detailed Description
Implementation of Minimum Edit Distance using Dynamic Programing.
Given two strings str1 & str2 and we have to calculate the minimum number of operations (Insert, Remove, Replace) required to convert str1 to str2.
-
+
Algorithm
We will solve this problem using Naive recursion. But as we are approaching with a DP solution. So, we will take a DP array to store the solution of all sub-problems so that we don't have to perform recursion again and again. Now to solve the problem, We can traverse all characters from either right side of the strings or left side. Suppose we will do it from the right side. So, there are two possibilities for every pair of characters being traversed.
- If the last characters of two strings are the same, Ignore the characters and get the count for the remaining string. So, we get the solution for lengths m-1 and n-1 in a DP array.
diff --git a/db/d16/0__1__knapsack_8cpp.html b/db/d16/0__1__knapsack_8cpp.html
index 433c48500..cfcf6167c 100644
--- a/db/d16/0__1__knapsack_8cpp.html
+++ b/db/d16/0__1__knapsack_8cpp.html
@@ -135,7 +135,7 @@ Functions
Detailed Description
Implementation of 0-1 Knapsack Problem
Given weights and values of n items, put these items in a knapsack of capacity W to get the maximum total value in the knapsack. In other words, given two integer arrays val[0..n-1] and wt[0..n-1] which represent values and weights associated with n items respectively. Also given an integer W which represents knapsack capacity, find out the maximum value subset of val[] such that sum of the weights of this subset is smaller than or equal to W. You cannot break an item, either pick the complete item or don’t pick it (0-1 property)
-
+
Algorithm
The idea is to consider all subsets of items and calculate the total weight and value of all subsets. Consider the only subsets whose total weight is smaller than W. From all such subsets, pick the maximum value subset.
- Author
- Anmol
diff --git a/db/dca/kadane2_8cpp.html b/db/dca/kadane2_8cpp.html
index 35dd96829..1dbb15c18 100644
--- a/db/dca/kadane2_8cpp.html
+++ b/db/dca/kadane2_8cpp.html
@@ -131,7 +131,7 @@ Functions
Detailed Description
Implementation of Kadane Algorithm
Kadane algorithm is used to find the maximum sum subarray in an array and maximum sum subarray problem is the task of finding a contiguous subarray with the largest sum
-
+
Algorithm
The simple idea of the algorithm is to search for all positive contiguous segments of the array and keep track of maximum sum contiguous segment among all positive segments(curr_sum is used for this) Each time we get a positive sum we compare it with max_sum and update max_sum if it is greater than curr_sum
diff --git a/dd/d47/namespacemath.html b/dd/d47/namespacemath.html
index c23f2ccf6..1d04b6d46 100644
--- a/dd/d47/namespacemath.html
+++ b/dd/d47/namespacemath.html
@@ -145,7 +145,7 @@ Functions
Mathematical algorithms
Given a recurrence relation; evaluate the value of nth term. For e.g., For fibonacci series, recurrence series is f(n) = f(n-1) + f(n-2) where f(0) = 0 and f(1) = 1. Note that the method used only demonstrates recurrence relation with one variable (n), unlike nCr problem, since it has two (n, r)
-
+
Algorithm
This problem can be solved using matrix exponentiation method.
- See also
- here for simple number exponentiation algorithm or explaination here.
diff --git a/dd/dca/class_f_c_f_s.html b/dd/dca/class_f_c_f_s.html
new file mode 100644
index 000000000..cc5a819ff
--- /dev/null
+++ b/dd/dca/class_f_c_f_s.html
@@ -0,0 +1,376 @@
+
+
+
+
+
+
+
+Algorithms_in_C++: FCFS< S, T, E > Class Template Reference
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Algorithms_in_C++ 1.0.0
+
+ Set of algorithms implemented in C++.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ FCFS< S, T, E > Class Template Reference
+
+
+
+Class which implements the FCFS scheduling algorithm.
+ More...
+
+
+Public Member Functions
void addProcess (S id, T arrival, E burst) Adds the process to the ready queue if it isn't already there. More...
vector< tuple< S, T, E, double, double, double > > scheduleForFcfs () Algorithm for scheduling CPU processes according to the First Come First Serve(FCFS) scheduling algorithm. More...
void printResult () Utility function for printing the status of each process after execution. More...
+
+Private Attributes
priority_queue< tuple< S, T, E, double, double, double >, vector< tuple< S, T, E, double, double, double > >, Compare< S, T, E > > schedule
+vector< tuple< S, T, E, double, double, double > > result
+unordered_set< S > idList
+Detailed Description
+template<typename S, typename T, typename E>
+class FCFS< S, T, E >Class which implements the FCFS scheduling algorithm.
+- Template Parameters
-
+
+ S Data type of Process ID T Data type of Arrival time E Data type of Burst time
+
+
+Member Function Documentation
+
+◆ addProcess()
+
+
+
+
+template<typename S , typename T , typename E >
+
+
+
+
+
+ void FCFS< S, T, E >::addProcess
+ (
+ S
+ id,
+
+
+ T
+ arrival,
+
+
+ E
+ burst
+
+
+ )
+
+
+
+
+inline
+
+
+
+
+Adds the process to the ready queue if it isn't already there.
+- Parameters
-
+
+ id Process ID arrival Arrival time of the process burst Burst time of the process
+
+
+- Returns
- void
+
+
+
+
+
+
+
+
+
+priority_queue< tuple< S, T, E, double, double, double >, vector< tuple< S, T, E, double, double, double > >, Compare< S, T, E > > scheduleDefinition: fcfs_scheduling.cpp:111
+T make_tuple(T... args)
+
+
+Here is the call graph for this function:
+
+
+
+
+
+
+
+
+◆ printResult()
+
+
+
+
+template<typename S , typename T , typename E >
+
+
+
+
+
+ void FCFS< S, T, E >::printResult
+ (
+ )
+
+
+
+
+inline
+
+
+
+
+Utility function for printing the status of each process after execution.
+- Returns
- void
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+T fixed(T... args)
+T left(T... args)
+
+T setprecision(T... args)
+T setw(T... args)
+
+Here is the call graph for this function:
+
+
+
+
+
+
+
+
+◆ scheduleForFcfs()
+
+
+
+
+template<typename S , typename T , typename E >
+
+
+
+
+
+ vector< tuple< S, T, E, double, double, double > > FCFS< S, T, E >::scheduleForFcfs
+ (
+ )
+
+
+
+
+inline
+
+
+
+
+Algorithm for scheduling CPU processes according to the First Come First Serve(FCFS) scheduling algorithm.
+FCFS is a non-preemptive algorithm in which the process which arrives first gets executed first. If two or more processes arrive together then the process with smaller process ID runs first (each process has a unique proces ID).
+I used a min priority queue of tuples to accomplish this task. The processes are ordered by their arrival times. If arrival times of some processes are equal, then they are ordered by their process ID.
+- Returns
- void
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Member Data Documentation
+
+◆ schedule
+
+
+
+
+template<typename S , typename T , typename E >
+
+
+
+
+
+ priority_queue<tuple<S, T, E, double, double, double>, vector<tuple<S, T, E, double, double, double> >, Compare<S, T, E> > FCFS< S, T, E >::schedule
+
+
+
+
+private
+
+
+
+Priority queue of schedules(stored as tuples) of processes. In each tuple 1st element: Process ID 2nd element: Arrival Time 3rd element: Burst time 4th element: Completion time 5th element: Turnaround time 6th element: Waiting time
+
+
+
+
The documentation for this class was generated from the following file:
+- cpu_scheduling_algorithms/fcfs_scheduling.cpp
+
+
+
+
+
+
+
+ - Generated by 1.9.2
+
+
+
+
diff --git a/dd/dca/class_f_c_f_s.js b/dd/dca/class_f_c_f_s.js
new file mode 100644
index 000000000..3c4ded1da
--- /dev/null
+++ b/dd/dca/class_f_c_f_s.js
@@ -0,0 +1,7 @@
+var class_f_c_f_s =
+[
+ [ "addProcess", "dd/dca/class_f_c_f_s.html#a8fbfe4d85f7576b4a7aade07d29fbd69", null ],
+ [ "printResult", "dd/dca/class_f_c_f_s.html#abb361a612b18bb189aa6d3c49288b793", null ],
+ [ "scheduleForFcfs", "dd/dca/class_f_c_f_s.html#aa25dbe30ba9930b5a7c1a6d11758bd91", null ],
+ [ "schedule", "dd/dca/class_f_c_f_s.html#af2594e22a867b308e027623940193d46", null ]
+];
\ No newline at end of file
diff --git a/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.map b/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.map
new file mode 100644
index 000000000..5ff1060ab
--- /dev/null
+++ b/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.map
@@ -0,0 +1,6 @@
+
diff --git a/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.md5 b/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.md5
new file mode 100644
index 000000000..f960e4771
--- /dev/null
+++ b/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.md5
@@ -0,0 +1 @@
+40be8724cd3544d6f4f7db4d23d50120
\ No newline at end of file
diff --git a/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.svg b/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.svg
new file mode 100644
index 000000000..4e2da5e1f
--- /dev/null
+++ b/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.svg
@@ -0,0 +1,69 @@
+
+
+
+
+
diff --git a/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.map b/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.map
new file mode 100644
index 000000000..bf9103337
--- /dev/null
+++ b/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.map
@@ -0,0 +1,6 @@
+
diff --git a/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.md5 b/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.md5
new file mode 100644
index 000000000..da9dbaf40
--- /dev/null
+++ b/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.md5
@@ -0,0 +1 @@
+fbc7b8c39328fdeb00baa02dadb94ca6
\ No newline at end of file
diff --git a/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.svg b/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.svg
new file mode 100644
index 000000000..e611a5eb6
--- /dev/null
+++ b/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.svg
@@ -0,0 +1,67 @@
+
+
+
+
+
diff --git a/de/d4a/class_compare.html b/de/d4a/class_compare.html
new file mode 100644
index 000000000..3bea0dd03
--- /dev/null
+++ b/de/d4a/class_compare.html
@@ -0,0 +1,195 @@
+
+
+
+
+
+
+
+Algorithms_in_C++: Compare< S, T, E > Class Template Reference
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Algorithms_in_C++ 1.0.0
+
+ Set of algorithms implemented in C++.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Compare< S, T, E > Class Template Reference
+
+
+
+Comparator class for priority queue.
+ More...
+
+
+Public Member Functions
bool operator() (tuple< S, T, E, double, double, double > &t1, tuple< S, T, E, double, double, double > &t2) A comparator function that checks whether to swap the two tuples or not. to https://www.geeksforgeeks.org/comparator-class-in-c-with-examples/ for detailed description of comparator. More...
+Detailed Description
+template<typename S, typename T, typename E>
+class Compare< S, T, E >Comparator class for priority queue.
+- Template Parameters
-
+
+ S Data type of Process ID T Data type of Arrival time E Data type of Burst time
+
+
+Member Function Documentation
+
+◆ operator()()
+
+
+
+
+template<typename S , typename T , typename E >
+
+
+
+
+
+ bool Compare< S, T, E >::operator()
+ (
+ tuple< S, T, E, double, double, double > &
+ t1,
+
+
+ tuple< S, T, E, double, double, double > &
+ t2
+
+
+ )
+
+
+
+
+inline
+
+
+
+
+A comparator function that checks whether to swap the two tuples or not. to https://www.geeksforgeeks.org/comparator-class-in-c-with-examples/ for detailed description of comparator.
+- Parameters
-
+
+ t1 First tuple t2 Second tuple
+
+
+- Returns
- true if the tuples SHOULD be swapped
+-
+false if the tuples SHOULDN'T be swapped
+
+
+
+
The documentation for this class was generated from the following file:
+- cpu_scheduling_algorithms/fcfs_scheduling.cpp
+
+
+
+
+
+
+
+ - Generated by 1.9.2
+
+
+
+
diff --git a/de/d4a/class_compare.js b/de/d4a/class_compare.js
new file mode 100644
index 000000000..f123aff03
--- /dev/null
+++ b/de/d4a/class_compare.js
@@ -0,0 +1,4 @@
+var class_compare =
+[
+ [ "operator()", "de/d4a/class_compare.html#afbdf9a44adb49728dc704155d7d1570c", null ]
+];
\ No newline at end of file
diff --git a/de/d8d/class_f_c_f_s-members.html b/de/d8d/class_f_c_f_s-members.html
new file mode 100644
index 000000000..5afa21c6c
--- /dev/null
+++ b/de/d8d/class_f_c_f_s-members.html
@@ -0,0 +1,114 @@
+
+
+
+
+
+
+
+Algorithms_in_C++: Member List
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Algorithms_in_C++ 1.0.0
+
+ Set of algorithms implemented in C++.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ FCFS< S, T, E > Member List
+
+
+
+This is the complete list of members for FCFS< S, T, E >, including all inherited members.
+
+ addProcess(S id, T arrival, E burst) FCFS< S, T, E > inline idList (defined in FCFS< S, T, E >) FCFS< S, T, E > private printResult() FCFS< S, T, E > inline result (defined in FCFS< S, T, E >) FCFS< S, T, E > private schedule FCFS< S, T, E > private scheduleForFcfs() FCFS< S, T, E > inline
+
+
+
+
+ - Generated by 1.9.2
+
+
+
+
diff --git a/df/d47/fcfs__scheduling_8cpp.html b/df/d47/fcfs__scheduling_8cpp.html
new file mode 100644
index 000000000..298493c7c
--- /dev/null
+++ b/df/d47/fcfs__scheduling_8cpp.html
@@ -0,0 +1,376 @@
+
+
+
+
+
+
+
+Algorithms_in_C++: cpu_scheduling_algorithms/fcfs_scheduling.cpp File Reference
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Algorithms_in_C++ 1.0.0
+
+ Set of algorithms implemented in C++.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Implementation of FCFS CPU scheduling algorithm.
+More...
+#include <algorithm>
+#include <cassert>
+#include <cstdlib>
+#include <ctime>
+#include <iomanip>
+#include <iostream>
+#include <queue>
+#include <unordered_set>
+#include <vector>
+
+Include dependency graph for fcfs_scheduling.cpp:
+
+
+
+
+
+
+Classes
class Compare< S, T, E > Comparator class for priority queue. More...
class FCFS< S, T, E > Class which implements the FCFS scheduling algorithm. More...
+
+Functions
template<typename S , typename T , typename E > bool sortcol (tuple< S, T, E > &t1, tuple< S, T, E > &t2) Comparator function for sorting a vector. More...
template<typename S , typename T , typename E > vector< tuple< S, T, E, double, double, double > > get_final_status (vector< tuple< uint32_t, uint32_t, uint32_t > > input) Function to be used for testing purposes. This function guarantees the correct solution for FCFS scheduling algorithm. More...
static void test () Self-test implementations. More...
int main () Entry point of the program. More...
+Detailed Description
+Implementation of FCFS CPU scheduling algorithm.
+FCFS is a non-preemptive CPU scheduling algorithm in which whichever process arrives first, gets executed first. If two or more processes arrive simultaneously, the process with smaller process ID gets executed first. https://bit.ly/3ABNXOCPratyush Vatsa
+Function Documentation
+
+◆ get_final_status()
+
+
+
+
+template<typename S , typename T , typename E >
+
+
+ vector< tuple< S, T, E, double, double, double > > get_final_status
+ (
+ vector< tuple< uint32_t, uint32_t, uint32_t > >
+ input )
+
+
+
+
+Function to be used for testing purposes. This function guarantees the correct solution for FCFS scheduling algorithm.
+- Parameters
-
+
+ input the input data
+
+
+Sorts the input vector according to arrival time. Processes whose arrival times are same get sorted according to process ID For each process, completion time, turnaround time and completion time are calculated, inserted in a tuple, which is added to the vector result.
- Returns
- A vector of tuples consisting of process ID, arrival time, burst time, completion time, turnaround time and waiting time for each process.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+T begin(T... args)
+T end(T... args)
+
+T size(T... args)
+T sort(T... args)
+
+
+
+
+
+◆ main()
+
+
+
+
+
+ int main
+ (
+ void
+ )
+
+
+
+
+
+◆ sortcol()
+
+
+
+
+template<typename S , typename T , typename E >
+
+
+ bool sortcol
+ (
+ tuple< S, T, E > &
+ t1,
+
+
+ tuple< S, T, E > &
+ t2
+
+
+ )
+
+
+
+
+Comparator function for sorting a vector.
+- Template Parameters
-
+
+ S Data type of Process ID T Data type of Arrival time E Data type of Burst time
+
+
+- Parameters
-
+
+ t1 First tuple t2 Second tuple
+
+
+- Returns
- true if t1 and t2 are in the CORRECT order
+-
+false if t1 and t2 are in the INCORRECT order
+
+
+
+
+◆ test()
+
+
+
+
+
+
+
+
+ static void test
+ (
+ )
+
+
+
+
+static
+
+
+
+
+Self-test implementations.
+- Returns
- void
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+void addProcess(S id, T arrival, E burst)Adds the process to the ready queue if it isn't already there.Definition: fcfs_scheduling.cpp:129
+vector< tuple< S, T, E, double, double, double > > scheduleForFcfs()Algorithm for scheduling CPU processes according to the First Come First Serve(FCFS) scheduling algor...Definition: fcfs_scheduling.cpp:154
+
+T rand(T... args)
+T srand(T... args)
+T time(T... args)
+
+Here is the call graph for this function:
+
+
+
+
+
+
+
+
+
+
+
+
+
+ - Generated by 1.9.2
+
+
+
+
diff --git a/df/d47/fcfs__scheduling_8cpp.js b/df/d47/fcfs__scheduling_8cpp.js
new file mode 100644
index 000000000..3ab097c7e
--- /dev/null
+++ b/df/d47/fcfs__scheduling_8cpp.js
@@ -0,0 +1,9 @@
+var fcfs__scheduling_8cpp =
+[
+ [ "Compare< S, T, E >", "de/d4a/class_compare.html", "de/d4a/class_compare" ],
+ [ "FCFS< S, T, E >", "dd/dca/class_f_c_f_s.html", "dd/dca/class_f_c_f_s" ],
+ [ "get_final_status", "df/d47/fcfs__scheduling_8cpp.html#a8f2b90cb64d63a7080965e66a05ccf86", null ],
+ [ "main", "df/d47/fcfs__scheduling_8cpp.html#ae66f6b31b5ad750f1fe042a706a4e3d4", null ],
+ [ "sortcol", "df/d47/fcfs__scheduling_8cpp.html#a18920aa331faf4476b251c8cdb2c2bec", null ],
+ [ "test", "df/d47/fcfs__scheduling_8cpp.html#aa8dca7b867074164d5f45b0f3851269d", null ]
+];
\ No newline at end of file
diff --git a/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.map b/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.map
new file mode 100644
index 000000000..fac5223b9
--- /dev/null
+++ b/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.map
@@ -0,0 +1,8 @@
+
diff --git a/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.md5 b/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.md5
new file mode 100644
index 000000000..60334c7c9
--- /dev/null
+++ b/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.md5
@@ -0,0 +1 @@
+eb25f61bb3c01f732953e7b177f935be
\ No newline at end of file
diff --git a/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.svg b/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.svg
new file mode 100644
index 000000000..861a9adf2
--- /dev/null
+++ b/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.svg
@@ -0,0 +1,99 @@
+
+
+
+
+
diff --git a/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.map b/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.map
new file mode 100644
index 000000000..ae5ce9e63
--- /dev/null
+++ b/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.map
@@ -0,0 +1,9 @@
+
diff --git a/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.md5 b/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.md5
new file mode 100644
index 000000000..ad9c7536b
--- /dev/null
+++ b/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.md5
@@ -0,0 +1 @@
+d1153ad5effebcdd01be2ae30d68c8af
\ No newline at end of file
diff --git a/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.svg b/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.svg
new file mode 100644
index 000000000..d4ff69629
--- /dev/null
+++ b/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.svg
@@ -0,0 +1,114 @@
+
+
+
+
+
diff --git a/df/d66/vector__cross__product_8cpp.html b/df/d66/vector__cross__product_8cpp.html
index 71f0fb3b7..cc70bdf6c 100644
--- a/df/d66/vector__cross__product_8cpp.html
+++ b/df/d66/vector__cross__product_8cpp.html
@@ -144,7 +144,7 @@ Functions
The direction ratios (DR) are calculated as follows: 1st DR, J: (b * z) - (c * y) 2nd DR, A: -((a * z) - (c * x)) 3rd DR, N: (a * y) - (b * x)
Therefore, the direction ratios of the cross product are: J, A, N The following C++ Program calculates the direction ratios of the cross products of two vector. The program uses a function, cross() for doing so. The direction ratios for the first and the second vector has to be passed one by one seperated by a space character.
Magnitude of a vector is the square root of the sum of the squares of the direction ratios.
-
+
Example:
An example of a running instance of the executable program:
Pass the first Vector: 1 2 3
Pass the second Vector: 4 5 6 The cross product is: -3 6 -3 Magnitude: 7.34847
diff --git a/dir_000002_000016.html b/dir_000002_000017.html
similarity index 100%
rename from dir_000002_000016.html
rename to dir_000002_000017.html
diff --git a/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.map b/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.map
index 623879934..72fef3963 100644
--- a/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.map
+++ b/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.map
@@ -1,5 +1,5 @@
diff --git a/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.md5 b/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.md5
index 5fd2b3301..257e4dba0 100644
--- a/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.md5
+++ b/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.md5
@@ -1 +1 @@
-92fa4d7ae23a16161aeff73e457c6e1f
\ No newline at end of file
+76e5d78bae3066db57a72fde536d8c2e
\ No newline at end of file
diff --git a/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.svg b/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.svg
index d7d51943b..7af541bfb 100644
--- a/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.svg
+++ b/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.svg
@@ -32,7 +32,7 @@
dir_4d6e05837bf820fb089a8a8cdf2f42b7->dir_9c6faab82c22511b50177aa2e38e2780
+
1
diff --git a/dir_cc8e79ed9d2b7756c78e8d0c87c6c0c7.html b/dir_cc8e79ed9d2b7756c78e8d0c87c6c0c7.html
new file mode 100644
index 000000000..7068e3381
--- /dev/null
+++ b/dir_cc8e79ed9d2b7756c78e8d0c87c6c0c7.html
@@ -0,0 +1,113 @@
+
+
+
+
+
+
+
+Algorithms_in_C++: cpu_scheduling_algorithms Directory Reference
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Algorithms_in_C++ 1.0.0
+
+ Set of algorithms implemented in C++.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ cpu_scheduling_algorithms Directory Reference
+
+
+
+
+Files
file fcfs_scheduling.cpp Implementation of FCFS CPU scheduling algorithm.
+
+
+
+
+
+
+ - Generated by 1.9.2
+
+
+
+
diff --git a/dir_cc8e79ed9d2b7756c78e8d0c87c6c0c7.js b/dir_cc8e79ed9d2b7756c78e8d0c87c6c0c7.js
new file mode 100644
index 000000000..804b70f89
--- /dev/null
+++ b/dir_cc8e79ed9d2b7756c78e8d0c87c6c0c7.js
@@ -0,0 +1,4 @@
+var dir_cc8e79ed9d2b7756c78e8d0c87c6c0c7 =
+[
+ [ "fcfs_scheduling.cpp", "df/d47/fcfs__scheduling_8cpp.html", "df/d47/fcfs__scheduling_8cpp" ]
+];
\ No newline at end of file
diff --git a/files.html b/files.html
index d3fdd7b77..6eaa50aa5 100644
--- a/files.html
+++ b/files.html
@@ -121,232 +121,234 @@ solve-a-rat-in-a-maze-c-java-pytho/"
- ► data_structures ► divide_and_conquer ► dynamic_programming ► geometry ► graph ► graphics ► greedy_algorithms ► hashing ► linear_algebra ► machine_learning ► math ► numerical_methods ► operations_on_datastructures ► others ► probability ► range_queries ► search ► sorting ► strings ► cpu_scheduling_algorithms ► data_structures ► divide_and_conquer ► dynamic_programming ► geometry ► graph ► graphics ► greedy_algorithms ► hashing ► linear_algebra ► machine_learning ► math ► numerical_methods ► operations_on_datastructures ► others ► probability ► range_queries ► search ► sorting ► strings
diff --git a/files_dup.js b/files_dup.js
index 927c6694b..685144116 100644
--- a/files_dup.js
+++ b/files_dup.js
@@ -3,6 +3,7 @@ var files_dup =
[ "backtracking", "dir_c11585dfcef32a26e29098facab6c144.html", "dir_c11585dfcef32a26e29098facab6c144" ],
[ "bit_manipulation", "dir_f3c4fbc4e901afa0a54d0623c5574aa7.html", "dir_f3c4fbc4e901afa0a54d0623c5574aa7" ],
[ "ciphers", "dir_4d6e05837bf820fb089a8a8cdf2f42b7.html", "dir_4d6e05837bf820fb089a8a8cdf2f42b7" ],
+ [ "cpu_scheduling_algorithms", "dir_cc8e79ed9d2b7756c78e8d0c87c6c0c7.html", "dir_cc8e79ed9d2b7756c78e8d0c87c6c0c7" ],
[ "data_structures", "dir_2e746e9d06bf2d8ff842208bcc6ebcfc.html", "dir_2e746e9d06bf2d8ff842208bcc6ebcfc" ],
[ "divide_and_conquer", "dir_93bc990c5cceb745f78af6949e9ef947.html", "dir_93bc990c5cceb745f78af6949e9ef947" ],
[ "dynamic_programming", "dir_8a20dd5bfd5341a725342bf72b6b686f.html", "dir_8a20dd5bfd5341a725342bf72b6b686f" ],
diff --git a/functions_a.html b/functions_a.html
index b6c1b9164..56bd8eb2f 100644
--- a/functions_a.html
+++ b/functions_a.html
@@ -103,6 +103,7 @@ $(document).ready(function(){initNavTree('functions_a.html',''); initResizable()
- add_digit() : large_number
- add_edge() : graph::Graph< T >, range_queries::heavy_light_decomposition::Tree< X >
- addEdge() : Graph, graph::HKGraph, graph::is_graph_bipartite::Graph
+- addProcess() : FCFS< S, T, E >
- addVertices() : Graph
- adj : graph::HKGraph, graph::is_graph_bipartite::Graph
- adjacency_list : graph::Graph< T >
diff --git a/functions_func_a.html b/functions_func_a.html
index 895b8d7b2..ce7a6fe56 100644
--- a/functions_func_a.html
+++ b/functions_func_a.html
@@ -101,6 +101,7 @@ $(document).ready(function(){initNavTree('functions_func_a.html',''); initResiza
- add_digit() : large_number
- add_edge() : graph::Graph< T >, range_queries::heavy_light_decomposition::Tree< X >
- addEdge() : Graph, graph::HKGraph, graph::is_graph_bipartite::Graph
+- addProcess() : FCFS< S, T, E >
- addVertices() : Graph
- arg() : Complex
- AyStarSearch() : machine_learning::aystar_search::AyStarSearch< Puzzle >
diff --git a/functions_func_i.html b/functions_func_i.html
index f6c10499c..b46256971 100644
--- a/functions_func_i.html
+++ b/functions_func_i.html
@@ -99,7 +99,7 @@ $(document).ready(function(){initNavTree('functions_func_i.html',''); initResiza
- init() : range_queries::heavy_light_decomposition::HLD< X >, range_queries::heavy_light_decomposition::Tree< X >
- inOrderIterative() : others::iterative_tree_traversals::BinaryTree
- insert() : binary_search_tree< T >, data_structures::linked_list::list, data_structures::list_array::list
-- Insert() : data_structures::tree_234::Tree234
+- Insert() : data_structures::tree_234::Tree234
- insert() : data_structures::trie, data_structures::trie_using_hashmap::Trie
- Insert() : operations_on_datastructures::trie_operations::Tnode
- insert() : probability::windowed_median::WindowedMedian, Trie
diff --git a/functions_func_o.html b/functions_func_o.html
index 2d36ddc58..524631ee8 100644
--- a/functions_func_o.html
+++ b/functions_func_o.html
@@ -105,7 +105,7 @@ $(document).ready(function(){initNavTree('functions_func_o.html',''); initResiza
- operator&() : uint128_t, uint256_t
- operator&&() : uint128_t, uint256_t
- operator&=() : uint128_t, uint256_t
-- operator()() : uint128_t, uint256_t
+- operator()() : Compare< S, T, E >, uint128_t, uint256_t
- operator*() : Complex, uint128_t, uint256_t
- operator*=() : large_number, uint128_t, uint256_t
- operator+() : Complex, uint128_t, uint256_t
diff --git a/functions_func_p.html b/functions_func_p.html
index 03847d40c..23611cdc6 100644
--- a/functions_func_p.html
+++ b/functions_func_p.html
@@ -103,6 +103,7 @@ $(document).ready(function(){initNavTree('functions_func_p.html',''); initResiza
- preOrderIterative() : others::iterative_tree_traversals::BinaryTree
- Print() : data_structures::tree_234::Tree234
- PrintNode() : data_structures::tree_234::Tree234
+- printResult() : FCFS< S, T, E >
- probability_density() : probability::geometric_dist::geometric_distribution
- push() : stack< Type >
- push_back() : data_structures::linked_list::list
diff --git a/functions_func_s.html b/functions_func_s.html
index 093c5d0f6..45a5ca001 100644
--- a/functions_func_s.html
+++ b/functions_func_s.html
@@ -94,6 +94,7 @@ $(document).ready(function(){initNavTree('functions_func_s.html',''); initResiza
- s -
- save_model() : machine_learning::neural_network::NeuralNetwork
+- scheduleForFcfs() : FCFS< S, T, E >
- search() : data_structures::linked_list::list, data_structures::trie, data_structures::trie_using_hashmap::Trie, Trie
- searchElement() : data_structures::SkipList
- SearchFreqSuggestions() : operations_on_datastructures::trie_operations::Tnode
diff --git a/functions_i.html b/functions_i.html
index 9c44e9eba..7f28ec0c7 100644
--- a/functions_i.html
+++ b/functions_i.html
@@ -99,7 +99,7 @@ $(document).ready(function(){initNavTree('functions_i.html',''); initResizable()
- init() : range_queries::heavy_light_decomposition::HLD< X >, range_queries::heavy_light_decomposition::Tree< X >
- inOrderIterative() : others::iterative_tree_traversals::BinaryTree
- insert() : binary_search_tree< T >, data_structures::linked_list::list, data_structures::list_array::list
-- Insert() : data_structures::tree_234::Tree234
+- Insert() : data_structures::tree_234::Tree234
- insert() : data_structures::trie, data_structures::trie_using_hashmap::Trie
- Insert() : operations_on_datastructures::trie_operations::Tnode
- insert() : probability::windowed_median::WindowedMedian, Trie
diff --git a/functions_o.html b/functions_o.html
index 6ac295c79..837e3e696 100644
--- a/functions_o.html
+++ b/functions_o.html
@@ -105,7 +105,7 @@ $(document).ready(function(){initNavTree('functions_o.html',''); initResizable()
- operator&() : uint128_t, uint256_t
- operator&&() : uint128_t, uint256_t
- operator&=() : uint128_t, uint256_t
-- operator()() : uint128_t, uint256_t
+- operator()() : Compare< S, T, E >, uint128_t, uint256_t
- operator*() : Complex, uint128_t, uint256_t
- operator*=() : large_number, uint128_t, uint256_t
- operator+() : Complex, large_number, uint128_t, uint256_t
diff --git a/functions_p.html b/functions_p.html
index 90430b6ff..183e64c23 100644
--- a/functions_p.html
+++ b/functions_p.html
@@ -110,6 +110,7 @@ $(document).ready(function(){initNavTree('functions_p.html',''); initResizable()
- preOrderIterative() : others::iterative_tree_traversals::BinaryTree
- Print() : data_structures::tree_234::Tree234
- PrintNode() : data_structures::tree_234::Tree234
+- printResult() : FCFS< S, T, E >
- probability_density() : probability::geometric_dist::geometric_distribution
- psucc : data_structures::linked_list::link
- ptrs : range_queries::perSegTree
diff --git a/functions_s.html b/functions_s.html
index d4dd818d0..32e7c85b4 100644
--- a/functions_s.html
+++ b/functions_s.html
@@ -96,6 +96,8 @@ $(document).ready(function(){initNavTree('functions_s.html',''); initResizable()
- s_size : range_queries::heavy_light_decomposition::SG< X >
- s_tree : range_queries::heavy_light_decomposition::SG< X >
- save_model() : machine_learning::neural_network::NeuralNetwork
+- schedule : FCFS< S, T, E >
+- scheduleForFcfs() : FCFS< S, T, E >
- search() : data_structures::linked_list::list, data_structures::trie, data_structures::trie_using_hashmap::Trie, Trie
- searchElement() : data_structures::SkipList
- SearchFreqSuggestions() : operations_on_datastructures::trie_operations::Tnode
diff --git a/functions_vars.html b/functions_vars.html
index 9752b512f..a47e938f3 100644
--- a/functions_vars.html
+++ b/functions_vars.html
@@ -217,6 +217,7 @@ $(document).ready(function(){initNavTree('functions_vars.html',''); initResizabl
- s -
- s_size : range_queries::heavy_light_decomposition::SG< X >
- s_tree : range_queries::heavy_light_decomposition::SG< X >
+- schedule : FCFS< S, T, E >
- side : graph::is_graph_bipartite::Graph
- size : stack< Type >
- size_ : binary_search_tree< T >
diff --git a/globals_func_g.html b/globals_func_g.html
index b8a49306e..dd9a8ec0e 100644
--- a/globals_func_g.html
+++ b/globals_func_g.html
@@ -96,6 +96,7 @@ $(document).ready(function(){initNavTree('globals_func_g.html',''); initResizabl
- gcd() : gcd_iterative_euclidean.cpp, gcd_of_n_numbers.cpp, gcd_recursive_euclidean.cpp, least_common_multiple.cpp
- genArray() : spiral_print.cpp
- get_clock_diff() : kohonen_som_topology.cpp, kohonen_som_trace.cpp
+- get_final_status() : fcfs_scheduling.cpp
- get_input() : ternary_search.cpp
- get_inverse() : ordinary_least_squares_regressor.cpp
- get_min_2d() : kohonen_som_topology.cpp
diff --git a/globals_func_i.html b/globals_func_i.html
index 7ce39a9c8..eaac1ff58 100644
--- a/globals_func_i.html
+++ b/globals_func_i.html
@@ -104,8 +104,8 @@ $(document).ready(function(){initNavTree('globals_func_i.html',''); initResizabl
- is_happy() : happy_number.cpp
- is_prime() : check_prime.cpp
- is_square() : ordinary_least_squares_regressor.cpp
-- isPrime() : modular_inverse_fermat_little_theorem.cpp
- IsPrime() : primality_test.cpp
+- isPrime() : modular_inverse_fermat_little_theorem.cpp
- it_ternary_search() : ternary_search.cpp
diff --git a/globals_func_m.html b/globals_func_m.html
index d58fdf390..875a674bd 100644
--- a/globals_func_m.html
+++ b/globals_func_m.html
@@ -93,7 +93,7 @@ $(document).ready(function(){initNavTree('globals_func_m.html',''); initResizabl
- m -
-- main() : graph_coloring.cpp, knight_tour.cpp, minimax.cpp, n_queens.cpp, n_queens_all_solution_optimised.cpp, nqueen_print_all_solutions.cpp, rat_maze.cpp, subarray_sum.cpp, subset_sum.cpp, sudoku_solve.cpp, wildcard_matching.cpp, count_of_set_bits.cpp, count_of_trailing_ciphers_in_factorial_n.cpp, hamming_distance.cpp, caesar_cipher.cpp, elliptic_curve_key_exchange.cpp, hill_cipher.cpp, morse_code.cpp, vigenere_cipher.cpp, xor_cipher.cpp, avltree.cpp, disjoint_set.cpp, linked_list.cpp, linkedlist_implentation_usingarray.cpp, list_array.cpp, queue_using_array.cpp, queue_using_two_stacks.cpp, reverse_a_linked_list.cpp, skip_list.cpp, sparse_table.cpp, tree_234.cpp, trie_modern.cpp, trie_tree.cpp, trie_using_hashmap.cpp, karatsuba_algorithm_for_fast_multiplication.cpp, 0_1_knapsack.cpp, abbreviation.cpp, coin_change_topdown.cpp, cut_rod.cpp, house_robber.cpp, kadane2.cpp, longest_increasing_subsequence.cpp, longest_palindromic_subsequence.cpp, minimum_edit_distance.cpp, palindrome_partitioning.cpp, shortest_common_supersequence.cpp, word_break.cpp, jarvis_algorithm.cpp, line_segment_intersection.cpp, bidirectional_dijkstra.cpp, breadth_first_search.cpp, connected_components.cpp, connected_components_with_dsu.cpp, depth_first_search.cpp, depth_first_search_with_stack.cpp, dijkstra.cpp, hamiltons_cycle.cpp, hopcroft_karp.cpp, is_graph_bipartite.cpp, lowest_common_ancestor.cpp, travelling_salesman_problem.cpp, spirograph.cpp, jumpgame.cpp, chaining.cpp, double_hash_hash_table.cpp, linear_probing_hash_table.cpp, md5.cpp, quadratic_probing_hash_table.cpp, sha1.cpp, gram_schmidt.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, neural_network.cpp, ordinary_least_squares_regressor.cpp, armstrong_number.cpp, binary_exponent.cpp, binomial_calculate.cpp, check_amicable_pair.cpp, check_factorial.cpp, check_prime.cpp, complex_numbers.cpp, double_factorial.cpp, eulers_totient_function.cpp, extended_euclid_algorithm.cpp, factorial.cpp, fast_power.cpp, fibonacci.cpp, fibonacci_fast.cpp, fibonacci_matrix_exponentiation.cpp, fibonacci_sum.cpp, finding_number_of_digits_in_a_number.cpp, gcd_iterative_euclidean.cpp, gcd_of_n_numbers.cpp, gcd_recursive_euclidean.cpp, integral_approximation.cpp, inv_sqrt.cpp, large_factorial.cpp, largest_power.cpp, lcm_sum.cpp, least_common_multiple.cpp, magic_number.cpp, miller_rabin.cpp, modular_division.cpp, modular_exponentiation.cpp, modular_inverse_fermat_little_theorem.cpp, n_bonacci.cpp, n_choose_r.cpp, ncr_modulo_p.cpp, number_of_positive_divisors.cpp, power_for_huge_numbers.cpp, power_of_two.cpp, prime_factorization.cpp, prime_numbers.cpp, primes_up_to_billion.cpp, realtime_stats.cpp, sieve_of_eratosthenes.cpp, sqrt_double.cpp, string_fibonacci.cpp, sum_of_binomial_coefficient.cpp, sum_of_digits.cpp, vector_cross_product.cpp, bisection_method.cpp, brent_method_extrema.cpp, false_position.cpp, gaussian_elimination.cpp, golden_search_extrema.cpp, lu_decompose.cpp, newton_raphson_method.cpp, ode_forward_euler.cpp, ode_midpoint_euler.cpp, ode_semi_implicit_euler.cpp, qr_decomposition.cpp, qr_eigen_values.cpp, rungekutta.cpp, successive_approximation.cpp, inorder_successor_of_bst.cpp, trie_multiple_search.cpp, buzz_number.cpp, decimal_to_hexadecimal.cpp, decimal_to_roman_numeral.cpp, fast_integer_input.cpp, happy_number.cpp, iterative_tree_traversals.cpp, kadanes3.cpp, lru_cache.cpp, matrix_exponentiation.cpp, palindrome_of_number.cpp, pascal_triangle.cpp, postfix_evaluation.cpp, primality_test.cpp, smallest_circle.cpp, sparse_matrix.cpp, spiral_print.cpp, stairs_pattern.cpp, tower_of_hanoi.cpp, vector_important_functions.cpp, addition_rule.cpp, bayes_theorem.cpp, binomial_dist.cpp, geometric_dist.cpp, poisson_dist.cpp, windowed_median.cpp, fenwick_tree.cpp, heavy_light_decomposition.cpp, persistent_seg_tree_lazy_prop.cpp, prefix_sum_array.cpp, sparse_table.cpp, binary_search.cpp, exponential_search.cpp, fibonacci_search.cpp, floyd_cycle_detection_algo.cpp, hash_search.cpp, interpolation_search.cpp, interpolation_search2.cpp, linear_search.cpp, median_search.cpp, saddleback_search.cpp, sublist_search.cpp, ternary_search.cpp, text_search.cpp, bogo_sort.cpp, comb_sort.cpp, count_inversions.cpp, cycle_sort.cpp, dnf_sort.cpp, gnome_sort.cpp, heap_sort.cpp, insertion_sort.cpp, merge_insertion_sort.cpp, merge_sort.cpp, pancake_sort.cpp, pigeonhole_sort.cpp, quick_sort.cpp, quick_sort_3.cpp, radix_sort2.cpp, random_pivot_quick_sort.cpp, recursive_bubble_sort.cpp, selection_sort_recursive.cpp, shell_sort2.cpp, strand_sort.cpp, wave_sort.cpp, brute_force_string_searching.cpp, horspool.cpp, knuth_morris_pratt.cpp, manacher_algorithm.cpp, rabin_karp.cpp, z_function.cpp
+- main() : graph_coloring.cpp, knight_tour.cpp, minimax.cpp, n_queens.cpp, n_queens_all_solution_optimised.cpp, nqueen_print_all_solutions.cpp, rat_maze.cpp, subarray_sum.cpp, subset_sum.cpp, sudoku_solve.cpp, wildcard_matching.cpp, count_of_set_bits.cpp, count_of_trailing_ciphers_in_factorial_n.cpp, hamming_distance.cpp, caesar_cipher.cpp, elliptic_curve_key_exchange.cpp, hill_cipher.cpp, morse_code.cpp, vigenere_cipher.cpp, xor_cipher.cpp, fcfs_scheduling.cpp, avltree.cpp, disjoint_set.cpp, linked_list.cpp, linkedlist_implentation_usingarray.cpp, list_array.cpp, queue_using_array.cpp, queue_using_two_stacks.cpp, reverse_a_linked_list.cpp, skip_list.cpp, sparse_table.cpp, tree_234.cpp, trie_modern.cpp, trie_tree.cpp, trie_using_hashmap.cpp, karatsuba_algorithm_for_fast_multiplication.cpp, 0_1_knapsack.cpp, abbreviation.cpp, coin_change_topdown.cpp, cut_rod.cpp, house_robber.cpp, kadane2.cpp, longest_increasing_subsequence.cpp, longest_palindromic_subsequence.cpp, minimum_edit_distance.cpp, palindrome_partitioning.cpp, shortest_common_supersequence.cpp, word_break.cpp, jarvis_algorithm.cpp, line_segment_intersection.cpp, bidirectional_dijkstra.cpp, breadth_first_search.cpp, connected_components.cpp, connected_components_with_dsu.cpp, depth_first_search.cpp, depth_first_search_with_stack.cpp, dijkstra.cpp, hamiltons_cycle.cpp, hopcroft_karp.cpp, is_graph_bipartite.cpp, lowest_common_ancestor.cpp, travelling_salesman_problem.cpp, spirograph.cpp, jumpgame.cpp, chaining.cpp, double_hash_hash_table.cpp, linear_probing_hash_table.cpp, md5.cpp, quadratic_probing_hash_table.cpp, sha1.cpp, gram_schmidt.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, neural_network.cpp, ordinary_least_squares_regressor.cpp, armstrong_number.cpp, binary_exponent.cpp, binomial_calculate.cpp, check_amicable_pair.cpp, check_factorial.cpp, check_prime.cpp, complex_numbers.cpp, double_factorial.cpp, eulers_totient_function.cpp, extended_euclid_algorithm.cpp, factorial.cpp, fast_power.cpp, fibonacci.cpp, fibonacci_fast.cpp, fibonacci_matrix_exponentiation.cpp, fibonacci_sum.cpp, finding_number_of_digits_in_a_number.cpp, gcd_iterative_euclidean.cpp, gcd_of_n_numbers.cpp, gcd_recursive_euclidean.cpp, integral_approximation.cpp, inv_sqrt.cpp, large_factorial.cpp, largest_power.cpp, lcm_sum.cpp, least_common_multiple.cpp, magic_number.cpp, miller_rabin.cpp, modular_division.cpp, modular_exponentiation.cpp, modular_inverse_fermat_little_theorem.cpp, n_bonacci.cpp, n_choose_r.cpp, ncr_modulo_p.cpp, number_of_positive_divisors.cpp, power_for_huge_numbers.cpp, power_of_two.cpp, prime_factorization.cpp, prime_numbers.cpp, primes_up_to_billion.cpp, realtime_stats.cpp, sieve_of_eratosthenes.cpp, sqrt_double.cpp, string_fibonacci.cpp, sum_of_binomial_coefficient.cpp, sum_of_digits.cpp, vector_cross_product.cpp, bisection_method.cpp, brent_method_extrema.cpp, false_position.cpp, gaussian_elimination.cpp, golden_search_extrema.cpp, lu_decompose.cpp, newton_raphson_method.cpp, ode_forward_euler.cpp, ode_midpoint_euler.cpp, ode_semi_implicit_euler.cpp, qr_decomposition.cpp, qr_eigen_values.cpp, rungekutta.cpp, successive_approximation.cpp, inorder_successor_of_bst.cpp, trie_multiple_search.cpp, buzz_number.cpp, decimal_to_hexadecimal.cpp, decimal_to_roman_numeral.cpp, fast_integer_input.cpp, happy_number.cpp, iterative_tree_traversals.cpp, kadanes3.cpp, lru_cache.cpp, matrix_exponentiation.cpp, palindrome_of_number.cpp, pascal_triangle.cpp, postfix_evaluation.cpp, primality_test.cpp, smallest_circle.cpp, sparse_matrix.cpp, spiral_print.cpp, stairs_pattern.cpp, tower_of_hanoi.cpp, vector_important_functions.cpp, addition_rule.cpp, bayes_theorem.cpp, binomial_dist.cpp, geometric_dist.cpp, poisson_dist.cpp, windowed_median.cpp, fenwick_tree.cpp, heavy_light_decomposition.cpp, persistent_seg_tree_lazy_prop.cpp, prefix_sum_array.cpp, sparse_table.cpp, binary_search.cpp, exponential_search.cpp, fibonacci_search.cpp, floyd_cycle_detection_algo.cpp, hash_search.cpp, interpolation_search.cpp, interpolation_search2.cpp, linear_search.cpp, median_search.cpp, saddleback_search.cpp, sublist_search.cpp, ternary_search.cpp, text_search.cpp, bogo_sort.cpp, comb_sort.cpp, count_inversions.cpp, cycle_sort.cpp, dnf_sort.cpp, gnome_sort.cpp, heap_sort.cpp, insertion_sort.cpp, merge_insertion_sort.cpp, merge_sort.cpp, pancake_sort.cpp, pigeonhole_sort.cpp, quick_sort.cpp, quick_sort_3.cpp, radix_sort2.cpp, random_pivot_quick_sort.cpp, recursive_bubble_sort.cpp, selection_sort_recursive.cpp, shell_sort2.cpp, strand_sort.cpp, wave_sort.cpp, brute_force_string_searching.cpp, horspool.cpp, knuth_morris_pratt.cpp, manacher_algorithm.cpp, rabin_karp.cpp, z_function.cpp
- mat_mul() : qr_eigen_values.cpp
- max_subarray_sum() : kadanes3.cpp
- merge() : merge_sort.cpp
diff --git a/globals_func_s.html b/globals_func_s.html
index a466aaaa6..660161a70 100644
--- a/globals_func_s.html
+++ b/globals_func_s.html
@@ -104,9 +104,10 @@ $(document).ready(function(){initNavTree('globals_func_s.html',''); initResizabl
- show_array() : bogo_sort.cpp
- show_data() : shell_sort2.cpp
- show_pascal() : pascal_triangle.cpp
-- sieve() : sieve_of_eratosthenes.cpp
- Sieve() : primes_up_to_billion.cpp
+- sieve() : sieve_of_eratosthenes.cpp
- SieveOfEratosthenes() : prime_factorization.cpp
+- sortcol() : fcfs_scheduling.cpp
- spiralPrint() : spiral_print.cpp
- Sqrt() : sqrt_double.cpp
- Standard_InvSqrt() : inv_sqrt.cpp
diff --git a/globals_func_t.html b/globals_func_t.html
index 71ab7f4f2..bc57baac7 100644
--- a/globals_func_t.html
+++ b/globals_func_t.html
@@ -94,7 +94,7 @@ $(document).ready(function(){initNavTree('globals_func_t.html',''); initResizabl
- t -
- ternary_search() : ternary_search.cpp
-- test() : rat_maze.cpp, subarray_sum.cpp, subset_sum.cpp, wildcard_matching.cpp, count_of_set_bits.cpp, count_of_trailing_ciphers_in_factorial_n.cpp, hamming_distance.cpp, caesar_cipher.cpp, elliptic_curve_key_exchange.cpp, morse_code.cpp, vigenere_cipher.cpp, xor_cipher.cpp, list_array.cpp, reverse_a_linked_list.cpp, sparse_table.cpp, trie_tree.cpp, trie_using_hashmap.cpp, karatsuba_algorithm_for_fast_multiplication.cpp, 0_1_knapsack.cpp, abbreviation.cpp, coin_change_topdown.cpp, cut_rod.cpp, house_robber.cpp, longest_increasing_subsequence.cpp, longest_palindromic_subsequence.cpp, minimum_edit_distance.cpp, palindrome_partitioning.cpp, shortest_common_supersequence.cpp, word_break.cpp, jarvis_algorithm.cpp, connected_components_with_dsu.cpp, is_graph_bipartite.cpp, jumpgame.cpp, md5.cpp, sha1.cpp, gram_schmidt.cpp, neural_network.cpp, armstrong_number.cpp, check_amicable_pair.cpp, double_factorial.cpp, fibonacci.cpp, fibonacci_matrix_exponentiation.cpp, fibonacci_sum.cpp, finding_number_of_digits_in_a_number.cpp, inv_sqrt.cpp, largest_power.cpp, lcm_sum.cpp, modular_division.cpp, modular_exponentiation.cpp, n_bonacci.cpp, n_choose_r.cpp, sum_of_binomial_coefficient.cpp, sum_of_digits.cpp, vector_cross_product.cpp, rungekutta.cpp, inorder_successor_of_bst.cpp, trie_multiple_search.cpp, kadanes3.cpp, smallest_circle.cpp, geometric_dist.cpp, windowed_median.cpp, persistent_seg_tree_lazy_prop.cpp, prefix_sum_array.cpp, floyd_cycle_detection_algo.cpp, median_search.cpp, saddleback_search.cpp, sublist_search.cpp, text_search.cpp, bogo_sort.cpp, count_inversions.cpp, cycle_sort.cpp, dnf_sort.cpp, gnome_sort.cpp, heap_sort.cpp, merge_insertion_sort.cpp, pancake_sort.cpp, random_pivot_quick_sort.cpp, recursive_bubble_sort.cpp, selection_sort_recursive.cpp, strand_sort.cpp, wave_sort.cpp, wiggle_sort.cpp, horspool.cpp, manacher_algorithm.cpp, z_function.cpp
+- test() : rat_maze.cpp, subarray_sum.cpp, subset_sum.cpp, wildcard_matching.cpp, count_of_set_bits.cpp, count_of_trailing_ciphers_in_factorial_n.cpp, hamming_distance.cpp, caesar_cipher.cpp, elliptic_curve_key_exchange.cpp, morse_code.cpp, vigenere_cipher.cpp, xor_cipher.cpp, fcfs_scheduling.cpp, list_array.cpp, reverse_a_linked_list.cpp, sparse_table.cpp, trie_tree.cpp, trie_using_hashmap.cpp, karatsuba_algorithm_for_fast_multiplication.cpp, 0_1_knapsack.cpp, abbreviation.cpp, coin_change_topdown.cpp, cut_rod.cpp, house_robber.cpp, longest_increasing_subsequence.cpp, longest_palindromic_subsequence.cpp, minimum_edit_distance.cpp, palindrome_partitioning.cpp, shortest_common_supersequence.cpp, word_break.cpp, jarvis_algorithm.cpp, connected_components_with_dsu.cpp, is_graph_bipartite.cpp, jumpgame.cpp, md5.cpp, sha1.cpp, gram_schmidt.cpp, neural_network.cpp, armstrong_number.cpp, check_amicable_pair.cpp, double_factorial.cpp, fibonacci.cpp, fibonacci_matrix_exponentiation.cpp, fibonacci_sum.cpp, finding_number_of_digits_in_a_number.cpp, inv_sqrt.cpp, largest_power.cpp, lcm_sum.cpp, modular_division.cpp, modular_exponentiation.cpp, n_bonacci.cpp, n_choose_r.cpp, sum_of_binomial_coefficient.cpp, sum_of_digits.cpp, vector_cross_product.cpp, rungekutta.cpp, inorder_successor_of_bst.cpp, trie_multiple_search.cpp, kadanes3.cpp, smallest_circle.cpp, geometric_dist.cpp, windowed_median.cpp, persistent_seg_tree_lazy_prop.cpp, prefix_sum_array.cpp, floyd_cycle_detection_algo.cpp, median_search.cpp, saddleback_search.cpp, sublist_search.cpp, text_search.cpp, bogo_sort.cpp, count_inversions.cpp, cycle_sort.cpp, dnf_sort.cpp, gnome_sort.cpp, heap_sort.cpp, merge_insertion_sort.cpp, pancake_sort.cpp, random_pivot_quick_sort.cpp, recursive_bubble_sort.cpp, selection_sort_recursive.cpp, strand_sort.cpp, wave_sort.cpp, wiggle_sort.cpp, horspool.cpp, manacher_algorithm.cpp, z_function.cpp
- test1() : hill_cipher.cpp, tree_234.cpp, hamiltons_cycle.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, large_factorial.cpp, sum_of_digits.cpp, brent_method_extrema.cpp, durand_kerner_roots.cpp, golden_search_extrema.cpp, lu_decompose.cpp, qr_eigen_values.cpp, iterative_tree_traversals.cpp
- test2() : hill_cipher.cpp, tree_234.cpp, hamiltons_cycle.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, large_factorial.cpp, sum_of_digits.cpp, brent_method_extrema.cpp, durand_kerner_roots.cpp, golden_search_extrema.cpp, lu_decompose.cpp, qr_eigen_values.cpp, iterative_tree_traversals.cpp, smallest_circle.cpp
- test3() : hamiltons_cycle.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, brent_method_extrema.cpp, golden_search_extrema.cpp, iterative_tree_traversals.cpp, smallest_circle.cpp
diff --git a/globals_g.html b/globals_g.html
index 3ac0c9f47..5ba25513f 100644
--- a/globals_g.html
+++ b/globals_g.html
@@ -96,6 +96,7 @@ $(document).ready(function(){initNavTree('globals_g.html',''); initResizable();
- gcd() : gcd_iterative_euclidean.cpp, gcd_of_n_numbers.cpp, gcd_recursive_euclidean.cpp, least_common_multiple.cpp
- genArray() : spiral_print.cpp
- get_clock_diff() : kohonen_som_topology.cpp, kohonen_som_trace.cpp
+- get_final_status() : fcfs_scheduling.cpp
- get_input() : ternary_search.cpp
- get_inverse() : ordinary_least_squares_regressor.cpp
- get_min_2d() : kohonen_som_topology.cpp
diff --git a/globals_i.html b/globals_i.html
index b5d750823..d3d28f433 100644
--- a/globals_i.html
+++ b/globals_i.html
@@ -105,9 +105,9 @@ $(document).ready(function(){initNavTree('globals_i.html',''); initResizable();
- is_happy() : happy_number.cpp
- is_prime() : check_prime.cpp
- is_square() : ordinary_least_squares_regressor.cpp
-- isprime : prime_factorization.cpp
-- isPrime() : modular_inverse_fermat_little_theorem.cpp
- IsPrime() : primality_test.cpp
+- isPrime() : modular_inverse_fermat_little_theorem.cpp
+- isprime : prime_factorization.cpp
- it_ternary_search() : ternary_search.cpp
diff --git a/globals_m.html b/globals_m.html
index 535edf2d6..20a5e3871 100644
--- a/globals_m.html
+++ b/globals_m.html
@@ -93,7 +93,7 @@ $(document).ready(function(){initNavTree('globals_m.html',''); initResizable();
Here is a list of all documented file members with links to the documentation:
- m -
-- main() : graph_coloring.cpp, knight_tour.cpp, minimax.cpp, n_queens.cpp, n_queens_all_solution_optimised.cpp, nqueen_print_all_solutions.cpp, rat_maze.cpp, subarray_sum.cpp, subset_sum.cpp, sudoku_solve.cpp, wildcard_matching.cpp, count_of_set_bits.cpp, count_of_trailing_ciphers_in_factorial_n.cpp, hamming_distance.cpp, caesar_cipher.cpp, elliptic_curve_key_exchange.cpp, hill_cipher.cpp, morse_code.cpp, vigenere_cipher.cpp, xor_cipher.cpp, avltree.cpp, disjoint_set.cpp, linked_list.cpp, linkedlist_implentation_usingarray.cpp, list_array.cpp, queue_using_array.cpp, queue_using_two_stacks.cpp, reverse_a_linked_list.cpp, skip_list.cpp, sparse_table.cpp, tree_234.cpp, trie_modern.cpp, trie_tree.cpp, trie_using_hashmap.cpp, karatsuba_algorithm_for_fast_multiplication.cpp, 0_1_knapsack.cpp, abbreviation.cpp, coin_change_topdown.cpp, cut_rod.cpp, house_robber.cpp, kadane2.cpp, longest_increasing_subsequence.cpp, longest_palindromic_subsequence.cpp, minimum_edit_distance.cpp, palindrome_partitioning.cpp, shortest_common_supersequence.cpp, word_break.cpp, jarvis_algorithm.cpp, line_segment_intersection.cpp, bidirectional_dijkstra.cpp, breadth_first_search.cpp, connected_components.cpp, connected_components_with_dsu.cpp, depth_first_search.cpp, depth_first_search_with_stack.cpp, dijkstra.cpp, hamiltons_cycle.cpp, hopcroft_karp.cpp, is_graph_bipartite.cpp, lowest_common_ancestor.cpp, travelling_salesman_problem.cpp, spirograph.cpp, jumpgame.cpp, chaining.cpp, double_hash_hash_table.cpp, linear_probing_hash_table.cpp, md5.cpp, quadratic_probing_hash_table.cpp, sha1.cpp, gram_schmidt.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, neural_network.cpp, ordinary_least_squares_regressor.cpp, armstrong_number.cpp, binary_exponent.cpp, binomial_calculate.cpp, check_amicable_pair.cpp, check_factorial.cpp, check_prime.cpp, complex_numbers.cpp, double_factorial.cpp, eulers_totient_function.cpp, extended_euclid_algorithm.cpp, factorial.cpp, fast_power.cpp, fibonacci.cpp, fibonacci_fast.cpp, fibonacci_matrix_exponentiation.cpp, fibonacci_sum.cpp, finding_number_of_digits_in_a_number.cpp, gcd_iterative_euclidean.cpp, gcd_of_n_numbers.cpp, gcd_recursive_euclidean.cpp, integral_approximation.cpp, inv_sqrt.cpp, large_factorial.cpp, largest_power.cpp, lcm_sum.cpp, least_common_multiple.cpp, magic_number.cpp, miller_rabin.cpp, modular_division.cpp, modular_exponentiation.cpp, modular_inverse_fermat_little_theorem.cpp, n_bonacci.cpp, n_choose_r.cpp, ncr_modulo_p.cpp, number_of_positive_divisors.cpp, power_for_huge_numbers.cpp, power_of_two.cpp, prime_factorization.cpp, prime_numbers.cpp, primes_up_to_billion.cpp, realtime_stats.cpp, sieve_of_eratosthenes.cpp, sqrt_double.cpp, string_fibonacci.cpp, sum_of_binomial_coefficient.cpp, sum_of_digits.cpp, vector_cross_product.cpp, bisection_method.cpp, brent_method_extrema.cpp, false_position.cpp, gaussian_elimination.cpp, golden_search_extrema.cpp, lu_decompose.cpp, newton_raphson_method.cpp, ode_forward_euler.cpp, ode_midpoint_euler.cpp, ode_semi_implicit_euler.cpp, qr_decomposition.cpp, qr_eigen_values.cpp, rungekutta.cpp, successive_approximation.cpp, inorder_successor_of_bst.cpp, trie_multiple_search.cpp, buzz_number.cpp, decimal_to_hexadecimal.cpp, decimal_to_roman_numeral.cpp, fast_integer_input.cpp, happy_number.cpp, iterative_tree_traversals.cpp, kadanes3.cpp, lru_cache.cpp, matrix_exponentiation.cpp, palindrome_of_number.cpp, pascal_triangle.cpp, postfix_evaluation.cpp, primality_test.cpp, smallest_circle.cpp, sparse_matrix.cpp, spiral_print.cpp, stairs_pattern.cpp, tower_of_hanoi.cpp, vector_important_functions.cpp, addition_rule.cpp, bayes_theorem.cpp, binomial_dist.cpp, geometric_dist.cpp, poisson_dist.cpp, windowed_median.cpp, fenwick_tree.cpp, heavy_light_decomposition.cpp, persistent_seg_tree_lazy_prop.cpp, prefix_sum_array.cpp, sparse_table.cpp, binary_search.cpp, exponential_search.cpp, fibonacci_search.cpp, floyd_cycle_detection_algo.cpp, hash_search.cpp, interpolation_search.cpp, interpolation_search2.cpp, linear_search.cpp, median_search.cpp, saddleback_search.cpp, sublist_search.cpp, ternary_search.cpp, text_search.cpp, bogo_sort.cpp, comb_sort.cpp, count_inversions.cpp, cycle_sort.cpp, dnf_sort.cpp, gnome_sort.cpp, heap_sort.cpp, insertion_sort.cpp, merge_insertion_sort.cpp, merge_sort.cpp, pancake_sort.cpp, pigeonhole_sort.cpp, quick_sort.cpp, quick_sort_3.cpp, radix_sort2.cpp, random_pivot_quick_sort.cpp, recursive_bubble_sort.cpp, selection_sort_recursive.cpp, shell_sort2.cpp, strand_sort.cpp, wave_sort.cpp, brute_force_string_searching.cpp, horspool.cpp, knuth_morris_pratt.cpp, manacher_algorithm.cpp, rabin_karp.cpp, z_function.cpp
+- main() : graph_coloring.cpp, knight_tour.cpp, minimax.cpp, n_queens.cpp, n_queens_all_solution_optimised.cpp, nqueen_print_all_solutions.cpp, rat_maze.cpp, subarray_sum.cpp, subset_sum.cpp, sudoku_solve.cpp, wildcard_matching.cpp, count_of_set_bits.cpp, count_of_trailing_ciphers_in_factorial_n.cpp, hamming_distance.cpp, caesar_cipher.cpp, elliptic_curve_key_exchange.cpp, hill_cipher.cpp, morse_code.cpp, vigenere_cipher.cpp, xor_cipher.cpp, fcfs_scheduling.cpp, avltree.cpp, disjoint_set.cpp, linked_list.cpp, linkedlist_implentation_usingarray.cpp, list_array.cpp, queue_using_array.cpp, queue_using_two_stacks.cpp, reverse_a_linked_list.cpp, skip_list.cpp, sparse_table.cpp, tree_234.cpp, trie_modern.cpp, trie_tree.cpp, trie_using_hashmap.cpp, karatsuba_algorithm_for_fast_multiplication.cpp, 0_1_knapsack.cpp, abbreviation.cpp, coin_change_topdown.cpp, cut_rod.cpp, house_robber.cpp, kadane2.cpp, longest_increasing_subsequence.cpp, longest_palindromic_subsequence.cpp, minimum_edit_distance.cpp, palindrome_partitioning.cpp, shortest_common_supersequence.cpp, word_break.cpp, jarvis_algorithm.cpp, line_segment_intersection.cpp, bidirectional_dijkstra.cpp, breadth_first_search.cpp, connected_components.cpp, connected_components_with_dsu.cpp, depth_first_search.cpp, depth_first_search_with_stack.cpp, dijkstra.cpp, hamiltons_cycle.cpp, hopcroft_karp.cpp, is_graph_bipartite.cpp, lowest_common_ancestor.cpp, travelling_salesman_problem.cpp, spirograph.cpp, jumpgame.cpp, chaining.cpp, double_hash_hash_table.cpp, linear_probing_hash_table.cpp, md5.cpp, quadratic_probing_hash_table.cpp, sha1.cpp, gram_schmidt.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, neural_network.cpp, ordinary_least_squares_regressor.cpp, armstrong_number.cpp, binary_exponent.cpp, binomial_calculate.cpp, check_amicable_pair.cpp, check_factorial.cpp, check_prime.cpp, complex_numbers.cpp, double_factorial.cpp, eulers_totient_function.cpp, extended_euclid_algorithm.cpp, factorial.cpp, fast_power.cpp, fibonacci.cpp, fibonacci_fast.cpp, fibonacci_matrix_exponentiation.cpp, fibonacci_sum.cpp, finding_number_of_digits_in_a_number.cpp, gcd_iterative_euclidean.cpp, gcd_of_n_numbers.cpp, gcd_recursive_euclidean.cpp, integral_approximation.cpp, inv_sqrt.cpp, large_factorial.cpp, largest_power.cpp, lcm_sum.cpp, least_common_multiple.cpp, magic_number.cpp, miller_rabin.cpp, modular_division.cpp, modular_exponentiation.cpp, modular_inverse_fermat_little_theorem.cpp, n_bonacci.cpp, n_choose_r.cpp, ncr_modulo_p.cpp, number_of_positive_divisors.cpp, power_for_huge_numbers.cpp, power_of_two.cpp, prime_factorization.cpp, prime_numbers.cpp, primes_up_to_billion.cpp, realtime_stats.cpp, sieve_of_eratosthenes.cpp, sqrt_double.cpp, string_fibonacci.cpp, sum_of_binomial_coefficient.cpp, sum_of_digits.cpp, vector_cross_product.cpp, bisection_method.cpp, brent_method_extrema.cpp, false_position.cpp, gaussian_elimination.cpp, golden_search_extrema.cpp, lu_decompose.cpp, newton_raphson_method.cpp, ode_forward_euler.cpp, ode_midpoint_euler.cpp, ode_semi_implicit_euler.cpp, qr_decomposition.cpp, qr_eigen_values.cpp, rungekutta.cpp, successive_approximation.cpp, inorder_successor_of_bst.cpp, trie_multiple_search.cpp, buzz_number.cpp, decimal_to_hexadecimal.cpp, decimal_to_roman_numeral.cpp, fast_integer_input.cpp, happy_number.cpp, iterative_tree_traversals.cpp, kadanes3.cpp, lru_cache.cpp, matrix_exponentiation.cpp, palindrome_of_number.cpp, pascal_triangle.cpp, postfix_evaluation.cpp, primality_test.cpp, smallest_circle.cpp, sparse_matrix.cpp, spiral_print.cpp, stairs_pattern.cpp, tower_of_hanoi.cpp, vector_important_functions.cpp, addition_rule.cpp, bayes_theorem.cpp, binomial_dist.cpp, geometric_dist.cpp, poisson_dist.cpp, windowed_median.cpp, fenwick_tree.cpp, heavy_light_decomposition.cpp, persistent_seg_tree_lazy_prop.cpp, prefix_sum_array.cpp, sparse_table.cpp, binary_search.cpp, exponential_search.cpp, fibonacci_search.cpp, floyd_cycle_detection_algo.cpp, hash_search.cpp, interpolation_search.cpp, interpolation_search2.cpp, linear_search.cpp, median_search.cpp, saddleback_search.cpp, sublist_search.cpp, ternary_search.cpp, text_search.cpp, bogo_sort.cpp, comb_sort.cpp, count_inversions.cpp, cycle_sort.cpp, dnf_sort.cpp, gnome_sort.cpp, heap_sort.cpp, insertion_sort.cpp, merge_insertion_sort.cpp, merge_sort.cpp, pancake_sort.cpp, pigeonhole_sort.cpp, quick_sort.cpp, quick_sort_3.cpp, radix_sort2.cpp, random_pivot_quick_sort.cpp, recursive_bubble_sort.cpp, selection_sort_recursive.cpp, shell_sort2.cpp, strand_sort.cpp, wave_sort.cpp, brute_force_string_searching.cpp, horspool.cpp, knuth_morris_pratt.cpp, manacher_algorithm.cpp, rabin_karp.cpp, z_function.cpp
- mat_mul() : qr_eigen_values.cpp
- mat_size : matrix_exponentiation.cpp
- matrix : lu_decomposition.h
diff --git a/globals_p.html b/globals_p.html
index 0e47ba48a..73d842724 100644
--- a/globals_p.html
+++ b/globals_p.html
@@ -105,8 +105,8 @@ $(document).ready(function(){initNavTree('globals_p.html',''); initResizable();
- pop() : paranthesis_matching.cpp
- power() : power_for_huge_numbers.cpp, matrix_exponentiation.cpp
- predict_OLS_regressor() : ordinary_least_squares_regressor.cpp
-- prime : primes_up_to_billion.cpp
- PRIME : rabin_karp.cpp
+- prime : primes_up_to_billion.cpp
- prime_factorization() : prime_factorization.cpp
- prime_numbers : prime_factorization.cpp
- primes() : prime_numbers.cpp
diff --git a/globals_s.html b/globals_s.html
index f161f7de4..d77d8bf54 100644
--- a/globals_s.html
+++ b/globals_s.html
@@ -104,9 +104,10 @@ $(document).ready(function(){initNavTree('globals_s.html',''); initResizable();
- show_array() : bogo_sort.cpp
- show_data() : shell_sort2.cpp
- show_pascal() : pascal_triangle.cpp
-- sieve() : sieve_of_eratosthenes.cpp
- Sieve() : primes_up_to_billion.cpp
+- sieve() : sieve_of_eratosthenes.cpp
- SieveOfEratosthenes() : prime_factorization.cpp
+- sortcol() : fcfs_scheduling.cpp
- spiralPrint() : spiral_print.cpp
- Sqrt() : sqrt_double.cpp
- stack : paranthesis_matching.cpp
diff --git a/globals_t.html b/globals_t.html
index e9776bdb2..4be523508 100644
--- a/globals_t.html
+++ b/globals_t.html
@@ -94,7 +94,7 @@ $(document).ready(function(){initNavTree('globals_t.html',''); initResizable();
- t -
- ternary_search() : ternary_search.cpp
-- test() : rat_maze.cpp, subarray_sum.cpp, subset_sum.cpp, wildcard_matching.cpp, count_of_set_bits.cpp, count_of_trailing_ciphers_in_factorial_n.cpp, hamming_distance.cpp, caesar_cipher.cpp, elliptic_curve_key_exchange.cpp, morse_code.cpp, vigenere_cipher.cpp, xor_cipher.cpp, list_array.cpp, reverse_a_linked_list.cpp, sparse_table.cpp, trie_tree.cpp, trie_using_hashmap.cpp, karatsuba_algorithm_for_fast_multiplication.cpp, 0_1_knapsack.cpp, abbreviation.cpp, coin_change_topdown.cpp, cut_rod.cpp, house_robber.cpp, longest_increasing_subsequence.cpp, longest_palindromic_subsequence.cpp, minimum_edit_distance.cpp, palindrome_partitioning.cpp, shortest_common_supersequence.cpp, word_break.cpp, jarvis_algorithm.cpp, connected_components_with_dsu.cpp, is_graph_bipartite.cpp, jumpgame.cpp, md5.cpp, sha1.cpp, gram_schmidt.cpp, neural_network.cpp, armstrong_number.cpp, check_amicable_pair.cpp, double_factorial.cpp, fibonacci.cpp, fibonacci_matrix_exponentiation.cpp, fibonacci_sum.cpp, finding_number_of_digits_in_a_number.cpp, inv_sqrt.cpp, largest_power.cpp, lcm_sum.cpp, modular_division.cpp, modular_exponentiation.cpp, n_bonacci.cpp, n_choose_r.cpp, sum_of_binomial_coefficient.cpp, sum_of_digits.cpp, vector_cross_product.cpp, rungekutta.cpp, inorder_successor_of_bst.cpp, trie_multiple_search.cpp, kadanes3.cpp, smallest_circle.cpp, geometric_dist.cpp, windowed_median.cpp, persistent_seg_tree_lazy_prop.cpp, prefix_sum_array.cpp, floyd_cycle_detection_algo.cpp, median_search.cpp, saddleback_search.cpp, sublist_search.cpp, text_search.cpp, bogo_sort.cpp, count_inversions.cpp, cycle_sort.cpp, dnf_sort.cpp, gnome_sort.cpp, heap_sort.cpp, merge_insertion_sort.cpp, pancake_sort.cpp, random_pivot_quick_sort.cpp, recursive_bubble_sort.cpp, selection_sort_recursive.cpp, strand_sort.cpp, wave_sort.cpp, wiggle_sort.cpp, horspool.cpp, manacher_algorithm.cpp, z_function.cpp
+- test() : rat_maze.cpp, subarray_sum.cpp, subset_sum.cpp, wildcard_matching.cpp, count_of_set_bits.cpp, count_of_trailing_ciphers_in_factorial_n.cpp, hamming_distance.cpp, caesar_cipher.cpp, elliptic_curve_key_exchange.cpp, morse_code.cpp, vigenere_cipher.cpp, xor_cipher.cpp, fcfs_scheduling.cpp, list_array.cpp, reverse_a_linked_list.cpp, sparse_table.cpp, trie_tree.cpp, trie_using_hashmap.cpp, karatsuba_algorithm_for_fast_multiplication.cpp, 0_1_knapsack.cpp, abbreviation.cpp, coin_change_topdown.cpp, cut_rod.cpp, house_robber.cpp, longest_increasing_subsequence.cpp, longest_palindromic_subsequence.cpp, minimum_edit_distance.cpp, palindrome_partitioning.cpp, shortest_common_supersequence.cpp, word_break.cpp, jarvis_algorithm.cpp, connected_components_with_dsu.cpp, is_graph_bipartite.cpp, jumpgame.cpp, md5.cpp, sha1.cpp, gram_schmidt.cpp, neural_network.cpp, armstrong_number.cpp, check_amicable_pair.cpp, double_factorial.cpp, fibonacci.cpp, fibonacci_matrix_exponentiation.cpp, fibonacci_sum.cpp, finding_number_of_digits_in_a_number.cpp, inv_sqrt.cpp, largest_power.cpp, lcm_sum.cpp, modular_division.cpp, modular_exponentiation.cpp, n_bonacci.cpp, n_choose_r.cpp, sum_of_binomial_coefficient.cpp, sum_of_digits.cpp, vector_cross_product.cpp, rungekutta.cpp, inorder_successor_of_bst.cpp, trie_multiple_search.cpp, kadanes3.cpp, smallest_circle.cpp, geometric_dist.cpp, windowed_median.cpp, persistent_seg_tree_lazy_prop.cpp, prefix_sum_array.cpp, floyd_cycle_detection_algo.cpp, median_search.cpp, saddleback_search.cpp, sublist_search.cpp, text_search.cpp, bogo_sort.cpp, count_inversions.cpp, cycle_sort.cpp, dnf_sort.cpp, gnome_sort.cpp, heap_sort.cpp, merge_insertion_sort.cpp, pancake_sort.cpp, random_pivot_quick_sort.cpp, recursive_bubble_sort.cpp, selection_sort_recursive.cpp, strand_sort.cpp, wave_sort.cpp, wiggle_sort.cpp, horspool.cpp, manacher_algorithm.cpp, z_function.cpp
- test1() : hill_cipher.cpp, tree_234.cpp, hamiltons_cycle.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, large_factorial.cpp, sum_of_digits.cpp, brent_method_extrema.cpp, durand_kerner_roots.cpp, golden_search_extrema.cpp, lu_decompose.cpp, qr_eigen_values.cpp, iterative_tree_traversals.cpp
- test2() : hill_cipher.cpp, tree_234.cpp, hamiltons_cycle.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, large_factorial.cpp, sum_of_digits.cpp, brent_method_extrema.cpp, durand_kerner_roots.cpp, golden_search_extrema.cpp, lu_decompose.cpp, qr_eigen_values.cpp, iterative_tree_traversals.cpp, smallest_circle.cpp
- test3() : hamiltons_cycle.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, brent_method_extrema.cpp, golden_search_extrema.cpp, iterative_tree_traversals.cpp, smallest_circle.cpp
diff --git a/hierarchy.html b/hierarchy.html
index 6cdc2a251..15fb8a93a 100644
--- a/hierarchy.html
+++ b/hierarchy.html
@@ -104,92 +104,94 @@ This inheritance list is sorted roughly, but not completely, alphabetically: Cbinary_search_tree< T >::bst_node A struct to represent a node in the Binary Search Tree
CBtree Ccll Ccompare Cmachine_learning::aystar_search::AyStarSearch< Puzzle >::comparison_operator Custom comparator for open_list CComplex Class Complex to represent complex numbers as a field Cgeometry::jarvis::Convexhull CCycleCheck Cmachine_learning::neural_network::layers::DenseLayer Cdouble_linked_list CEdge Cmachine_learning::aystar_search::EightPuzzle< N > A class defining EightPuzzle/15-Puzzle game Cdouble_hashing::Entry Clinear_probing::Entry Cquadratic_probing::Entry CFenwickTree Cprobability::geometric_dist::geometric_distribution A class to model the geometric distribution CGraph ▼Cgraph::Graph< T > Cgraph::RootedTree Cgraph::is_graph_bipartite::Graph Class for representing graph as an adjacency list Chash_chain Chain class with a given modulus Cciphers::HillCipher Implementation of Hill Cipher algorithm Cgraph::HKGraph Represents Bipartite graph for Hopcroft Karp implementation Cmachine_learning::aystar_search::AyStarSearch< Puzzle >::Info Struct that handles all the information related to the current state CItem Clarge_number Cdata_structures::linked_list::link Clinkedlist Cdata_structures::linked_list::list Cdata_structures::list_array::list Structure of List with supporting methods Clist Cgraph::LowestCommonAncestor Cothers::lru_cache::LRUCache LRU cache class CMinHeap CMinHeapNode Cmst Cmath::ncr_modulo_p::NCRModuloP Class which contains all methods required for calculating nCr mod p Cmachine_learning::neural_network::NeuralNetwork Cdata_structures::linked_list::Node Cdata_structures::Node Cdata_structures::tree_234::Node 2-3-4 tree node class Cdata_structures::trie_using_hashmap::Trie::Node Struct representing a trie node CNode Cnode< Kind > Coperations_on_datastructures::inorder_traversal_of_bst::Node A Node structure representing a single node in BST Cothers::iterative_tree_traversals::Node Defines the structure of a node of the tree Crange_queries::perSegTree::Node Csearch::sublist_search::Node A Node structure representing a single link Node in a linked list Crange_queries::perSegTree Range query here is range sum, but the code can be modified to make different queries like range max or min Cciphers::elliptic_curve_key_exchange::Point Definition of struct Point Cgeometry::jarvis::Point CPoint Cquery Cqueue< Kind > CQueue Cdata_structures::queue_using_array::Queue_Array Queue_Array class containing the main data and also index of head and tail of the array CRBtree CSegmentIntersection ▼Crange_queries::heavy_light_decomposition::SG< X > Segment Tree, to store heavy chains Crange_queries::heavy_light_decomposition::HLD< X > The Heavy-Light Decomposition class Cdata_structures::SkipList CSolution Cdata_structures::sparse_table::Sparse_table Cothers::postfix_expression::Stack Creates an array to be used as stack for storing values Cstack< Type > Cstack_linkedList Cstatistics::stats_computer1< T > Cstatistics::stats_computer2< T > CTestCases Class encapsulating the necessary test cases Coperations_on_datastructures::trie_operations::Tnode Class defining the structure of trie node and containing the methods to perform operations on them Ctower ▼Crange_queries::heavy_light_decomposition::Tree< X > A Basic Tree, which supports binary lifting Crange_queries::heavy_light_decomposition::HLD< X > The Heavy-Light Decomposition class Cdata_structures::tree_234::Tree234 2-3-4 tree class Cdata_structures::trie Trie implementation for small-case English alphabets a-z Cdata_structures::trie_using_hashmap::Trie Trie class, implementation of trie using hashmap in each trie node for all the characters of char16_t(UTF-16)type with methods to insert, delete, search, start with and to recommend words based on a given prefix CTrie CTrie::TrieNode ▼Cstd::true_type [external] Cstd::is_arithmetic< uint128_t > Cstd::is_arithmetic< uint256_t > Cstd::is_integral< uint128_t > Cstd::is_integral< uint256_t > Cstd::is_unsigned< uint128_t > Cstd::is_unsigned< uint256_t > Cuint128_t Class for 128-bit unsigned integer Cuint256_t Class for 256-bit unsigned integer Cprobability::windowed_median::WindowedMedian A class to calculate the median of a leading sliding window at the back of a stream of integer values CCompare< S, T, E > Comparator class for priority queue Ccompare Cmachine_learning::aystar_search::AyStarSearch< Puzzle >::comparison_operator Custom comparator for open_list CComplex Class Complex to represent complex numbers as a field Cgeometry::jarvis::Convexhull CCycleCheck Cmachine_learning::neural_network::layers::DenseLayer Cdouble_linked_list CEdge Cmachine_learning::aystar_search::EightPuzzle< N > A class defining EightPuzzle/15-Puzzle game Cdouble_hashing::Entry Clinear_probing::Entry Cquadratic_probing::Entry CFCFS< S, T, E > Class which implements the FCFS scheduling algorithm CFenwickTree Cprobability::geometric_dist::geometric_distribution A class to model the geometric distribution CGraph ▼Cgraph::Graph< T > Cgraph::RootedTree Cgraph::is_graph_bipartite::Graph Class for representing graph as an adjacency list Chash_chain Chain class with a given modulus Cciphers::HillCipher Implementation of Hill Cipher algorithm Cgraph::HKGraph Represents Bipartite graph for Hopcroft Karp implementation Cmachine_learning::aystar_search::AyStarSearch< Puzzle >::Info Struct that handles all the information related to the current state CItem Clarge_number Cdata_structures::linked_list::link Clinkedlist Cdata_structures::linked_list::list Cdata_structures::list_array::list Structure of List with supporting methods Clist Cgraph::LowestCommonAncestor Cothers::lru_cache::LRUCache LRU cache class CMinHeap CMinHeapNode Cmst Cmath::ncr_modulo_p::NCRModuloP Class which contains all methods required for calculating nCr mod p Cmachine_learning::neural_network::NeuralNetwork Cdata_structures::linked_list::Node Cdata_structures::Node Cdata_structures::tree_234::Node 2-3-4 tree node class Cdata_structures::trie_using_hashmap::Trie::Node Struct representing a trie node CNode Cnode< Kind > Coperations_on_datastructures::inorder_traversal_of_bst::Node A Node structure representing a single node in BST Cothers::iterative_tree_traversals::Node Defines the structure of a node of the tree Crange_queries::perSegTree::Node Csearch::sublist_search::Node A Node structure representing a single link Node in a linked list Crange_queries::perSegTree Range query here is range sum, but the code can be modified to make different queries like range max or min Cciphers::elliptic_curve_key_exchange::Point Definition of struct Point Cgeometry::jarvis::Point CPoint Cquery Cqueue< Kind > CQueue Cdata_structures::queue_using_array::Queue_Array Queue_Array class containing the main data and also index of head and tail of the array CRBtree CSegmentIntersection ▼Crange_queries::heavy_light_decomposition::SG< X > Segment Tree, to store heavy chains Crange_queries::heavy_light_decomposition::HLD< X > The Heavy-Light Decomposition class Cdata_structures::SkipList CSolution Cdata_structures::sparse_table::Sparse_table Cothers::postfix_expression::Stack Creates an array to be used as stack for storing values Cstack< Type > Cstack_linkedList Cstatistics::stats_computer1< T > Cstatistics::stats_computer2< T > CTestCases Class encapsulating the necessary test cases Coperations_on_datastructures::trie_operations::Tnode Class defining the structure of trie node and containing the methods to perform operations on them Ctower ▼Crange_queries::heavy_light_decomposition::Tree< X > A Basic Tree, which supports binary lifting Crange_queries::heavy_light_decomposition::HLD< X > The Heavy-Light Decomposition class Cdata_structures::tree_234::Tree234 2-3-4 tree class Cdata_structures::trie Trie implementation for small-case English alphabets a-z Cdata_structures::trie_using_hashmap::Trie Trie class, implementation of trie using hashmap in each trie node for all the characters of char16_t(UTF-16)type with methods to insert, delete, search, start with and to recommend words based on a given prefix CTrie CTrie::TrieNode ▼Cstd::true_type [external] Cstd::is_arithmetic< uint128_t > Cstd::is_arithmetic< uint256_t > Cstd::is_integral< uint128_t > Cstd::is_integral< uint256_t > Cstd::is_unsigned< uint128_t > Cstd::is_unsigned< uint256_t > Cuint128_t Class for 128-bit unsigned integer Cuint256_t Class for 256-bit unsigned integer Cprobability::windowed_median::WindowedMedian A class to calculate the median of a leading sliding window at the back of a stream of integer values
diff --git a/hierarchy.js b/hierarchy.js
index cc5d4c317..d62633ce2 100644
--- a/hierarchy.js
+++ b/hierarchy.js
@@ -7,6 +7,7 @@ var hierarchy =
[ "binary_search_tree< T >::bst_node", "dd/db6/structbinary__search__tree_1_1bst__node.html", null ],
[ "Btree", "d9/d90/struct_btree.html", null ],
[ "cll", "d5/d15/classcll.html", null ],
+ [ "Compare< S, T, E >", "de/d4a/class_compare.html", null ],
[ "compare", "d1/db3/structcompare.html", null ],
[ "machine_learning::aystar_search::AyStarSearch< Puzzle >::comparison_operator", "d3/d2a/structmachine__learning_1_1aystar__search_1_1_ay_star_search_1_1comparison__operator.html", null ],
[ "Complex", "da/d5a/class_complex.html", null ],
@@ -19,6 +20,7 @@ var hierarchy =
[ "double_hashing::Entry", "d9/dde/structdouble__hashing_1_1_entry.html", null ],
[ "linear_probing::Entry", "db/d19/structlinear__probing_1_1_entry.html", null ],
[ "quadratic_probing::Entry", "da/dd1/structquadratic__probing_1_1_entry.html", null ],
+ [ "FCFS< S, T, E >", "dd/dca/class_f_c_f_s.html", null ],
[ "FenwickTree", "dd/d91/class_fenwick_tree.html", null ],
[ "probability::geometric_dist::geometric_distribution", "da/d19/classprobability_1_1geometric__dist_1_1geometric__distribution.html", null ],
[ "Graph", "da/d9a/class_graph.html", null ],
diff --git a/index.html b/index.html
index 9b5825758..538225e93 100644
--- a/index.html
+++ b/index.html
@@ -95,10 +95,10 @@ $(document).ready(function(){initNavTree('index.html',''); initResizable(); });
-
+
Overview
This repository is a collection of open-source implementation of a variety of algorithms implemented in C++ and licensed under MIT License. These algorithms span a variety of topics from computer science, mathematics and statistics, data science, machine learning, engineering, etc.. The implementations and the associated documentation are meant to provide a learning resource for educators and students. Hence, one may find more than one implementation for the same objective but using a different algorithm strategies and optimizations.
-
+
Features
- The repository provides implementations of various algorithms in one of the most fundamental general purpose languages - C++.
@@ -109,12 +109,12 @@ Features
- Self-checks within programs ensure correct implementations with confidence.
- Modular implementations and OpenSource licensing enable the functions to be utilized conveniently in other applications.
-
+
Documentation
Online Documentation is generated from the repository source codes directly. The documentation contains all resources including source code snippets, details on execution of the programs, diagrammatic representation of program flow, and links to external resources where necessary. The documentation also introduces interactive source code with links to documentation for C++ STL library functions used. Click on Files menu to see the list of all the files documented with the code.
Documentation of Algorithms in C++ by The Algorithms Contributors is licensed under CC BY-SA 4.0
-
+
Contributions
As a community developed and maintained repository, we welcome new un-plagiarized quality contributions. Please read our Contribution Guidelines.
diff --git a/inherit_graph_10.map b/inherit_graph_10.map
index 32a286108..e3ea338d1 100644
--- a/inherit_graph_10.map
+++ b/inherit_graph_10.map
@@ -1,3 +1,3 @@
diff --git a/inherit_graph_10.md5 b/inherit_graph_10.md5
index 679531e7b..7bca58621 100644
--- a/inherit_graph_10.md5
+++ b/inherit_graph_10.md5
@@ -1 +1 @@
-5eb287a2fb56ae0e7e71100d4f42a21c
\ No newline at end of file
+5320309e3bffbba4f4360758b1ad97f4
\ No newline at end of file
diff --git a/inherit_graph_10.svg b/inherit_graph_10.svg
index 66bb71fe6..4ad91dbea 100644
--- a/inherit_graph_10.svg
+++ b/inherit_graph_10.svg
@@ -12,10 +12,10 @@
Node0
-
+
data_structures::linked
-_list::list
+_list::link
diff --git a/inherit_graph_11.map b/inherit_graph_11.map
index 7d4ec9a8d..32a286108 100644
--- a/inherit_graph_11.map
+++ b/inherit_graph_11.map
@@ -1,3 +1,3 @@
diff --git a/inherit_graph_11.md5 b/inherit_graph_11.md5
index c563a0c98..679531e7b 100644
--- a/inherit_graph_11.md5
+++ b/inherit_graph_11.md5
@@ -1 +1 @@
-d57400eb9de671d3442759337d4a98a7
\ No newline at end of file
+5eb287a2fb56ae0e7e71100d4f42a21c
\ No newline at end of file
diff --git a/inherit_graph_11.svg b/inherit_graph_11.svg
index 5e4880e22..66bb71fe6 100644
--- a/inherit_graph_11.svg
+++ b/inherit_graph_11.svg
@@ -12,10 +12,10 @@
Node0
-
+
data_structures::linked
-_list::Node
+_list::list
diff --git a/inherit_graph_12.map b/inherit_graph_12.map
index 087a17e54..7d4ec9a8d 100644
--- a/inherit_graph_12.map
+++ b/inherit_graph_12.map
@@ -1,3 +1,3 @@
diff --git a/inherit_graph_12.md5 b/inherit_graph_12.md5
index fed441c74..c563a0c98 100644
--- a/inherit_graph_12.md5
+++ b/inherit_graph_12.md5
@@ -1 +1 @@
-8b10ed21001ae43ebb02b0fc74f2c517
\ No newline at end of file
+d57400eb9de671d3442759337d4a98a7
\ No newline at end of file
diff --git a/inherit_graph_12.svg b/inherit_graph_12.svg
index 62e00425f..5e4880e22 100644
--- a/inherit_graph_12.svg
+++ b/inherit_graph_12.svg
@@ -4,18 +4,18 @@
-
Method 1: Use parent pointer (store the address of parent nodes)
- If a node does not have the right subtree, and we already visited the node itself, then the next node will be its parent node according to inorder traversal, and if we are going to parent from left, then the parent would be unvisited.
- In other words, go to the nearest ancestor for which given node would be in left subtree.
+
Method 2: Search from the root node
- In case if there is no link from a child node to the parent node, we need to walk down the tree starting from the root node to the given node, by doing so, we are visiting every ancestor of the given node.
diff --git a/d4/d38/power__of__two_8cpp.html b/d4/d38/power__of__two_8cpp.html
index 2c3ca0248..7ee5b99a4 100644
--- a/d4/d38/power__of__two_8cpp.html
+++ b/d4/d38/power__of__two_8cpp.html
@@ -125,7 +125,7 @@ Functions
Detailed Description
Implementation to check whether a number is a power of 2 or not.
This algorithm uses bit manipulation to check if a number is a power of 2 or not.
-
+
Algorithm
Let the input number be n, then the bitwise and between n and n-1 will let us know whether the number is power of 2 or not
For Example, If N= 32 then N-1 is 31, if we perform bitwise and of these two numbers then the result will be zero, which indicates that it is the power of 2 If N=23 then N-1 is 22, if we perform bitwise and of these two numbers then the result will not be zero , which indicates that it is not the power of 2
- Note
- This implementation is better than naive recursive or iterative approach.
diff --git a/d4/d8d/jarvis__algorithm_8cpp.html b/d4/d8d/jarvis__algorithm_8cpp.html
index 9f186b043..2ea246476 100644
--- a/d4/d8d/jarvis__algorithm_8cpp.html
+++ b/d4/d8d/jarvis__algorithm_8cpp.html
@@ -136,7 +136,7 @@ Functions
Detailed Description
Implementation of Jarvis’s algorithm.
Given a set of points in the plane. the convex hull of the set is the smallest convex polygon that contains all the points of it.
-
+
Algorithm
The idea of Jarvis’s Algorithm is simple, we start from the leftmost point (or point with minimum x coordinate value) and we keep wrapping points in counterclockwise direction.
The idea is to use orientation() here. Next point is selected as the point that beats all other points at counterclockwise orientation, i.e., next point is q if for any other point r, we have “orientation(p, q, r) = counterclockwise”.
diff --git a/d4/d9f/selection__sort__recursive_8cpp.html b/d4/d9f/selection__sort__recursive_8cpp.html
index 69ee52e4e..1f12431b3 100644
--- a/d4/d9f/selection__sort__recursive_8cpp.html
+++ b/d4/d9f/selection__sort__recursive_8cpp.html
@@ -139,7 +139,7 @@ Functions
Detailed Description
Implementation of the Selection sort implementation using recursion.
The selection sort algorithm divides the input list into two parts: a sorted sublist of items which is built up from left to right at the front (left) of the list, and a sublist of the remaining unsorted items that occupy the rest of the list. Initially, the sorted sublist is empty, and the unsorted sublist is the entire input list. The algorithm proceeds by finding the smallest (or largest, depending on the sorting order) element in the unsorted sublist, exchanging (swapping) it with the leftmost unsorted element (putting it in sorted order), and moving the sublist boundaries one element to the right.
-
+
Implementation
FindMinIndex This function finds the minimum element of the array(list) recursively by simply comparing the minimum element of array reduced size by 1 and compares it to the last element of the array to find the minimum of the whole array.
SelectionSortRecursive Just like selection sort, it divides the list into two parts (i.e.: sorted and unsorted) and finds the minimum of the unsorted array. By calling the FindMinIndex function, it swaps the minimum element with the first element of the list, and then solves recursively for the remaining unsorted list.
diff --git a/d5/d33/gram__schmidt_8cpp.html b/d5/d33/gram__schmidt_8cpp.html
index f0a7fa6e8..c5a75e2e3 100644
--- a/d5/d33/gram__schmidt_8cpp.html
+++ b/d5/d33/gram__schmidt_8cpp.html
@@ -139,7 +139,7 @@ Functions
Detailed Description
Gram Schmidt Orthogonalisation Process
Takes the input of Linearly Independent Vectors, returns vectors orthogonal to each other.
-
+
Algorithm
Take the first vector of given LI vectors as first vector of Orthogonal vectors. Take projection of second input vector on the first vector of Orthogonal vector and subtract it from the 2nd LI vector. Take projection of third vector on the second vector of Othogonal vectors and subtract it from the 3rd LI vector. Keep repeating the above process until all the vectors in the given input array are exhausted.
For Example: In R2, Input LI Vectors={(3,1),(2,2)} then Orthogonal Vectors= {(3, 1),(-0.4, 1.2)}
diff --git a/d5/d45/sublist__search_8cpp.html b/d5/d45/sublist__search_8cpp.html
index 2d629b439..201817fd1 100644
--- a/d5/d45/sublist__search_8cpp.html
+++ b/d5/d45/sublist__search_8cpp.html
@@ -148,14 +148,14 @@ Functions
Detailed Description
Implementation of the Sublist Search Algorithm
-
+
Algorithm
- Sublist search is used to detect a presence of one list in another list.
- Suppose we have a single-node list (let's say the first list), and we want to ensure that the list is present in another list (let's say the second list), then we can perform the sublist search to find it.
- For instance, the first list contains these elements: 23 -> 30 -> 41, and the second list contains these elements: 10 -> 15 -> 23 -> 30 -> 41 -> 49. At a glance, we see that the first list presents in the second list.
-
+
Working
- The sublist search algorithm works by comparing the first element of the first list with the first element of the second list.
diff --git a/d5/d88/md__d_i_r_e_c_t_o_r_y.html b/d5/d88/md__d_i_r_e_c_t_o_r_y.html
index 514ce65b3..c5af30faa 100644
--- a/d5/d88/md__d_i_r_e_c_t_o_r_y.html
+++ b/d5/d88/md__d_i_r_e_c_t_o_r_y.html
@@ -128,6 +128,11 @@ Ciphers
- Xor Cipher
+Cpu Scheduling Algorithms
+
+
Data Structures
- Avltree
@@ -169,12 +174,12 @@ Data Structures
- Trie Tree
- Trie Using Hashmap
-
+
Divide And Conquer
-
+
Dynamic Programming
- 0 1 Knapsack
@@ -205,13 +210,13 @@ Dynamic Programming
- Tree Height
- Word Break
-
+
Geometry
-
+
Graph
- Bidirectional Dijkstra
@@ -235,12 +240,12 @@ Graph
- Topological Sort By Kahns Algo
- Travelling Salesman Problem
-
+
Graphics
-
+
Greedy Algorithms
- Dijkstra
@@ -250,7 +255,7 @@ Greedy Algorithms
- Kruskals Minimum Spanning Tree
- Prims Minimum Spanning Tree
-
+
Hashing
- Chaining
@@ -260,12 +265,12 @@ Hashing
- Quadratic Probing Hash Table
- Sha1
-
+
Linear Algebra
-
+
Machine Learning
- A Star Search
@@ -276,7 +281,7 @@ Machine Learning
- Ordinary Least Squares Regressor
- Vector Ops
-
+
Math
- Armstrong Number
@@ -330,7 +335,7 @@ Math
- Sum Of Digits
- Vector Cross Product
-
+
Numerical Methods
- Bisection Method
@@ -351,7 +356,7 @@ Numerical Methods
- Rungekutta
- Successive Approximation
-
+
Operations On Datastructures
- Array Left Rotation
@@ -366,7 +371,7 @@ Operations On Datastructures
- Trie Multiple Search
- Union Of 2 Arrays
-
+
Others
- Buzz Number
@@ -391,7 +396,7 @@ Others
- Tower Of Hanoi
- Vector Important Functions
-
+
Probability
- Addition Rule
@@ -401,7 +406,7 @@ Probability
- Poisson Dist
- Windowed Median
-
+
Range Queries
- Fenwick Tree
@@ -412,7 +417,7 @@ Range Queries
- Segtree
- Sparse Table
-
+
Search
- Binary Search
@@ -430,7 +435,7 @@ Search
- Ternary Search
- Text Search
-
+
Sorting
- Bead Sort
@@ -473,7 +478,7 @@ Sorting
- Wave Sort
- Wiggle Sort
-
+
Strings
- Brute Force String Searching
diff --git a/d5/d96/md5_8cpp.html b/d5/d96/md5_8cpp.html
index fcef37251..653b5c1fe 100644
--- a/d5/d96/md5_8cpp.html
+++ b/d5/d96/md5_8cpp.html
@@ -164,7 +164,7 @@ Functions
- Store salted password
However MD5 has be know to be cryptographically weak for quite some time, yet it is still widely used. This weakness was exploited by the Flame Malware in 2012
-
+
Algorithm
First of all, all values are expected to be in little endian. This is especially important when using part of the bytestring as an integer.
The first step of the algorithm is to pad the message for its length to be a multiple of 64 (bytes). This is done by first adding 0x80 (10000000) and then only zeroes until the last 8 bytes must be filled, where then the 64 bit size of the input will be added
diff --git a/d5/ddb/bogo__sort_8cpp.html b/d5/ddb/bogo__sort_8cpp.html
index 5fca0b893..30e0a0c78 100644
--- a/d5/ddb/bogo__sort_8cpp.html
+++ b/d5/ddb/bogo__sort_8cpp.html
@@ -135,7 +135,7 @@ Functions
Detailed Description
Implementation of Bogosort algorithm
In computer science, bogosort (also known as permutation sort, stupid sort, slowsort, shotgun sort, random sort, monkey sort, bobosort or shuffle sort) is a highly inefficient sorting algorithm based on the generate and test paradigm. Two versions of this algorithm exist: a deterministic version that enumerates all permutations until it hits a sorted one, and a randomized version that randomly permutes its input.Randomized version is implemented here.
-
+
Algorithm
Shuffle the array untill array is sorted.
diff --git a/d6/d10/cut__rod_8cpp.html b/d6/d10/cut__rod_8cpp.html
index 5da32cc73..e6dad50c4 100644
--- a/d6/d10/cut__rod_8cpp.html
+++ b/d6/d10/cut__rod_8cpp.html
@@ -135,7 +135,7 @@ Functions
Detailed Description
Implementation of cutting a rod problem.
Given a rod of length n inches and an array of prices that contains prices of all pieces of size<=n. Determine the maximum profit obtainable by cutting up the rod and selling the pieces.
-
+
Algorithm
The idea is to break the given rod into every smaller piece as possible and then check profit for each piece, by calculating maximum profit for smaller pieces we will build the solution for larger pieces in bottom-up manner.
- Capitalize zero or more of
a's lowercase letters.
- Delete all of the remaining lowercase letters in
a.
-
+
Algorithm
The idea is in the problem statement itself: iterate through characters of string a and b (for character indexes i and j respectively):
- If
a[i] and b[j] are equal, then move to next position
diff --git a/d8/d7a/sha1_8cpp.html b/d8/d7a/sha1_8cpp.html
index 011c7725c..4a75469bc 100644
--- a/d8/d7a/sha1_8cpp.html
+++ b/d8/d7a/sha1_8cpp.html
@@ -150,7 +150,7 @@ Functions
Simple C++ implementation of the SHA-1 Hashing Algorithm
SHA-1 is a cryptographic hash function that was developped by the NSA 1995. SHA-1 is not considered secure since around 2010.
-
+
Algorithm
The first step of the algorithm is to pad the message for its length to be a multiple of 64 (bytes). This is done by first adding 0x80 (10000000) and then only zeroes until the last 8 bytes must be filled, where then the 64 bit size of the input will be added
Once this is done, the algo breaks down this padded message into 64 bytes chunks. Each chunk is used for one round, a round breaks the chunk into 16 blocks of 4 bytes. These 16 blocks are then extended to 80 blocks using XOR operations on existing blocks (see code for more details). The algorithm will then update its 160-bit state (here represented used 5 32-bits integer) using partial hashes computed using special functions on the blocks previously built. Please take a look at the wikipedia article for more precision on these operations
- Note
- This is a simple implementation for a byte string but some implmenetations can work on bytestream, messages of unknown length.
diff --git a/d8/d90/iterative__tree__traversals_8cpp.html b/d8/d90/iterative__tree__traversals_8cpp.html
index 73ac4c543..3efdda89b 100644
--- a/d8/d90/iterative__tree__traversals_8cpp.html
+++ b/d8/d90/iterative__tree__traversals_8cpp.html
@@ -157,13 +157,13 @@ Functions
Detailed Description
Iterative version of Preorder, Postorder, and preorder Traversal of the Tree
-
+
Iterative Preorder Traversal of a tree
Create a Stack that will store the Node of Tree. Push the root node into the stack. Save the root into the variabe named as current, and pop and elemnt from the stack. Store the data of current into the result array, and start traversing from it. Push both the child node of the current node into the stack, first right child then left child. Repeat the same set of steps untill the Stack becomes empty. And return the result array as the preorder traversal of a tree.
-
+
Iterative Postorder Traversal of a tree
Create a Stack that will store the Node of Tree. Push the root node into the stack. Save the root into the variabe named as current, and pop and elemnt from the stack. Store the data of current into the result array, and start traversing from it. Push both the child node of the current node into the stack, first left child then right child. Repeat the same set of steps untill the Stack becomes empty. Now reverse the result array and then return it to the calling function as a postorder traversal of a tree.
-
+
Iterative Inorder Traversal of a tree
Create a Stack that will store the Node of Tree. Push the root node into the stack. Save the root into the variabe named as current. Now iterate and take the current to the extreme left of the tree by traversing only to its left. Pop the elemnt from the stack and assign it to the current. Store the data of current into the result array. Repeat the same set of steps until the Stack becomes empty or the current becomes NULL. And return the result array as the inorder traversal of a tree.
Function Documentation
diff --git a/d8/d99/connected__components__with__dsu_8cpp.html b/d8/d99/connected__components__with__dsu_8cpp.html
index 75568d7b0..ab127c3d4 100644
--- a/d8/d99/connected__components__with__dsu_8cpp.html
+++ b/d8/d99/connected__components__with__dsu_8cpp.html
@@ -155,7 +155,7 @@ uint32_t graph::disjoint_u
Detailed Description
The Disjoint union is the technique to find connected component in graph efficiently.
-
+
Algorithm
In Graph, if you have to find out the number of connected components, there are 2 options
- Depth first search
diff --git a/d8/dc8/class_compare-members.html b/d8/dc8/class_compare-members.html
new file mode 100644
index 000000000..84ead1ecc
--- /dev/null
+++ b/d8/dc8/class_compare-members.html
@@ -0,0 +1,109 @@
+
+
+
+
+
+
+
+Algorithms_in_C++: Member List
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Algorithms_in_C++ 1.0.0
+
+ Set of algorithms implemented in C++.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Compare< S, T, E > Member List
+
+
+
+This is the complete list of members for Compare< S, T, E >, including all inherited members.
+
+ operator()(tuple< S, T, E, double, double, double > &t1, tuple< S, T, E, double, double, double > &t2) Compare< S, T, E > inline
+
+
+
+
+ - Generated by 1.9.2
+
+
+
+
diff --git a/d9/dfd/comb__sort_8cpp.html b/d9/dfd/comb__sort_8cpp.html
index 871becef3..117c91753 100644
--- a/d9/dfd/comb__sort_8cpp.html
+++ b/d9/dfd/comb__sort_8cpp.html
@@ -172,7 +172,7 @@ Functions
Initialize swapped as true to make sure that loop runs
Keep running until gap = 1 or none elements were swapped
Find next gap
-Compare all elements with current gap
+Compare all elements with current gap
diff --git a/da/d52/minimum__edit__distance_8cpp.html b/da/d52/minimum__edit__distance_8cpp.html
index 3567f6cd6..624a0f246 100644
--- a/da/d52/minimum__edit__distance_8cpp.html
+++ b/da/d52/minimum__edit__distance_8cpp.html
@@ -136,7 +136,7 @@ Functions
Detailed Description
Implementation of Minimum Edit Distance using Dynamic Programing.
Given two strings str1 & str2 and we have to calculate the minimum number of operations (Insert, Remove, Replace) required to convert str1 to str2.
-
+
Algorithm
We will solve this problem using Naive recursion. But as we are approaching with a DP solution. So, we will take a DP array to store the solution of all sub-problems so that we don't have to perform recursion again and again. Now to solve the problem, We can traverse all characters from either right side of the strings or left side. Suppose we will do it from the right side. So, there are two possibilities for every pair of characters being traversed.
- If the last characters of two strings are the same, Ignore the characters and get the count for the remaining string. So, we get the solution for lengths m-1 and n-1 in a DP array.
diff --git a/db/d16/0__1__knapsack_8cpp.html b/db/d16/0__1__knapsack_8cpp.html
index 433c48500..cfcf6167c 100644
--- a/db/d16/0__1__knapsack_8cpp.html
+++ b/db/d16/0__1__knapsack_8cpp.html
@@ -135,7 +135,7 @@ Functions
Detailed Description
Implementation of 0-1 Knapsack Problem
Given weights and values of n items, put these items in a knapsack of capacity W to get the maximum total value in the knapsack. In other words, given two integer arrays val[0..n-1] and wt[0..n-1] which represent values and weights associated with n items respectively. Also given an integer W which represents knapsack capacity, find out the maximum value subset of val[] such that sum of the weights of this subset is smaller than or equal to W. You cannot break an item, either pick the complete item or don’t pick it (0-1 property)
-
+
Algorithm
The idea is to consider all subsets of items and calculate the total weight and value of all subsets. Consider the only subsets whose total weight is smaller than W. From all such subsets, pick the maximum value subset.
- Author
- Anmol
diff --git a/db/dca/kadane2_8cpp.html b/db/dca/kadane2_8cpp.html
index 35dd96829..1dbb15c18 100644
--- a/db/dca/kadane2_8cpp.html
+++ b/db/dca/kadane2_8cpp.html
@@ -131,7 +131,7 @@ Functions
Detailed Description
Implementation of Kadane Algorithm
Kadane algorithm is used to find the maximum sum subarray in an array and maximum sum subarray problem is the task of finding a contiguous subarray with the largest sum
-
+
Algorithm
The simple idea of the algorithm is to search for all positive contiguous segments of the array and keep track of maximum sum contiguous segment among all positive segments(curr_sum is used for this) Each time we get a positive sum we compare it with max_sum and update max_sum if it is greater than curr_sum
diff --git a/dd/d47/namespacemath.html b/dd/d47/namespacemath.html
index c23f2ccf6..1d04b6d46 100644
--- a/dd/d47/namespacemath.html
+++ b/dd/d47/namespacemath.html
@@ -145,7 +145,7 @@ Functions
Mathematical algorithms
Given a recurrence relation; evaluate the value of nth term. For e.g., For fibonacci series, recurrence series is f(n) = f(n-1) + f(n-2) where f(0) = 0 and f(1) = 1. Note that the method used only demonstrates recurrence relation with one variable (n), unlike nCr problem, since it has two (n, r)
-
+
Algorithm
This problem can be solved using matrix exponentiation method.
- See also
- here for simple number exponentiation algorithm or explaination here.
diff --git a/dd/dca/class_f_c_f_s.html b/dd/dca/class_f_c_f_s.html
new file mode 100644
index 000000000..cc5a819ff
--- /dev/null
+++ b/dd/dca/class_f_c_f_s.html
@@ -0,0 +1,376 @@
+
+
+
+
+
+
+
+Algorithms_in_C++: FCFS< S, T, E > Class Template Reference
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Algorithms_in_C++ 1.0.0
+
+ Set of algorithms implemented in C++.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ FCFS< S, T, E > Class Template Reference
+
+
+
+Class which implements the FCFS scheduling algorithm.
+ More...
+
+
+Public Member Functions
void addProcess (S id, T arrival, E burst) Adds the process to the ready queue if it isn't already there. More...
vector< tuple< S, T, E, double, double, double > > scheduleForFcfs () Algorithm for scheduling CPU processes according to the First Come First Serve(FCFS) scheduling algorithm. More...
void printResult () Utility function for printing the status of each process after execution. More...
+
+Private Attributes
priority_queue< tuple< S, T, E, double, double, double >, vector< tuple< S, T, E, double, double, double > >, Compare< S, T, E > > schedule
+vector< tuple< S, T, E, double, double, double > > result
+unordered_set< S > idList
+Detailed Description
+template<typename S, typename T, typename E>
+class FCFS< S, T, E >Class which implements the FCFS scheduling algorithm.
+- Template Parameters
-
+
+ S Data type of Process ID T Data type of Arrival time E Data type of Burst time
+
+
+Member Function Documentation
+
+◆ addProcess()
+
+
+
+
+template<typename S , typename T , typename E >
+
+
+
+
+
+ void FCFS< S, T, E >::addProcess
+ (
+ S
+ id,
+
+
+ T
+ arrival,
+
+
+ E
+ burst
+
+
+ )
+
+
+
+
+inline
+
+
+
+
+Adds the process to the ready queue if it isn't already there.
+- Parameters
-
+
+ id Process ID arrival Arrival time of the process burst Burst time of the process
+
+
+- Returns
- void
+
+
+
+
+
+
+
+
+
+priority_queue< tuple< S, T, E, double, double, double >, vector< tuple< S, T, E, double, double, double > >, Compare< S, T, E > > scheduleDefinition: fcfs_scheduling.cpp:111
+T make_tuple(T... args)
+
+
+Here is the call graph for this function:
+
+
+
+
+
+
+
+
+◆ printResult()
+
+
+
+
+template<typename S , typename T , typename E >
+
+
+
+
+
+ void FCFS< S, T, E >::printResult
+ (
+ )
+
+
+
+
+inline
+
+
+
+
+Utility function for printing the status of each process after execution.
+- Returns
- void
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+T fixed(T... args)
+T left(T... args)
+
+T setprecision(T... args)
+T setw(T... args)
+
+Here is the call graph for this function:
+
+
+
+
+
+
+
+
+◆ scheduleForFcfs()
+
+
+
+
+template<typename S , typename T , typename E >
+
+
+
+
+
+ vector< tuple< S, T, E, double, double, double > > FCFS< S, T, E >::scheduleForFcfs
+ (
+ )
+
+
+
+
+inline
+
+
+
+
+Algorithm for scheduling CPU processes according to the First Come First Serve(FCFS) scheduling algorithm.
+FCFS is a non-preemptive algorithm in which the process which arrives first gets executed first. If two or more processes arrive together then the process with smaller process ID runs first (each process has a unique proces ID).
+I used a min priority queue of tuples to accomplish this task. The processes are ordered by their arrival times. If arrival times of some processes are equal, then they are ordered by their process ID.
+- Returns
- void
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Member Data Documentation
+
+◆ schedule
+
+
+
+
+template<typename S , typename T , typename E >
+
+
+
+
+
+ priority_queue<tuple<S, T, E, double, double, double>, vector<tuple<S, T, E, double, double, double> >, Compare<S, T, E> > FCFS< S, T, E >::schedule
+
+
+
+
+private
+
+
+
+Priority queue of schedules(stored as tuples) of processes. In each tuple 1st element: Process ID 2nd element: Arrival Time 3rd element: Burst time 4th element: Completion time 5th element: Turnaround time 6th element: Waiting time
+
+
+
+
The documentation for this class was generated from the following file:
+- cpu_scheduling_algorithms/fcfs_scheduling.cpp
+
+
+
+
+
+
+
+ - Generated by 1.9.2
+
+
+
+
diff --git a/dd/dca/class_f_c_f_s.js b/dd/dca/class_f_c_f_s.js
new file mode 100644
index 000000000..3c4ded1da
--- /dev/null
+++ b/dd/dca/class_f_c_f_s.js
@@ -0,0 +1,7 @@
+var class_f_c_f_s =
+[
+ [ "addProcess", "dd/dca/class_f_c_f_s.html#a8fbfe4d85f7576b4a7aade07d29fbd69", null ],
+ [ "printResult", "dd/dca/class_f_c_f_s.html#abb361a612b18bb189aa6d3c49288b793", null ],
+ [ "scheduleForFcfs", "dd/dca/class_f_c_f_s.html#aa25dbe30ba9930b5a7c1a6d11758bd91", null ],
+ [ "schedule", "dd/dca/class_f_c_f_s.html#af2594e22a867b308e027623940193d46", null ]
+];
\ No newline at end of file
diff --git a/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.map b/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.map
new file mode 100644
index 000000000..5ff1060ab
--- /dev/null
+++ b/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.map
@@ -0,0 +1,6 @@
+
diff --git a/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.md5 b/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.md5
new file mode 100644
index 000000000..f960e4771
--- /dev/null
+++ b/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.md5
@@ -0,0 +1 @@
+40be8724cd3544d6f4f7db4d23d50120
\ No newline at end of file
diff --git a/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.svg b/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.svg
new file mode 100644
index 000000000..4e2da5e1f
--- /dev/null
+++ b/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.svg
@@ -0,0 +1,69 @@
+
+
+
+
+
diff --git a/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.map b/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.map
new file mode 100644
index 000000000..bf9103337
--- /dev/null
+++ b/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.map
@@ -0,0 +1,6 @@
+
diff --git a/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.md5 b/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.md5
new file mode 100644
index 000000000..da9dbaf40
--- /dev/null
+++ b/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.md5
@@ -0,0 +1 @@
+fbc7b8c39328fdeb00baa02dadb94ca6
\ No newline at end of file
diff --git a/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.svg b/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.svg
new file mode 100644
index 000000000..e611a5eb6
--- /dev/null
+++ b/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.svg
@@ -0,0 +1,67 @@
+
+
+
+
+
diff --git a/de/d4a/class_compare.html b/de/d4a/class_compare.html
new file mode 100644
index 000000000..3bea0dd03
--- /dev/null
+++ b/de/d4a/class_compare.html
@@ -0,0 +1,195 @@
+
+
+
+
+
+
+
+Algorithms_in_C++: Compare< S, T, E > Class Template Reference
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Algorithms_in_C++ 1.0.0
+
+ Set of algorithms implemented in C++.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Compare< S, T, E > Class Template Reference
+
+
+
+Comparator class for priority queue.
+ More...
+
+
+Public Member Functions
bool operator() (tuple< S, T, E, double, double, double > &t1, tuple< S, T, E, double, double, double > &t2) A comparator function that checks whether to swap the two tuples or not. to https://www.geeksforgeeks.org/comparator-class-in-c-with-examples/ for detailed description of comparator. More...
+Detailed Description
+template<typename S, typename T, typename E>
+class Compare< S, T, E >Comparator class for priority queue.
+- Template Parameters
-
+
+ S Data type of Process ID T Data type of Arrival time E Data type of Burst time
+
+
+Member Function Documentation
+
+◆ operator()()
+
+
+
+
+template<typename S , typename T , typename E >
+
+
+
+
+
+ bool Compare< S, T, E >::operator()
+ (
+ tuple< S, T, E, double, double, double > &
+ t1,
+
+
+ tuple< S, T, E, double, double, double > &
+ t2
+
+
+ )
+
+
+
+
+inline
+
+
+
+
+A comparator function that checks whether to swap the two tuples or not. to https://www.geeksforgeeks.org/comparator-class-in-c-with-examples/ for detailed description of comparator.
+- Parameters
-
+
+ t1 First tuple t2 Second tuple
+
+
+- Returns
- true if the tuples SHOULD be swapped
+-
+false if the tuples SHOULDN'T be swapped
+
+
+
+
The documentation for this class was generated from the following file:
+- cpu_scheduling_algorithms/fcfs_scheduling.cpp
+
+
+
+
+
+
+
+ - Generated by 1.9.2
+
+
+
+
diff --git a/de/d4a/class_compare.js b/de/d4a/class_compare.js
new file mode 100644
index 000000000..f123aff03
--- /dev/null
+++ b/de/d4a/class_compare.js
@@ -0,0 +1,4 @@
+var class_compare =
+[
+ [ "operator()", "de/d4a/class_compare.html#afbdf9a44adb49728dc704155d7d1570c", null ]
+];
\ No newline at end of file
diff --git a/de/d8d/class_f_c_f_s-members.html b/de/d8d/class_f_c_f_s-members.html
new file mode 100644
index 000000000..5afa21c6c
--- /dev/null
+++ b/de/d8d/class_f_c_f_s-members.html
@@ -0,0 +1,114 @@
+
+
+
+
+
+
+
+Algorithms_in_C++: Member List
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Algorithms_in_C++ 1.0.0
+
+ Set of algorithms implemented in C++.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ FCFS< S, T, E > Member List
+
+
+
+This is the complete list of members for FCFS< S, T, E >, including all inherited members.
+
+ addProcess(S id, T arrival, E burst) FCFS< S, T, E > inline idList (defined in FCFS< S, T, E >) FCFS< S, T, E > private printResult() FCFS< S, T, E > inline result (defined in FCFS< S, T, E >) FCFS< S, T, E > private schedule FCFS< S, T, E > private scheduleForFcfs() FCFS< S, T, E > inline
+
+
+
+
+ - Generated by 1.9.2
+
+
+
+
diff --git a/df/d47/fcfs__scheduling_8cpp.html b/df/d47/fcfs__scheduling_8cpp.html
new file mode 100644
index 000000000..298493c7c
--- /dev/null
+++ b/df/d47/fcfs__scheduling_8cpp.html
@@ -0,0 +1,376 @@
+
+
+
+
+
+
+
+Algorithms_in_C++: cpu_scheduling_algorithms/fcfs_scheduling.cpp File Reference
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Algorithms_in_C++ 1.0.0
+
+ Set of algorithms implemented in C++.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Implementation of FCFS CPU scheduling algorithm.
+More...
+#include <algorithm>
+#include <cassert>
+#include <cstdlib>
+#include <ctime>
+#include <iomanip>
+#include <iostream>
+#include <queue>
+#include <unordered_set>
+#include <vector>
+
+Include dependency graph for fcfs_scheduling.cpp:
+
+
+
+
+
+
+Classes
class Compare< S, T, E > Comparator class for priority queue. More...
class FCFS< S, T, E > Class which implements the FCFS scheduling algorithm. More...
+
+Functions
template<typename S , typename T , typename E > bool sortcol (tuple< S, T, E > &t1, tuple< S, T, E > &t2) Comparator function for sorting a vector. More...
template<typename S , typename T , typename E > vector< tuple< S, T, E, double, double, double > > get_final_status (vector< tuple< uint32_t, uint32_t, uint32_t > > input) Function to be used for testing purposes. This function guarantees the correct solution for FCFS scheduling algorithm. More...
static void test () Self-test implementations. More...
int main () Entry point of the program. More...
+Detailed Description
+Implementation of FCFS CPU scheduling algorithm.
+FCFS is a non-preemptive CPU scheduling algorithm in which whichever process arrives first, gets executed first. If two or more processes arrive simultaneously, the process with smaller process ID gets executed first. https://bit.ly/3ABNXOCPratyush Vatsa
+Function Documentation
+
+◆ get_final_status()
+
+
+
+
+template<typename S , typename T , typename E >
+
+
+ vector< tuple< S, T, E, double, double, double > > get_final_status
+ (
+ vector< tuple< uint32_t, uint32_t, uint32_t > >
+ input )
+
+
+
+
+Function to be used for testing purposes. This function guarantees the correct solution for FCFS scheduling algorithm.
+- Parameters
-
+
+ input the input data
+
+
+Sorts the input vector according to arrival time. Processes whose arrival times are same get sorted according to process ID For each process, completion time, turnaround time and completion time are calculated, inserted in a tuple, which is added to the vector result.
- Returns
- A vector of tuples consisting of process ID, arrival time, burst time, completion time, turnaround time and waiting time for each process.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+T begin(T... args)
+T end(T... args)
+
+T size(T... args)
+T sort(T... args)
+
+
+
+
+
+◆ main()
+
+
+
+
+
+ int main
+ (
+ void
+ )
+
+
+
+
+
+◆ sortcol()
+
+
+
+
+template<typename S , typename T , typename E >
+
+
+ bool sortcol
+ (
+ tuple< S, T, E > &
+ t1,
+
+
+ tuple< S, T, E > &
+ t2
+
+
+ )
+
+
+
+
+Comparator function for sorting a vector.
+- Template Parameters
-
+
+ S Data type of Process ID T Data type of Arrival time E Data type of Burst time
+
+
+- Parameters
-
+
+ t1 First tuple t2 Second tuple
+
+
+- Returns
- true if t1 and t2 are in the CORRECT order
+-
+false if t1 and t2 are in the INCORRECT order
+
+
+
+
+◆ test()
+
+
+
+
+
+
+
+
+ static void test
+ (
+ )
+
+
+
+
+static
+
+
+
+
+Self-test implementations.
+- Returns
- void
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+void addProcess(S id, T arrival, E burst)Adds the process to the ready queue if it isn't already there.Definition: fcfs_scheduling.cpp:129
+vector< tuple< S, T, E, double, double, double > > scheduleForFcfs()Algorithm for scheduling CPU processes according to the First Come First Serve(FCFS) scheduling algor...Definition: fcfs_scheduling.cpp:154
+
+T rand(T... args)
+T srand(T... args)
+T time(T... args)
+
+Here is the call graph for this function:
+
+
+
+
+
+
+
+
+
+
+
+
+
+ - Generated by 1.9.2
+
+
+
+
diff --git a/df/d47/fcfs__scheduling_8cpp.js b/df/d47/fcfs__scheduling_8cpp.js
new file mode 100644
index 000000000..3ab097c7e
--- /dev/null
+++ b/df/d47/fcfs__scheduling_8cpp.js
@@ -0,0 +1,9 @@
+var fcfs__scheduling_8cpp =
+[
+ [ "Compare< S, T, E >", "de/d4a/class_compare.html", "de/d4a/class_compare" ],
+ [ "FCFS< S, T, E >", "dd/dca/class_f_c_f_s.html", "dd/dca/class_f_c_f_s" ],
+ [ "get_final_status", "df/d47/fcfs__scheduling_8cpp.html#a8f2b90cb64d63a7080965e66a05ccf86", null ],
+ [ "main", "df/d47/fcfs__scheduling_8cpp.html#ae66f6b31b5ad750f1fe042a706a4e3d4", null ],
+ [ "sortcol", "df/d47/fcfs__scheduling_8cpp.html#a18920aa331faf4476b251c8cdb2c2bec", null ],
+ [ "test", "df/d47/fcfs__scheduling_8cpp.html#aa8dca7b867074164d5f45b0f3851269d", null ]
+];
\ No newline at end of file
diff --git a/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.map b/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.map
new file mode 100644
index 000000000..fac5223b9
--- /dev/null
+++ b/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.map
@@ -0,0 +1,8 @@
+
diff --git a/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.md5 b/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.md5
new file mode 100644
index 000000000..60334c7c9
--- /dev/null
+++ b/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.md5
@@ -0,0 +1 @@
+eb25f61bb3c01f732953e7b177f935be
\ No newline at end of file
diff --git a/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.svg b/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.svg
new file mode 100644
index 000000000..861a9adf2
--- /dev/null
+++ b/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.svg
@@ -0,0 +1,99 @@
+
+
+
+
+
diff --git a/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.map b/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.map
new file mode 100644
index 000000000..ae5ce9e63
--- /dev/null
+++ b/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.map
@@ -0,0 +1,9 @@
+
diff --git a/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.md5 b/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.md5
new file mode 100644
index 000000000..ad9c7536b
--- /dev/null
+++ b/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.md5
@@ -0,0 +1 @@
+d1153ad5effebcdd01be2ae30d68c8af
\ No newline at end of file
diff --git a/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.svg b/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.svg
new file mode 100644
index 000000000..d4ff69629
--- /dev/null
+++ b/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.svg
@@ -0,0 +1,114 @@
+
+
+
+
+
diff --git a/df/d66/vector__cross__product_8cpp.html b/df/d66/vector__cross__product_8cpp.html
index 71f0fb3b7..cc70bdf6c 100644
--- a/df/d66/vector__cross__product_8cpp.html
+++ b/df/d66/vector__cross__product_8cpp.html
@@ -144,7 +144,7 @@ Functions
The direction ratios (DR) are calculated as follows: 1st DR, J: (b * z) - (c * y) 2nd DR, A: -((a * z) - (c * x)) 3rd DR, N: (a * y) - (b * x)
Therefore, the direction ratios of the cross product are: J, A, N The following C++ Program calculates the direction ratios of the cross products of two vector. The program uses a function, cross() for doing so. The direction ratios for the first and the second vector has to be passed one by one seperated by a space character.
Magnitude of a vector is the square root of the sum of the squares of the direction ratios.
-
+
Example:
An example of a running instance of the executable program:
Pass the first Vector: 1 2 3
Pass the second Vector: 4 5 6 The cross product is: -3 6 -3 Magnitude: 7.34847
diff --git a/dir_000002_000016.html b/dir_000002_000017.html
similarity index 100%
rename from dir_000002_000016.html
rename to dir_000002_000017.html
diff --git a/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.map b/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.map
index 623879934..72fef3963 100644
--- a/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.map
+++ b/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.map
@@ -1,5 +1,5 @@
diff --git a/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.md5 b/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.md5
index 5fd2b3301..257e4dba0 100644
--- a/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.md5
+++ b/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.md5
@@ -1 +1 @@
-92fa4d7ae23a16161aeff73e457c6e1f
\ No newline at end of file
+76e5d78bae3066db57a72fde536d8c2e
\ No newline at end of file
diff --git a/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.svg b/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.svg
index d7d51943b..7af541bfb 100644
--- a/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.svg
+++ b/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.svg
@@ -32,7 +32,7 @@
dir_4d6e05837bf820fb089a8a8cdf2f42b7->dir_9c6faab82c22511b50177aa2e38e2780
+
1
diff --git a/dir_cc8e79ed9d2b7756c78e8d0c87c6c0c7.html b/dir_cc8e79ed9d2b7756c78e8d0c87c6c0c7.html
new file mode 100644
index 000000000..7068e3381
--- /dev/null
+++ b/dir_cc8e79ed9d2b7756c78e8d0c87c6c0c7.html
@@ -0,0 +1,113 @@
+
+
+
+
+
+
+
+Algorithms_in_C++: cpu_scheduling_algorithms Directory Reference
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Algorithms_in_C++ 1.0.0
+
+ Set of algorithms implemented in C++.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ cpu_scheduling_algorithms Directory Reference
+
+
+
+
+Files
file fcfs_scheduling.cpp Implementation of FCFS CPU scheduling algorithm.
+
+
+
+
+
+
+ - Generated by 1.9.2
+
+
+
+
diff --git a/dir_cc8e79ed9d2b7756c78e8d0c87c6c0c7.js b/dir_cc8e79ed9d2b7756c78e8d0c87c6c0c7.js
new file mode 100644
index 000000000..804b70f89
--- /dev/null
+++ b/dir_cc8e79ed9d2b7756c78e8d0c87c6c0c7.js
@@ -0,0 +1,4 @@
+var dir_cc8e79ed9d2b7756c78e8d0c87c6c0c7 =
+[
+ [ "fcfs_scheduling.cpp", "df/d47/fcfs__scheduling_8cpp.html", "df/d47/fcfs__scheduling_8cpp" ]
+];
\ No newline at end of file
diff --git a/files.html b/files.html
index d3fdd7b77..6eaa50aa5 100644
--- a/files.html
+++ b/files.html
@@ -121,232 +121,234 @@ solve-a-rat-in-a-maze-c-java-pytho/"
- ► data_structures ► divide_and_conquer ► dynamic_programming ► geometry ► graph ► graphics ► greedy_algorithms ► hashing ► linear_algebra ► machine_learning ► math ► numerical_methods ► operations_on_datastructures ► others ► probability ► range_queries ► search ► sorting ► strings ► cpu_scheduling_algorithms ► data_structures ► divide_and_conquer ► dynamic_programming ► geometry ► graph ► graphics ► greedy_algorithms ► hashing ► linear_algebra ► machine_learning ► math ► numerical_methods ► operations_on_datastructures ► others ► probability ► range_queries ► search ► sorting ► strings
diff --git a/files_dup.js b/files_dup.js
index 927c6694b..685144116 100644
--- a/files_dup.js
+++ b/files_dup.js
@@ -3,6 +3,7 @@ var files_dup =
[ "backtracking", "dir_c11585dfcef32a26e29098facab6c144.html", "dir_c11585dfcef32a26e29098facab6c144" ],
[ "bit_manipulation", "dir_f3c4fbc4e901afa0a54d0623c5574aa7.html", "dir_f3c4fbc4e901afa0a54d0623c5574aa7" ],
[ "ciphers", "dir_4d6e05837bf820fb089a8a8cdf2f42b7.html", "dir_4d6e05837bf820fb089a8a8cdf2f42b7" ],
+ [ "cpu_scheduling_algorithms", "dir_cc8e79ed9d2b7756c78e8d0c87c6c0c7.html", "dir_cc8e79ed9d2b7756c78e8d0c87c6c0c7" ],
[ "data_structures", "dir_2e746e9d06bf2d8ff842208bcc6ebcfc.html", "dir_2e746e9d06bf2d8ff842208bcc6ebcfc" ],
[ "divide_and_conquer", "dir_93bc990c5cceb745f78af6949e9ef947.html", "dir_93bc990c5cceb745f78af6949e9ef947" ],
[ "dynamic_programming", "dir_8a20dd5bfd5341a725342bf72b6b686f.html", "dir_8a20dd5bfd5341a725342bf72b6b686f" ],
diff --git a/functions_a.html b/functions_a.html
index b6c1b9164..56bd8eb2f 100644
--- a/functions_a.html
+++ b/functions_a.html
@@ -103,6 +103,7 @@ $(document).ready(function(){initNavTree('functions_a.html',''); initResizable()
- add_digit() : large_number
- add_edge() : graph::Graph< T >, range_queries::heavy_light_decomposition::Tree< X >
- addEdge() : Graph, graph::HKGraph, graph::is_graph_bipartite::Graph
+- addProcess() : FCFS< S, T, E >
- addVertices() : Graph
- adj : graph::HKGraph, graph::is_graph_bipartite::Graph
- adjacency_list : graph::Graph< T >
diff --git a/functions_func_a.html b/functions_func_a.html
index 895b8d7b2..ce7a6fe56 100644
--- a/functions_func_a.html
+++ b/functions_func_a.html
@@ -101,6 +101,7 @@ $(document).ready(function(){initNavTree('functions_func_a.html',''); initResiza
- add_digit() : large_number
- add_edge() : graph::Graph< T >, range_queries::heavy_light_decomposition::Tree< X >
- addEdge() : Graph, graph::HKGraph, graph::is_graph_bipartite::Graph
+- addProcess() : FCFS< S, T, E >
- addVertices() : Graph
- arg() : Complex
- AyStarSearch() : machine_learning::aystar_search::AyStarSearch< Puzzle >
diff --git a/functions_func_i.html b/functions_func_i.html
index f6c10499c..b46256971 100644
--- a/functions_func_i.html
+++ b/functions_func_i.html
@@ -99,7 +99,7 @@ $(document).ready(function(){initNavTree('functions_func_i.html',''); initResiza
- init() : range_queries::heavy_light_decomposition::HLD< X >, range_queries::heavy_light_decomposition::Tree< X >
- inOrderIterative() : others::iterative_tree_traversals::BinaryTree
- insert() : binary_search_tree< T >, data_structures::linked_list::list, data_structures::list_array::list
-- Insert() : data_structures::tree_234::Tree234
+- Insert() : data_structures::tree_234::Tree234
- insert() : data_structures::trie, data_structures::trie_using_hashmap::Trie
- Insert() : operations_on_datastructures::trie_operations::Tnode
- insert() : probability::windowed_median::WindowedMedian, Trie
diff --git a/functions_func_o.html b/functions_func_o.html
index 2d36ddc58..524631ee8 100644
--- a/functions_func_o.html
+++ b/functions_func_o.html
@@ -105,7 +105,7 @@ $(document).ready(function(){initNavTree('functions_func_o.html',''); initResiza
- operator&() : uint128_t, uint256_t
- operator&&() : uint128_t, uint256_t
- operator&=() : uint128_t, uint256_t
-- operator()() : uint128_t, uint256_t
+- operator()() : Compare< S, T, E >, uint128_t, uint256_t
- operator*() : Complex, uint128_t, uint256_t
- operator*=() : large_number, uint128_t, uint256_t
- operator+() : Complex, uint128_t, uint256_t
diff --git a/functions_func_p.html b/functions_func_p.html
index 03847d40c..23611cdc6 100644
--- a/functions_func_p.html
+++ b/functions_func_p.html
@@ -103,6 +103,7 @@ $(document).ready(function(){initNavTree('functions_func_p.html',''); initResiza
- preOrderIterative() : others::iterative_tree_traversals::BinaryTree
- Print() : data_structures::tree_234::Tree234
- PrintNode() : data_structures::tree_234::Tree234
+- printResult() : FCFS< S, T, E >
- probability_density() : probability::geometric_dist::geometric_distribution
- push() : stack< Type >
- push_back() : data_structures::linked_list::list
diff --git a/functions_func_s.html b/functions_func_s.html
index 093c5d0f6..45a5ca001 100644
--- a/functions_func_s.html
+++ b/functions_func_s.html
@@ -94,6 +94,7 @@ $(document).ready(function(){initNavTree('functions_func_s.html',''); initResiza
- s -
- save_model() : machine_learning::neural_network::NeuralNetwork
+- scheduleForFcfs() : FCFS< S, T, E >
- search() : data_structures::linked_list::list, data_structures::trie, data_structures::trie_using_hashmap::Trie, Trie
- searchElement() : data_structures::SkipList
- SearchFreqSuggestions() : operations_on_datastructures::trie_operations::Tnode
diff --git a/functions_i.html b/functions_i.html
index 9c44e9eba..7f28ec0c7 100644
--- a/functions_i.html
+++ b/functions_i.html
@@ -99,7 +99,7 @@ $(document).ready(function(){initNavTree('functions_i.html',''); initResizable()
- init() : range_queries::heavy_light_decomposition::HLD< X >, range_queries::heavy_light_decomposition::Tree< X >
- inOrderIterative() : others::iterative_tree_traversals::BinaryTree
- insert() : binary_search_tree< T >, data_structures::linked_list::list, data_structures::list_array::list
-- Insert() : data_structures::tree_234::Tree234
+- Insert() : data_structures::tree_234::Tree234
- insert() : data_structures::trie, data_structures::trie_using_hashmap::Trie
- Insert() : operations_on_datastructures::trie_operations::Tnode
- insert() : probability::windowed_median::WindowedMedian, Trie
diff --git a/functions_o.html b/functions_o.html
index 6ac295c79..837e3e696 100644
--- a/functions_o.html
+++ b/functions_o.html
@@ -105,7 +105,7 @@ $(document).ready(function(){initNavTree('functions_o.html',''); initResizable()
- operator&() : uint128_t, uint256_t
- operator&&() : uint128_t, uint256_t
- operator&=() : uint128_t, uint256_t
-- operator()() : uint128_t, uint256_t
+- operator()() : Compare< S, T, E >, uint128_t, uint256_t
- operator*() : Complex, uint128_t, uint256_t
- operator*=() : large_number, uint128_t, uint256_t
- operator+() : Complex, large_number, uint128_t, uint256_t
diff --git a/functions_p.html b/functions_p.html
index 90430b6ff..183e64c23 100644
--- a/functions_p.html
+++ b/functions_p.html
@@ -110,6 +110,7 @@ $(document).ready(function(){initNavTree('functions_p.html',''); initResizable()
- preOrderIterative() : others::iterative_tree_traversals::BinaryTree
- Print() : data_structures::tree_234::Tree234
- PrintNode() : data_structures::tree_234::Tree234
+- printResult() : FCFS< S, T, E >
- probability_density() : probability::geometric_dist::geometric_distribution
- psucc : data_structures::linked_list::link
- ptrs : range_queries::perSegTree
diff --git a/functions_s.html b/functions_s.html
index d4dd818d0..32e7c85b4 100644
--- a/functions_s.html
+++ b/functions_s.html
@@ -96,6 +96,8 @@ $(document).ready(function(){initNavTree('functions_s.html',''); initResizable()
- s_size : range_queries::heavy_light_decomposition::SG< X >
- s_tree : range_queries::heavy_light_decomposition::SG< X >
- save_model() : machine_learning::neural_network::NeuralNetwork
+- schedule : FCFS< S, T, E >
+- scheduleForFcfs() : FCFS< S, T, E >
- search() : data_structures::linked_list::list, data_structures::trie, data_structures::trie_using_hashmap::Trie, Trie
- searchElement() : data_structures::SkipList
- SearchFreqSuggestions() : operations_on_datastructures::trie_operations::Tnode
diff --git a/functions_vars.html b/functions_vars.html
index 9752b512f..a47e938f3 100644
--- a/functions_vars.html
+++ b/functions_vars.html
@@ -217,6 +217,7 @@ $(document).ready(function(){initNavTree('functions_vars.html',''); initResizabl
- s -
- s_size : range_queries::heavy_light_decomposition::SG< X >
- s_tree : range_queries::heavy_light_decomposition::SG< X >
+- schedule : FCFS< S, T, E >
- side : graph::is_graph_bipartite::Graph
- size : stack< Type >
- size_ : binary_search_tree< T >
diff --git a/globals_func_g.html b/globals_func_g.html
index b8a49306e..dd9a8ec0e 100644
--- a/globals_func_g.html
+++ b/globals_func_g.html
@@ -96,6 +96,7 @@ $(document).ready(function(){initNavTree('globals_func_g.html',''); initResizabl
- gcd() : gcd_iterative_euclidean.cpp, gcd_of_n_numbers.cpp, gcd_recursive_euclidean.cpp, least_common_multiple.cpp
- genArray() : spiral_print.cpp
- get_clock_diff() : kohonen_som_topology.cpp, kohonen_som_trace.cpp
+- get_final_status() : fcfs_scheduling.cpp
- get_input() : ternary_search.cpp
- get_inverse() : ordinary_least_squares_regressor.cpp
- get_min_2d() : kohonen_som_topology.cpp
diff --git a/globals_func_i.html b/globals_func_i.html
index 7ce39a9c8..eaac1ff58 100644
--- a/globals_func_i.html
+++ b/globals_func_i.html
@@ -104,8 +104,8 @@ $(document).ready(function(){initNavTree('globals_func_i.html',''); initResizabl
- is_happy() : happy_number.cpp
- is_prime() : check_prime.cpp
- is_square() : ordinary_least_squares_regressor.cpp
-- isPrime() : modular_inverse_fermat_little_theorem.cpp
- IsPrime() : primality_test.cpp
+- isPrime() : modular_inverse_fermat_little_theorem.cpp
- it_ternary_search() : ternary_search.cpp
diff --git a/globals_func_m.html b/globals_func_m.html
index d58fdf390..875a674bd 100644
--- a/globals_func_m.html
+++ b/globals_func_m.html
@@ -93,7 +93,7 @@ $(document).ready(function(){initNavTree('globals_func_m.html',''); initResizabl
- m -
-- main() : graph_coloring.cpp, knight_tour.cpp, minimax.cpp, n_queens.cpp, n_queens_all_solution_optimised.cpp, nqueen_print_all_solutions.cpp, rat_maze.cpp, subarray_sum.cpp, subset_sum.cpp, sudoku_solve.cpp, wildcard_matching.cpp, count_of_set_bits.cpp, count_of_trailing_ciphers_in_factorial_n.cpp, hamming_distance.cpp, caesar_cipher.cpp, elliptic_curve_key_exchange.cpp, hill_cipher.cpp, morse_code.cpp, vigenere_cipher.cpp, xor_cipher.cpp, avltree.cpp, disjoint_set.cpp, linked_list.cpp, linkedlist_implentation_usingarray.cpp, list_array.cpp, queue_using_array.cpp, queue_using_two_stacks.cpp, reverse_a_linked_list.cpp, skip_list.cpp, sparse_table.cpp, tree_234.cpp, trie_modern.cpp, trie_tree.cpp, trie_using_hashmap.cpp, karatsuba_algorithm_for_fast_multiplication.cpp, 0_1_knapsack.cpp, abbreviation.cpp, coin_change_topdown.cpp, cut_rod.cpp, house_robber.cpp, kadane2.cpp, longest_increasing_subsequence.cpp, longest_palindromic_subsequence.cpp, minimum_edit_distance.cpp, palindrome_partitioning.cpp, shortest_common_supersequence.cpp, word_break.cpp, jarvis_algorithm.cpp, line_segment_intersection.cpp, bidirectional_dijkstra.cpp, breadth_first_search.cpp, connected_components.cpp, connected_components_with_dsu.cpp, depth_first_search.cpp, depth_first_search_with_stack.cpp, dijkstra.cpp, hamiltons_cycle.cpp, hopcroft_karp.cpp, is_graph_bipartite.cpp, lowest_common_ancestor.cpp, travelling_salesman_problem.cpp, spirograph.cpp, jumpgame.cpp, chaining.cpp, double_hash_hash_table.cpp, linear_probing_hash_table.cpp, md5.cpp, quadratic_probing_hash_table.cpp, sha1.cpp, gram_schmidt.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, neural_network.cpp, ordinary_least_squares_regressor.cpp, armstrong_number.cpp, binary_exponent.cpp, binomial_calculate.cpp, check_amicable_pair.cpp, check_factorial.cpp, check_prime.cpp, complex_numbers.cpp, double_factorial.cpp, eulers_totient_function.cpp, extended_euclid_algorithm.cpp, factorial.cpp, fast_power.cpp, fibonacci.cpp, fibonacci_fast.cpp, fibonacci_matrix_exponentiation.cpp, fibonacci_sum.cpp, finding_number_of_digits_in_a_number.cpp, gcd_iterative_euclidean.cpp, gcd_of_n_numbers.cpp, gcd_recursive_euclidean.cpp, integral_approximation.cpp, inv_sqrt.cpp, large_factorial.cpp, largest_power.cpp, lcm_sum.cpp, least_common_multiple.cpp, magic_number.cpp, miller_rabin.cpp, modular_division.cpp, modular_exponentiation.cpp, modular_inverse_fermat_little_theorem.cpp, n_bonacci.cpp, n_choose_r.cpp, ncr_modulo_p.cpp, number_of_positive_divisors.cpp, power_for_huge_numbers.cpp, power_of_two.cpp, prime_factorization.cpp, prime_numbers.cpp, primes_up_to_billion.cpp, realtime_stats.cpp, sieve_of_eratosthenes.cpp, sqrt_double.cpp, string_fibonacci.cpp, sum_of_binomial_coefficient.cpp, sum_of_digits.cpp, vector_cross_product.cpp, bisection_method.cpp, brent_method_extrema.cpp, false_position.cpp, gaussian_elimination.cpp, golden_search_extrema.cpp, lu_decompose.cpp, newton_raphson_method.cpp, ode_forward_euler.cpp, ode_midpoint_euler.cpp, ode_semi_implicit_euler.cpp, qr_decomposition.cpp, qr_eigen_values.cpp, rungekutta.cpp, successive_approximation.cpp, inorder_successor_of_bst.cpp, trie_multiple_search.cpp, buzz_number.cpp, decimal_to_hexadecimal.cpp, decimal_to_roman_numeral.cpp, fast_integer_input.cpp, happy_number.cpp, iterative_tree_traversals.cpp, kadanes3.cpp, lru_cache.cpp, matrix_exponentiation.cpp, palindrome_of_number.cpp, pascal_triangle.cpp, postfix_evaluation.cpp, primality_test.cpp, smallest_circle.cpp, sparse_matrix.cpp, spiral_print.cpp, stairs_pattern.cpp, tower_of_hanoi.cpp, vector_important_functions.cpp, addition_rule.cpp, bayes_theorem.cpp, binomial_dist.cpp, geometric_dist.cpp, poisson_dist.cpp, windowed_median.cpp, fenwick_tree.cpp, heavy_light_decomposition.cpp, persistent_seg_tree_lazy_prop.cpp, prefix_sum_array.cpp, sparse_table.cpp, binary_search.cpp, exponential_search.cpp, fibonacci_search.cpp, floyd_cycle_detection_algo.cpp, hash_search.cpp, interpolation_search.cpp, interpolation_search2.cpp, linear_search.cpp, median_search.cpp, saddleback_search.cpp, sublist_search.cpp, ternary_search.cpp, text_search.cpp, bogo_sort.cpp, comb_sort.cpp, count_inversions.cpp, cycle_sort.cpp, dnf_sort.cpp, gnome_sort.cpp, heap_sort.cpp, insertion_sort.cpp, merge_insertion_sort.cpp, merge_sort.cpp, pancake_sort.cpp, pigeonhole_sort.cpp, quick_sort.cpp, quick_sort_3.cpp, radix_sort2.cpp, random_pivot_quick_sort.cpp, recursive_bubble_sort.cpp, selection_sort_recursive.cpp, shell_sort2.cpp, strand_sort.cpp, wave_sort.cpp, brute_force_string_searching.cpp, horspool.cpp, knuth_morris_pratt.cpp, manacher_algorithm.cpp, rabin_karp.cpp, z_function.cpp
+- main() : graph_coloring.cpp, knight_tour.cpp, minimax.cpp, n_queens.cpp, n_queens_all_solution_optimised.cpp, nqueen_print_all_solutions.cpp, rat_maze.cpp, subarray_sum.cpp, subset_sum.cpp, sudoku_solve.cpp, wildcard_matching.cpp, count_of_set_bits.cpp, count_of_trailing_ciphers_in_factorial_n.cpp, hamming_distance.cpp, caesar_cipher.cpp, elliptic_curve_key_exchange.cpp, hill_cipher.cpp, morse_code.cpp, vigenere_cipher.cpp, xor_cipher.cpp, fcfs_scheduling.cpp, avltree.cpp, disjoint_set.cpp, linked_list.cpp, linkedlist_implentation_usingarray.cpp, list_array.cpp, queue_using_array.cpp, queue_using_two_stacks.cpp, reverse_a_linked_list.cpp, skip_list.cpp, sparse_table.cpp, tree_234.cpp, trie_modern.cpp, trie_tree.cpp, trie_using_hashmap.cpp, karatsuba_algorithm_for_fast_multiplication.cpp, 0_1_knapsack.cpp, abbreviation.cpp, coin_change_topdown.cpp, cut_rod.cpp, house_robber.cpp, kadane2.cpp, longest_increasing_subsequence.cpp, longest_palindromic_subsequence.cpp, minimum_edit_distance.cpp, palindrome_partitioning.cpp, shortest_common_supersequence.cpp, word_break.cpp, jarvis_algorithm.cpp, line_segment_intersection.cpp, bidirectional_dijkstra.cpp, breadth_first_search.cpp, connected_components.cpp, connected_components_with_dsu.cpp, depth_first_search.cpp, depth_first_search_with_stack.cpp, dijkstra.cpp, hamiltons_cycle.cpp, hopcroft_karp.cpp, is_graph_bipartite.cpp, lowest_common_ancestor.cpp, travelling_salesman_problem.cpp, spirograph.cpp, jumpgame.cpp, chaining.cpp, double_hash_hash_table.cpp, linear_probing_hash_table.cpp, md5.cpp, quadratic_probing_hash_table.cpp, sha1.cpp, gram_schmidt.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, neural_network.cpp, ordinary_least_squares_regressor.cpp, armstrong_number.cpp, binary_exponent.cpp, binomial_calculate.cpp, check_amicable_pair.cpp, check_factorial.cpp, check_prime.cpp, complex_numbers.cpp, double_factorial.cpp, eulers_totient_function.cpp, extended_euclid_algorithm.cpp, factorial.cpp, fast_power.cpp, fibonacci.cpp, fibonacci_fast.cpp, fibonacci_matrix_exponentiation.cpp, fibonacci_sum.cpp, finding_number_of_digits_in_a_number.cpp, gcd_iterative_euclidean.cpp, gcd_of_n_numbers.cpp, gcd_recursive_euclidean.cpp, integral_approximation.cpp, inv_sqrt.cpp, large_factorial.cpp, largest_power.cpp, lcm_sum.cpp, least_common_multiple.cpp, magic_number.cpp, miller_rabin.cpp, modular_division.cpp, modular_exponentiation.cpp, modular_inverse_fermat_little_theorem.cpp, n_bonacci.cpp, n_choose_r.cpp, ncr_modulo_p.cpp, number_of_positive_divisors.cpp, power_for_huge_numbers.cpp, power_of_two.cpp, prime_factorization.cpp, prime_numbers.cpp, primes_up_to_billion.cpp, realtime_stats.cpp, sieve_of_eratosthenes.cpp, sqrt_double.cpp, string_fibonacci.cpp, sum_of_binomial_coefficient.cpp, sum_of_digits.cpp, vector_cross_product.cpp, bisection_method.cpp, brent_method_extrema.cpp, false_position.cpp, gaussian_elimination.cpp, golden_search_extrema.cpp, lu_decompose.cpp, newton_raphson_method.cpp, ode_forward_euler.cpp, ode_midpoint_euler.cpp, ode_semi_implicit_euler.cpp, qr_decomposition.cpp, qr_eigen_values.cpp, rungekutta.cpp, successive_approximation.cpp, inorder_successor_of_bst.cpp, trie_multiple_search.cpp, buzz_number.cpp, decimal_to_hexadecimal.cpp, decimal_to_roman_numeral.cpp, fast_integer_input.cpp, happy_number.cpp, iterative_tree_traversals.cpp, kadanes3.cpp, lru_cache.cpp, matrix_exponentiation.cpp, palindrome_of_number.cpp, pascal_triangle.cpp, postfix_evaluation.cpp, primality_test.cpp, smallest_circle.cpp, sparse_matrix.cpp, spiral_print.cpp, stairs_pattern.cpp, tower_of_hanoi.cpp, vector_important_functions.cpp, addition_rule.cpp, bayes_theorem.cpp, binomial_dist.cpp, geometric_dist.cpp, poisson_dist.cpp, windowed_median.cpp, fenwick_tree.cpp, heavy_light_decomposition.cpp, persistent_seg_tree_lazy_prop.cpp, prefix_sum_array.cpp, sparse_table.cpp, binary_search.cpp, exponential_search.cpp, fibonacci_search.cpp, floyd_cycle_detection_algo.cpp, hash_search.cpp, interpolation_search.cpp, interpolation_search2.cpp, linear_search.cpp, median_search.cpp, saddleback_search.cpp, sublist_search.cpp, ternary_search.cpp, text_search.cpp, bogo_sort.cpp, comb_sort.cpp, count_inversions.cpp, cycle_sort.cpp, dnf_sort.cpp, gnome_sort.cpp, heap_sort.cpp, insertion_sort.cpp, merge_insertion_sort.cpp, merge_sort.cpp, pancake_sort.cpp, pigeonhole_sort.cpp, quick_sort.cpp, quick_sort_3.cpp, radix_sort2.cpp, random_pivot_quick_sort.cpp, recursive_bubble_sort.cpp, selection_sort_recursive.cpp, shell_sort2.cpp, strand_sort.cpp, wave_sort.cpp, brute_force_string_searching.cpp, horspool.cpp, knuth_morris_pratt.cpp, manacher_algorithm.cpp, rabin_karp.cpp, z_function.cpp
- mat_mul() : qr_eigen_values.cpp
- max_subarray_sum() : kadanes3.cpp
- merge() : merge_sort.cpp
diff --git a/globals_func_s.html b/globals_func_s.html
index a466aaaa6..660161a70 100644
--- a/globals_func_s.html
+++ b/globals_func_s.html
@@ -104,9 +104,10 @@ $(document).ready(function(){initNavTree('globals_func_s.html',''); initResizabl
- show_array() : bogo_sort.cpp
- show_data() : shell_sort2.cpp
- show_pascal() : pascal_triangle.cpp
-- sieve() : sieve_of_eratosthenes.cpp
- Sieve() : primes_up_to_billion.cpp
+- sieve() : sieve_of_eratosthenes.cpp
- SieveOfEratosthenes() : prime_factorization.cpp
+- sortcol() : fcfs_scheduling.cpp
- spiralPrint() : spiral_print.cpp
- Sqrt() : sqrt_double.cpp
- Standard_InvSqrt() : inv_sqrt.cpp
diff --git a/globals_func_t.html b/globals_func_t.html
index 71ab7f4f2..bc57baac7 100644
--- a/globals_func_t.html
+++ b/globals_func_t.html
@@ -94,7 +94,7 @@ $(document).ready(function(){initNavTree('globals_func_t.html',''); initResizabl
- t -
- ternary_search() : ternary_search.cpp
-- test() : rat_maze.cpp, subarray_sum.cpp, subset_sum.cpp, wildcard_matching.cpp, count_of_set_bits.cpp, count_of_trailing_ciphers_in_factorial_n.cpp, hamming_distance.cpp, caesar_cipher.cpp, elliptic_curve_key_exchange.cpp, morse_code.cpp, vigenere_cipher.cpp, xor_cipher.cpp, list_array.cpp, reverse_a_linked_list.cpp, sparse_table.cpp, trie_tree.cpp, trie_using_hashmap.cpp, karatsuba_algorithm_for_fast_multiplication.cpp, 0_1_knapsack.cpp, abbreviation.cpp, coin_change_topdown.cpp, cut_rod.cpp, house_robber.cpp, longest_increasing_subsequence.cpp, longest_palindromic_subsequence.cpp, minimum_edit_distance.cpp, palindrome_partitioning.cpp, shortest_common_supersequence.cpp, word_break.cpp, jarvis_algorithm.cpp, connected_components_with_dsu.cpp, is_graph_bipartite.cpp, jumpgame.cpp, md5.cpp, sha1.cpp, gram_schmidt.cpp, neural_network.cpp, armstrong_number.cpp, check_amicable_pair.cpp, double_factorial.cpp, fibonacci.cpp, fibonacci_matrix_exponentiation.cpp, fibonacci_sum.cpp, finding_number_of_digits_in_a_number.cpp, inv_sqrt.cpp, largest_power.cpp, lcm_sum.cpp, modular_division.cpp, modular_exponentiation.cpp, n_bonacci.cpp, n_choose_r.cpp, sum_of_binomial_coefficient.cpp, sum_of_digits.cpp, vector_cross_product.cpp, rungekutta.cpp, inorder_successor_of_bst.cpp, trie_multiple_search.cpp, kadanes3.cpp, smallest_circle.cpp, geometric_dist.cpp, windowed_median.cpp, persistent_seg_tree_lazy_prop.cpp, prefix_sum_array.cpp, floyd_cycle_detection_algo.cpp, median_search.cpp, saddleback_search.cpp, sublist_search.cpp, text_search.cpp, bogo_sort.cpp, count_inversions.cpp, cycle_sort.cpp, dnf_sort.cpp, gnome_sort.cpp, heap_sort.cpp, merge_insertion_sort.cpp, pancake_sort.cpp, random_pivot_quick_sort.cpp, recursive_bubble_sort.cpp, selection_sort_recursive.cpp, strand_sort.cpp, wave_sort.cpp, wiggle_sort.cpp, horspool.cpp, manacher_algorithm.cpp, z_function.cpp
+- test() : rat_maze.cpp, subarray_sum.cpp, subset_sum.cpp, wildcard_matching.cpp, count_of_set_bits.cpp, count_of_trailing_ciphers_in_factorial_n.cpp, hamming_distance.cpp, caesar_cipher.cpp, elliptic_curve_key_exchange.cpp, morse_code.cpp, vigenere_cipher.cpp, xor_cipher.cpp, fcfs_scheduling.cpp, list_array.cpp, reverse_a_linked_list.cpp, sparse_table.cpp, trie_tree.cpp, trie_using_hashmap.cpp, karatsuba_algorithm_for_fast_multiplication.cpp, 0_1_knapsack.cpp, abbreviation.cpp, coin_change_topdown.cpp, cut_rod.cpp, house_robber.cpp, longest_increasing_subsequence.cpp, longest_palindromic_subsequence.cpp, minimum_edit_distance.cpp, palindrome_partitioning.cpp, shortest_common_supersequence.cpp, word_break.cpp, jarvis_algorithm.cpp, connected_components_with_dsu.cpp, is_graph_bipartite.cpp, jumpgame.cpp, md5.cpp, sha1.cpp, gram_schmidt.cpp, neural_network.cpp, armstrong_number.cpp, check_amicable_pair.cpp, double_factorial.cpp, fibonacci.cpp, fibonacci_matrix_exponentiation.cpp, fibonacci_sum.cpp, finding_number_of_digits_in_a_number.cpp, inv_sqrt.cpp, largest_power.cpp, lcm_sum.cpp, modular_division.cpp, modular_exponentiation.cpp, n_bonacci.cpp, n_choose_r.cpp, sum_of_binomial_coefficient.cpp, sum_of_digits.cpp, vector_cross_product.cpp, rungekutta.cpp, inorder_successor_of_bst.cpp, trie_multiple_search.cpp, kadanes3.cpp, smallest_circle.cpp, geometric_dist.cpp, windowed_median.cpp, persistent_seg_tree_lazy_prop.cpp, prefix_sum_array.cpp, floyd_cycle_detection_algo.cpp, median_search.cpp, saddleback_search.cpp, sublist_search.cpp, text_search.cpp, bogo_sort.cpp, count_inversions.cpp, cycle_sort.cpp, dnf_sort.cpp, gnome_sort.cpp, heap_sort.cpp, merge_insertion_sort.cpp, pancake_sort.cpp, random_pivot_quick_sort.cpp, recursive_bubble_sort.cpp, selection_sort_recursive.cpp, strand_sort.cpp, wave_sort.cpp, wiggle_sort.cpp, horspool.cpp, manacher_algorithm.cpp, z_function.cpp
- test1() : hill_cipher.cpp, tree_234.cpp, hamiltons_cycle.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, large_factorial.cpp, sum_of_digits.cpp, brent_method_extrema.cpp, durand_kerner_roots.cpp, golden_search_extrema.cpp, lu_decompose.cpp, qr_eigen_values.cpp, iterative_tree_traversals.cpp
- test2() : hill_cipher.cpp, tree_234.cpp, hamiltons_cycle.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, large_factorial.cpp, sum_of_digits.cpp, brent_method_extrema.cpp, durand_kerner_roots.cpp, golden_search_extrema.cpp, lu_decompose.cpp, qr_eigen_values.cpp, iterative_tree_traversals.cpp, smallest_circle.cpp
- test3() : hamiltons_cycle.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, brent_method_extrema.cpp, golden_search_extrema.cpp, iterative_tree_traversals.cpp, smallest_circle.cpp
diff --git a/globals_g.html b/globals_g.html
index 3ac0c9f47..5ba25513f 100644
--- a/globals_g.html
+++ b/globals_g.html
@@ -96,6 +96,7 @@ $(document).ready(function(){initNavTree('globals_g.html',''); initResizable();
- gcd() : gcd_iterative_euclidean.cpp, gcd_of_n_numbers.cpp, gcd_recursive_euclidean.cpp, least_common_multiple.cpp
- genArray() : spiral_print.cpp
- get_clock_diff() : kohonen_som_topology.cpp, kohonen_som_trace.cpp
+- get_final_status() : fcfs_scheduling.cpp
- get_input() : ternary_search.cpp
- get_inverse() : ordinary_least_squares_regressor.cpp
- get_min_2d() : kohonen_som_topology.cpp
diff --git a/globals_i.html b/globals_i.html
index b5d750823..d3d28f433 100644
--- a/globals_i.html
+++ b/globals_i.html
@@ -105,9 +105,9 @@ $(document).ready(function(){initNavTree('globals_i.html',''); initResizable();
- is_happy() : happy_number.cpp
- is_prime() : check_prime.cpp
- is_square() : ordinary_least_squares_regressor.cpp
-- isprime : prime_factorization.cpp
-- isPrime() : modular_inverse_fermat_little_theorem.cpp
- IsPrime() : primality_test.cpp
+- isPrime() : modular_inverse_fermat_little_theorem.cpp
+- isprime : prime_factorization.cpp
- it_ternary_search() : ternary_search.cpp
diff --git a/globals_m.html b/globals_m.html
index 535edf2d6..20a5e3871 100644
--- a/globals_m.html
+++ b/globals_m.html
@@ -93,7 +93,7 @@ $(document).ready(function(){initNavTree('globals_m.html',''); initResizable();
Here is a list of all documented file members with links to the documentation:
- m -
-- main() : graph_coloring.cpp, knight_tour.cpp, minimax.cpp, n_queens.cpp, n_queens_all_solution_optimised.cpp, nqueen_print_all_solutions.cpp, rat_maze.cpp, subarray_sum.cpp, subset_sum.cpp, sudoku_solve.cpp, wildcard_matching.cpp, count_of_set_bits.cpp, count_of_trailing_ciphers_in_factorial_n.cpp, hamming_distance.cpp, caesar_cipher.cpp, elliptic_curve_key_exchange.cpp, hill_cipher.cpp, morse_code.cpp, vigenere_cipher.cpp, xor_cipher.cpp, avltree.cpp, disjoint_set.cpp, linked_list.cpp, linkedlist_implentation_usingarray.cpp, list_array.cpp, queue_using_array.cpp, queue_using_two_stacks.cpp, reverse_a_linked_list.cpp, skip_list.cpp, sparse_table.cpp, tree_234.cpp, trie_modern.cpp, trie_tree.cpp, trie_using_hashmap.cpp, karatsuba_algorithm_for_fast_multiplication.cpp, 0_1_knapsack.cpp, abbreviation.cpp, coin_change_topdown.cpp, cut_rod.cpp, house_robber.cpp, kadane2.cpp, longest_increasing_subsequence.cpp, longest_palindromic_subsequence.cpp, minimum_edit_distance.cpp, palindrome_partitioning.cpp, shortest_common_supersequence.cpp, word_break.cpp, jarvis_algorithm.cpp, line_segment_intersection.cpp, bidirectional_dijkstra.cpp, breadth_first_search.cpp, connected_components.cpp, connected_components_with_dsu.cpp, depth_first_search.cpp, depth_first_search_with_stack.cpp, dijkstra.cpp, hamiltons_cycle.cpp, hopcroft_karp.cpp, is_graph_bipartite.cpp, lowest_common_ancestor.cpp, travelling_salesman_problem.cpp, spirograph.cpp, jumpgame.cpp, chaining.cpp, double_hash_hash_table.cpp, linear_probing_hash_table.cpp, md5.cpp, quadratic_probing_hash_table.cpp, sha1.cpp, gram_schmidt.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, neural_network.cpp, ordinary_least_squares_regressor.cpp, armstrong_number.cpp, binary_exponent.cpp, binomial_calculate.cpp, check_amicable_pair.cpp, check_factorial.cpp, check_prime.cpp, complex_numbers.cpp, double_factorial.cpp, eulers_totient_function.cpp, extended_euclid_algorithm.cpp, factorial.cpp, fast_power.cpp, fibonacci.cpp, fibonacci_fast.cpp, fibonacci_matrix_exponentiation.cpp, fibonacci_sum.cpp, finding_number_of_digits_in_a_number.cpp, gcd_iterative_euclidean.cpp, gcd_of_n_numbers.cpp, gcd_recursive_euclidean.cpp, integral_approximation.cpp, inv_sqrt.cpp, large_factorial.cpp, largest_power.cpp, lcm_sum.cpp, least_common_multiple.cpp, magic_number.cpp, miller_rabin.cpp, modular_division.cpp, modular_exponentiation.cpp, modular_inverse_fermat_little_theorem.cpp, n_bonacci.cpp, n_choose_r.cpp, ncr_modulo_p.cpp, number_of_positive_divisors.cpp, power_for_huge_numbers.cpp, power_of_two.cpp, prime_factorization.cpp, prime_numbers.cpp, primes_up_to_billion.cpp, realtime_stats.cpp, sieve_of_eratosthenes.cpp, sqrt_double.cpp, string_fibonacci.cpp, sum_of_binomial_coefficient.cpp, sum_of_digits.cpp, vector_cross_product.cpp, bisection_method.cpp, brent_method_extrema.cpp, false_position.cpp, gaussian_elimination.cpp, golden_search_extrema.cpp, lu_decompose.cpp, newton_raphson_method.cpp, ode_forward_euler.cpp, ode_midpoint_euler.cpp, ode_semi_implicit_euler.cpp, qr_decomposition.cpp, qr_eigen_values.cpp, rungekutta.cpp, successive_approximation.cpp, inorder_successor_of_bst.cpp, trie_multiple_search.cpp, buzz_number.cpp, decimal_to_hexadecimal.cpp, decimal_to_roman_numeral.cpp, fast_integer_input.cpp, happy_number.cpp, iterative_tree_traversals.cpp, kadanes3.cpp, lru_cache.cpp, matrix_exponentiation.cpp, palindrome_of_number.cpp, pascal_triangle.cpp, postfix_evaluation.cpp, primality_test.cpp, smallest_circle.cpp, sparse_matrix.cpp, spiral_print.cpp, stairs_pattern.cpp, tower_of_hanoi.cpp, vector_important_functions.cpp, addition_rule.cpp, bayes_theorem.cpp, binomial_dist.cpp, geometric_dist.cpp, poisson_dist.cpp, windowed_median.cpp, fenwick_tree.cpp, heavy_light_decomposition.cpp, persistent_seg_tree_lazy_prop.cpp, prefix_sum_array.cpp, sparse_table.cpp, binary_search.cpp, exponential_search.cpp, fibonacci_search.cpp, floyd_cycle_detection_algo.cpp, hash_search.cpp, interpolation_search.cpp, interpolation_search2.cpp, linear_search.cpp, median_search.cpp, saddleback_search.cpp, sublist_search.cpp, ternary_search.cpp, text_search.cpp, bogo_sort.cpp, comb_sort.cpp, count_inversions.cpp, cycle_sort.cpp, dnf_sort.cpp, gnome_sort.cpp, heap_sort.cpp, insertion_sort.cpp, merge_insertion_sort.cpp, merge_sort.cpp, pancake_sort.cpp, pigeonhole_sort.cpp, quick_sort.cpp, quick_sort_3.cpp, radix_sort2.cpp, random_pivot_quick_sort.cpp, recursive_bubble_sort.cpp, selection_sort_recursive.cpp, shell_sort2.cpp, strand_sort.cpp, wave_sort.cpp, brute_force_string_searching.cpp, horspool.cpp, knuth_morris_pratt.cpp, manacher_algorithm.cpp, rabin_karp.cpp, z_function.cpp
+- main() : graph_coloring.cpp, knight_tour.cpp, minimax.cpp, n_queens.cpp, n_queens_all_solution_optimised.cpp, nqueen_print_all_solutions.cpp, rat_maze.cpp, subarray_sum.cpp, subset_sum.cpp, sudoku_solve.cpp, wildcard_matching.cpp, count_of_set_bits.cpp, count_of_trailing_ciphers_in_factorial_n.cpp, hamming_distance.cpp, caesar_cipher.cpp, elliptic_curve_key_exchange.cpp, hill_cipher.cpp, morse_code.cpp, vigenere_cipher.cpp, xor_cipher.cpp, fcfs_scheduling.cpp, avltree.cpp, disjoint_set.cpp, linked_list.cpp, linkedlist_implentation_usingarray.cpp, list_array.cpp, queue_using_array.cpp, queue_using_two_stacks.cpp, reverse_a_linked_list.cpp, skip_list.cpp, sparse_table.cpp, tree_234.cpp, trie_modern.cpp, trie_tree.cpp, trie_using_hashmap.cpp, karatsuba_algorithm_for_fast_multiplication.cpp, 0_1_knapsack.cpp, abbreviation.cpp, coin_change_topdown.cpp, cut_rod.cpp, house_robber.cpp, kadane2.cpp, longest_increasing_subsequence.cpp, longest_palindromic_subsequence.cpp, minimum_edit_distance.cpp, palindrome_partitioning.cpp, shortest_common_supersequence.cpp, word_break.cpp, jarvis_algorithm.cpp, line_segment_intersection.cpp, bidirectional_dijkstra.cpp, breadth_first_search.cpp, connected_components.cpp, connected_components_with_dsu.cpp, depth_first_search.cpp, depth_first_search_with_stack.cpp, dijkstra.cpp, hamiltons_cycle.cpp, hopcroft_karp.cpp, is_graph_bipartite.cpp, lowest_common_ancestor.cpp, travelling_salesman_problem.cpp, spirograph.cpp, jumpgame.cpp, chaining.cpp, double_hash_hash_table.cpp, linear_probing_hash_table.cpp, md5.cpp, quadratic_probing_hash_table.cpp, sha1.cpp, gram_schmidt.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, neural_network.cpp, ordinary_least_squares_regressor.cpp, armstrong_number.cpp, binary_exponent.cpp, binomial_calculate.cpp, check_amicable_pair.cpp, check_factorial.cpp, check_prime.cpp, complex_numbers.cpp, double_factorial.cpp, eulers_totient_function.cpp, extended_euclid_algorithm.cpp, factorial.cpp, fast_power.cpp, fibonacci.cpp, fibonacci_fast.cpp, fibonacci_matrix_exponentiation.cpp, fibonacci_sum.cpp, finding_number_of_digits_in_a_number.cpp, gcd_iterative_euclidean.cpp, gcd_of_n_numbers.cpp, gcd_recursive_euclidean.cpp, integral_approximation.cpp, inv_sqrt.cpp, large_factorial.cpp, largest_power.cpp, lcm_sum.cpp, least_common_multiple.cpp, magic_number.cpp, miller_rabin.cpp, modular_division.cpp, modular_exponentiation.cpp, modular_inverse_fermat_little_theorem.cpp, n_bonacci.cpp, n_choose_r.cpp, ncr_modulo_p.cpp, number_of_positive_divisors.cpp, power_for_huge_numbers.cpp, power_of_two.cpp, prime_factorization.cpp, prime_numbers.cpp, primes_up_to_billion.cpp, realtime_stats.cpp, sieve_of_eratosthenes.cpp, sqrt_double.cpp, string_fibonacci.cpp, sum_of_binomial_coefficient.cpp, sum_of_digits.cpp, vector_cross_product.cpp, bisection_method.cpp, brent_method_extrema.cpp, false_position.cpp, gaussian_elimination.cpp, golden_search_extrema.cpp, lu_decompose.cpp, newton_raphson_method.cpp, ode_forward_euler.cpp, ode_midpoint_euler.cpp, ode_semi_implicit_euler.cpp, qr_decomposition.cpp, qr_eigen_values.cpp, rungekutta.cpp, successive_approximation.cpp, inorder_successor_of_bst.cpp, trie_multiple_search.cpp, buzz_number.cpp, decimal_to_hexadecimal.cpp, decimal_to_roman_numeral.cpp, fast_integer_input.cpp, happy_number.cpp, iterative_tree_traversals.cpp, kadanes3.cpp, lru_cache.cpp, matrix_exponentiation.cpp, palindrome_of_number.cpp, pascal_triangle.cpp, postfix_evaluation.cpp, primality_test.cpp, smallest_circle.cpp, sparse_matrix.cpp, spiral_print.cpp, stairs_pattern.cpp, tower_of_hanoi.cpp, vector_important_functions.cpp, addition_rule.cpp, bayes_theorem.cpp, binomial_dist.cpp, geometric_dist.cpp, poisson_dist.cpp, windowed_median.cpp, fenwick_tree.cpp, heavy_light_decomposition.cpp, persistent_seg_tree_lazy_prop.cpp, prefix_sum_array.cpp, sparse_table.cpp, binary_search.cpp, exponential_search.cpp, fibonacci_search.cpp, floyd_cycle_detection_algo.cpp, hash_search.cpp, interpolation_search.cpp, interpolation_search2.cpp, linear_search.cpp, median_search.cpp, saddleback_search.cpp, sublist_search.cpp, ternary_search.cpp, text_search.cpp, bogo_sort.cpp, comb_sort.cpp, count_inversions.cpp, cycle_sort.cpp, dnf_sort.cpp, gnome_sort.cpp, heap_sort.cpp, insertion_sort.cpp, merge_insertion_sort.cpp, merge_sort.cpp, pancake_sort.cpp, pigeonhole_sort.cpp, quick_sort.cpp, quick_sort_3.cpp, radix_sort2.cpp, random_pivot_quick_sort.cpp, recursive_bubble_sort.cpp, selection_sort_recursive.cpp, shell_sort2.cpp, strand_sort.cpp, wave_sort.cpp, brute_force_string_searching.cpp, horspool.cpp, knuth_morris_pratt.cpp, manacher_algorithm.cpp, rabin_karp.cpp, z_function.cpp
- mat_mul() : qr_eigen_values.cpp
- mat_size : matrix_exponentiation.cpp
- matrix : lu_decomposition.h
diff --git a/globals_p.html b/globals_p.html
index 0e47ba48a..73d842724 100644
--- a/globals_p.html
+++ b/globals_p.html
@@ -105,8 +105,8 @@ $(document).ready(function(){initNavTree('globals_p.html',''); initResizable();
- pop() : paranthesis_matching.cpp
- power() : power_for_huge_numbers.cpp, matrix_exponentiation.cpp
- predict_OLS_regressor() : ordinary_least_squares_regressor.cpp
-- prime : primes_up_to_billion.cpp
- PRIME : rabin_karp.cpp
+- prime : primes_up_to_billion.cpp
- prime_factorization() : prime_factorization.cpp
- prime_numbers : prime_factorization.cpp
- primes() : prime_numbers.cpp
diff --git a/globals_s.html b/globals_s.html
index f161f7de4..d77d8bf54 100644
--- a/globals_s.html
+++ b/globals_s.html
@@ -104,9 +104,10 @@ $(document).ready(function(){initNavTree('globals_s.html',''); initResizable();
- show_array() : bogo_sort.cpp
- show_data() : shell_sort2.cpp
- show_pascal() : pascal_triangle.cpp
-- sieve() : sieve_of_eratosthenes.cpp
- Sieve() : primes_up_to_billion.cpp
+- sieve() : sieve_of_eratosthenes.cpp
- SieveOfEratosthenes() : prime_factorization.cpp
+- sortcol() : fcfs_scheduling.cpp
- spiralPrint() : spiral_print.cpp
- Sqrt() : sqrt_double.cpp
- stack : paranthesis_matching.cpp
diff --git a/globals_t.html b/globals_t.html
index e9776bdb2..4be523508 100644
--- a/globals_t.html
+++ b/globals_t.html
@@ -94,7 +94,7 @@ $(document).ready(function(){initNavTree('globals_t.html',''); initResizable();
- t -
- ternary_search() : ternary_search.cpp
-- test() : rat_maze.cpp, subarray_sum.cpp, subset_sum.cpp, wildcard_matching.cpp, count_of_set_bits.cpp, count_of_trailing_ciphers_in_factorial_n.cpp, hamming_distance.cpp, caesar_cipher.cpp, elliptic_curve_key_exchange.cpp, morse_code.cpp, vigenere_cipher.cpp, xor_cipher.cpp, list_array.cpp, reverse_a_linked_list.cpp, sparse_table.cpp, trie_tree.cpp, trie_using_hashmap.cpp, karatsuba_algorithm_for_fast_multiplication.cpp, 0_1_knapsack.cpp, abbreviation.cpp, coin_change_topdown.cpp, cut_rod.cpp, house_robber.cpp, longest_increasing_subsequence.cpp, longest_palindromic_subsequence.cpp, minimum_edit_distance.cpp, palindrome_partitioning.cpp, shortest_common_supersequence.cpp, word_break.cpp, jarvis_algorithm.cpp, connected_components_with_dsu.cpp, is_graph_bipartite.cpp, jumpgame.cpp, md5.cpp, sha1.cpp, gram_schmidt.cpp, neural_network.cpp, armstrong_number.cpp, check_amicable_pair.cpp, double_factorial.cpp, fibonacci.cpp, fibonacci_matrix_exponentiation.cpp, fibonacci_sum.cpp, finding_number_of_digits_in_a_number.cpp, inv_sqrt.cpp, largest_power.cpp, lcm_sum.cpp, modular_division.cpp, modular_exponentiation.cpp, n_bonacci.cpp, n_choose_r.cpp, sum_of_binomial_coefficient.cpp, sum_of_digits.cpp, vector_cross_product.cpp, rungekutta.cpp, inorder_successor_of_bst.cpp, trie_multiple_search.cpp, kadanes3.cpp, smallest_circle.cpp, geometric_dist.cpp, windowed_median.cpp, persistent_seg_tree_lazy_prop.cpp, prefix_sum_array.cpp, floyd_cycle_detection_algo.cpp, median_search.cpp, saddleback_search.cpp, sublist_search.cpp, text_search.cpp, bogo_sort.cpp, count_inversions.cpp, cycle_sort.cpp, dnf_sort.cpp, gnome_sort.cpp, heap_sort.cpp, merge_insertion_sort.cpp, pancake_sort.cpp, random_pivot_quick_sort.cpp, recursive_bubble_sort.cpp, selection_sort_recursive.cpp, strand_sort.cpp, wave_sort.cpp, wiggle_sort.cpp, horspool.cpp, manacher_algorithm.cpp, z_function.cpp
+- test() : rat_maze.cpp, subarray_sum.cpp, subset_sum.cpp, wildcard_matching.cpp, count_of_set_bits.cpp, count_of_trailing_ciphers_in_factorial_n.cpp, hamming_distance.cpp, caesar_cipher.cpp, elliptic_curve_key_exchange.cpp, morse_code.cpp, vigenere_cipher.cpp, xor_cipher.cpp, fcfs_scheduling.cpp, list_array.cpp, reverse_a_linked_list.cpp, sparse_table.cpp, trie_tree.cpp, trie_using_hashmap.cpp, karatsuba_algorithm_for_fast_multiplication.cpp, 0_1_knapsack.cpp, abbreviation.cpp, coin_change_topdown.cpp, cut_rod.cpp, house_robber.cpp, longest_increasing_subsequence.cpp, longest_palindromic_subsequence.cpp, minimum_edit_distance.cpp, palindrome_partitioning.cpp, shortest_common_supersequence.cpp, word_break.cpp, jarvis_algorithm.cpp, connected_components_with_dsu.cpp, is_graph_bipartite.cpp, jumpgame.cpp, md5.cpp, sha1.cpp, gram_schmidt.cpp, neural_network.cpp, armstrong_number.cpp, check_amicable_pair.cpp, double_factorial.cpp, fibonacci.cpp, fibonacci_matrix_exponentiation.cpp, fibonacci_sum.cpp, finding_number_of_digits_in_a_number.cpp, inv_sqrt.cpp, largest_power.cpp, lcm_sum.cpp, modular_division.cpp, modular_exponentiation.cpp, n_bonacci.cpp, n_choose_r.cpp, sum_of_binomial_coefficient.cpp, sum_of_digits.cpp, vector_cross_product.cpp, rungekutta.cpp, inorder_successor_of_bst.cpp, trie_multiple_search.cpp, kadanes3.cpp, smallest_circle.cpp, geometric_dist.cpp, windowed_median.cpp, persistent_seg_tree_lazy_prop.cpp, prefix_sum_array.cpp, floyd_cycle_detection_algo.cpp, median_search.cpp, saddleback_search.cpp, sublist_search.cpp, text_search.cpp, bogo_sort.cpp, count_inversions.cpp, cycle_sort.cpp, dnf_sort.cpp, gnome_sort.cpp, heap_sort.cpp, merge_insertion_sort.cpp, pancake_sort.cpp, random_pivot_quick_sort.cpp, recursive_bubble_sort.cpp, selection_sort_recursive.cpp, strand_sort.cpp, wave_sort.cpp, wiggle_sort.cpp, horspool.cpp, manacher_algorithm.cpp, z_function.cpp
- test1() : hill_cipher.cpp, tree_234.cpp, hamiltons_cycle.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, large_factorial.cpp, sum_of_digits.cpp, brent_method_extrema.cpp, durand_kerner_roots.cpp, golden_search_extrema.cpp, lu_decompose.cpp, qr_eigen_values.cpp, iterative_tree_traversals.cpp
- test2() : hill_cipher.cpp, tree_234.cpp, hamiltons_cycle.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, large_factorial.cpp, sum_of_digits.cpp, brent_method_extrema.cpp, durand_kerner_roots.cpp, golden_search_extrema.cpp, lu_decompose.cpp, qr_eigen_values.cpp, iterative_tree_traversals.cpp, smallest_circle.cpp
- test3() : hamiltons_cycle.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, brent_method_extrema.cpp, golden_search_extrema.cpp, iterative_tree_traversals.cpp, smallest_circle.cpp
diff --git a/hierarchy.html b/hierarchy.html
index 6cdc2a251..15fb8a93a 100644
--- a/hierarchy.html
+++ b/hierarchy.html
@@ -104,92 +104,94 @@ This inheritance list is sorted roughly, but not completely, alphabetically: Cbinary_search_tree< T >::bst_node A struct to represent a node in the Binary Search Tree
CBtree Ccll Ccompare Cmachine_learning::aystar_search::AyStarSearch< Puzzle >::comparison_operator Custom comparator for open_list CComplex Class Complex to represent complex numbers as a field Cgeometry::jarvis::Convexhull CCycleCheck Cmachine_learning::neural_network::layers::DenseLayer Cdouble_linked_list CEdge Cmachine_learning::aystar_search::EightPuzzle< N > A class defining EightPuzzle/15-Puzzle game Cdouble_hashing::Entry Clinear_probing::Entry Cquadratic_probing::Entry CFenwickTree Cprobability::geometric_dist::geometric_distribution A class to model the geometric distribution CGraph ▼Cgraph::Graph< T > Cgraph::RootedTree Cgraph::is_graph_bipartite::Graph Class for representing graph as an adjacency list Chash_chain Chain class with a given modulus Cciphers::HillCipher Implementation of Hill Cipher algorithm Cgraph::HKGraph Represents Bipartite graph for Hopcroft Karp implementation Cmachine_learning::aystar_search::AyStarSearch< Puzzle >::Info Struct that handles all the information related to the current state CItem Clarge_number Cdata_structures::linked_list::link Clinkedlist Cdata_structures::linked_list::list Cdata_structures::list_array::list Structure of List with supporting methods Clist Cgraph::LowestCommonAncestor Cothers::lru_cache::LRUCache LRU cache class CMinHeap CMinHeapNode Cmst Cmath::ncr_modulo_p::NCRModuloP Class which contains all methods required for calculating nCr mod p Cmachine_learning::neural_network::NeuralNetwork Cdata_structures::linked_list::Node Cdata_structures::Node Cdata_structures::tree_234::Node 2-3-4 tree node class Cdata_structures::trie_using_hashmap::Trie::Node Struct representing a trie node CNode Cnode< Kind > Coperations_on_datastructures::inorder_traversal_of_bst::Node A Node structure representing a single node in BST Cothers::iterative_tree_traversals::Node Defines the structure of a node of the tree Crange_queries::perSegTree::Node Csearch::sublist_search::Node A Node structure representing a single link Node in a linked list Crange_queries::perSegTree Range query here is range sum, but the code can be modified to make different queries like range max or min Cciphers::elliptic_curve_key_exchange::Point Definition of struct Point Cgeometry::jarvis::Point CPoint Cquery Cqueue< Kind > CQueue Cdata_structures::queue_using_array::Queue_Array Queue_Array class containing the main data and also index of head and tail of the array CRBtree CSegmentIntersection ▼Crange_queries::heavy_light_decomposition::SG< X > Segment Tree, to store heavy chains Crange_queries::heavy_light_decomposition::HLD< X > The Heavy-Light Decomposition class Cdata_structures::SkipList CSolution Cdata_structures::sparse_table::Sparse_table Cothers::postfix_expression::Stack Creates an array to be used as stack for storing values Cstack< Type > Cstack_linkedList Cstatistics::stats_computer1< T > Cstatistics::stats_computer2< T > CTestCases Class encapsulating the necessary test cases Coperations_on_datastructures::trie_operations::Tnode Class defining the structure of trie node and containing the methods to perform operations on them Ctower ▼Crange_queries::heavy_light_decomposition::Tree< X > A Basic Tree, which supports binary lifting Crange_queries::heavy_light_decomposition::HLD< X > The Heavy-Light Decomposition class Cdata_structures::tree_234::Tree234 2-3-4 tree class Cdata_structures::trie Trie implementation for small-case English alphabets a-z Cdata_structures::trie_using_hashmap::Trie Trie class, implementation of trie using hashmap in each trie node for all the characters of char16_t(UTF-16)type with methods to insert, delete, search, start with and to recommend words based on a given prefix CTrie CTrie::TrieNode ▼Cstd::true_type [external] Cstd::is_arithmetic< uint128_t > Cstd::is_arithmetic< uint256_t > Cstd::is_integral< uint128_t > Cstd::is_integral< uint256_t > Cstd::is_unsigned< uint128_t > Cstd::is_unsigned< uint256_t > Cuint128_t Class for 128-bit unsigned integer Cuint256_t Class for 256-bit unsigned integer Cprobability::windowed_median::WindowedMedian A class to calculate the median of a leading sliding window at the back of a stream of integer values CCompare< S, T, E > Comparator class for priority queue Ccompare Cmachine_learning::aystar_search::AyStarSearch< Puzzle >::comparison_operator Custom comparator for open_list CComplex Class Complex to represent complex numbers as a field Cgeometry::jarvis::Convexhull CCycleCheck Cmachine_learning::neural_network::layers::DenseLayer Cdouble_linked_list CEdge Cmachine_learning::aystar_search::EightPuzzle< N > A class defining EightPuzzle/15-Puzzle game Cdouble_hashing::Entry Clinear_probing::Entry Cquadratic_probing::Entry CFCFS< S, T, E > Class which implements the FCFS scheduling algorithm CFenwickTree Cprobability::geometric_dist::geometric_distribution A class to model the geometric distribution CGraph ▼Cgraph::Graph< T > Cgraph::RootedTree Cgraph::is_graph_bipartite::Graph Class for representing graph as an adjacency list Chash_chain Chain class with a given modulus Cciphers::HillCipher Implementation of Hill Cipher algorithm Cgraph::HKGraph Represents Bipartite graph for Hopcroft Karp implementation Cmachine_learning::aystar_search::AyStarSearch< Puzzle >::Info Struct that handles all the information related to the current state CItem Clarge_number Cdata_structures::linked_list::link Clinkedlist Cdata_structures::linked_list::list Cdata_structures::list_array::list Structure of List with supporting methods Clist Cgraph::LowestCommonAncestor Cothers::lru_cache::LRUCache LRU cache class CMinHeap CMinHeapNode Cmst Cmath::ncr_modulo_p::NCRModuloP Class which contains all methods required for calculating nCr mod p Cmachine_learning::neural_network::NeuralNetwork Cdata_structures::linked_list::Node Cdata_structures::Node Cdata_structures::tree_234::Node 2-3-4 tree node class Cdata_structures::trie_using_hashmap::Trie::Node Struct representing a trie node CNode Cnode< Kind > Coperations_on_datastructures::inorder_traversal_of_bst::Node A Node structure representing a single node in BST Cothers::iterative_tree_traversals::Node Defines the structure of a node of the tree Crange_queries::perSegTree::Node Csearch::sublist_search::Node A Node structure representing a single link Node in a linked list Crange_queries::perSegTree Range query here is range sum, but the code can be modified to make different queries like range max or min Cciphers::elliptic_curve_key_exchange::Point Definition of struct Point Cgeometry::jarvis::Point CPoint Cquery Cqueue< Kind > CQueue Cdata_structures::queue_using_array::Queue_Array Queue_Array class containing the main data and also index of head and tail of the array CRBtree CSegmentIntersection ▼Crange_queries::heavy_light_decomposition::SG< X > Segment Tree, to store heavy chains Crange_queries::heavy_light_decomposition::HLD< X > The Heavy-Light Decomposition class Cdata_structures::SkipList CSolution Cdata_structures::sparse_table::Sparse_table Cothers::postfix_expression::Stack Creates an array to be used as stack for storing values Cstack< Type > Cstack_linkedList Cstatistics::stats_computer1< T > Cstatistics::stats_computer2< T > CTestCases Class encapsulating the necessary test cases Coperations_on_datastructures::trie_operations::Tnode Class defining the structure of trie node and containing the methods to perform operations on them Ctower ▼Crange_queries::heavy_light_decomposition::Tree< X > A Basic Tree, which supports binary lifting Crange_queries::heavy_light_decomposition::HLD< X > The Heavy-Light Decomposition class Cdata_structures::tree_234::Tree234 2-3-4 tree class Cdata_structures::trie Trie implementation for small-case English alphabets a-z Cdata_structures::trie_using_hashmap::Trie Trie class, implementation of trie using hashmap in each trie node for all the characters of char16_t(UTF-16)type with methods to insert, delete, search, start with and to recommend words based on a given prefix CTrie CTrie::TrieNode ▼Cstd::true_type [external] Cstd::is_arithmetic< uint128_t > Cstd::is_arithmetic< uint256_t > Cstd::is_integral< uint128_t > Cstd::is_integral< uint256_t > Cstd::is_unsigned< uint128_t > Cstd::is_unsigned< uint256_t > Cuint128_t Class for 128-bit unsigned integer Cuint256_t Class for 256-bit unsigned integer Cprobability::windowed_median::WindowedMedian A class to calculate the median of a leading sliding window at the back of a stream of integer values
diff --git a/hierarchy.js b/hierarchy.js
index cc5d4c317..d62633ce2 100644
--- a/hierarchy.js
+++ b/hierarchy.js
@@ -7,6 +7,7 @@ var hierarchy =
[ "binary_search_tree< T >::bst_node", "dd/db6/structbinary__search__tree_1_1bst__node.html", null ],
[ "Btree", "d9/d90/struct_btree.html", null ],
[ "cll", "d5/d15/classcll.html", null ],
+ [ "Compare< S, T, E >", "de/d4a/class_compare.html", null ],
[ "compare", "d1/db3/structcompare.html", null ],
[ "machine_learning::aystar_search::AyStarSearch< Puzzle >::comparison_operator", "d3/d2a/structmachine__learning_1_1aystar__search_1_1_ay_star_search_1_1comparison__operator.html", null ],
[ "Complex", "da/d5a/class_complex.html", null ],
@@ -19,6 +20,7 @@ var hierarchy =
[ "double_hashing::Entry", "d9/dde/structdouble__hashing_1_1_entry.html", null ],
[ "linear_probing::Entry", "db/d19/structlinear__probing_1_1_entry.html", null ],
[ "quadratic_probing::Entry", "da/dd1/structquadratic__probing_1_1_entry.html", null ],
+ [ "FCFS< S, T, E >", "dd/dca/class_f_c_f_s.html", null ],
[ "FenwickTree", "dd/d91/class_fenwick_tree.html", null ],
[ "probability::geometric_dist::geometric_distribution", "da/d19/classprobability_1_1geometric__dist_1_1geometric__distribution.html", null ],
[ "Graph", "da/d9a/class_graph.html", null ],
diff --git a/index.html b/index.html
index 9b5825758..538225e93 100644
--- a/index.html
+++ b/index.html
@@ -95,10 +95,10 @@ $(document).ready(function(){initNavTree('index.html',''); initResizable(); });
-
+
Overview
This repository is a collection of open-source implementation of a variety of algorithms implemented in C++ and licensed under MIT License. These algorithms span a variety of topics from computer science, mathematics and statistics, data science, machine learning, engineering, etc.. The implementations and the associated documentation are meant to provide a learning resource for educators and students. Hence, one may find more than one implementation for the same objective but using a different algorithm strategies and optimizations.
-
+
Features
- The repository provides implementations of various algorithms in one of the most fundamental general purpose languages - C++.
@@ -109,12 +109,12 @@ Features
- Self-checks within programs ensure correct implementations with confidence.
- Modular implementations and OpenSource licensing enable the functions to be utilized conveniently in other applications.
-
+
Documentation
Online Documentation is generated from the repository source codes directly. The documentation contains all resources including source code snippets, details on execution of the programs, diagrammatic representation of program flow, and links to external resources where necessary. The documentation also introduces interactive source code with links to documentation for C++ STL library functions used. Click on Files menu to see the list of all the files documented with the code.
Documentation of Algorithms in C++ by The Algorithms Contributors is licensed under CC BY-SA 4.0
-
+
Contributions
As a community developed and maintained repository, we welcome new un-plagiarized quality contributions. Please read our Contribution Guidelines.
diff --git a/inherit_graph_10.map b/inherit_graph_10.map
index 32a286108..e3ea338d1 100644
--- a/inherit_graph_10.map
+++ b/inherit_graph_10.map
@@ -1,3 +1,3 @@
diff --git a/inherit_graph_10.md5 b/inherit_graph_10.md5
index 679531e7b..7bca58621 100644
--- a/inherit_graph_10.md5
+++ b/inherit_graph_10.md5
@@ -1 +1 @@
-5eb287a2fb56ae0e7e71100d4f42a21c
\ No newline at end of file
+5320309e3bffbba4f4360758b1ad97f4
\ No newline at end of file
diff --git a/inherit_graph_10.svg b/inherit_graph_10.svg
index 66bb71fe6..4ad91dbea 100644
--- a/inherit_graph_10.svg
+++ b/inherit_graph_10.svg
@@ -12,10 +12,10 @@
Node0
-
+
data_structures::linked
-_list::list
+_list::link
diff --git a/inherit_graph_11.map b/inherit_graph_11.map
index 7d4ec9a8d..32a286108 100644
--- a/inherit_graph_11.map
+++ b/inherit_graph_11.map
@@ -1,3 +1,3 @@
diff --git a/inherit_graph_11.md5 b/inherit_graph_11.md5
index c563a0c98..679531e7b 100644
--- a/inherit_graph_11.md5
+++ b/inherit_graph_11.md5
@@ -1 +1 @@
-d57400eb9de671d3442759337d4a98a7
\ No newline at end of file
+5eb287a2fb56ae0e7e71100d4f42a21c
\ No newline at end of file
diff --git a/inherit_graph_11.svg b/inherit_graph_11.svg
index 5e4880e22..66bb71fe6 100644
--- a/inherit_graph_11.svg
+++ b/inherit_graph_11.svg
@@ -12,10 +12,10 @@
Node0
-
+
data_structures::linked
-_list::Node
+_list::list
diff --git a/inherit_graph_12.map b/inherit_graph_12.map
index 087a17e54..7d4ec9a8d 100644
--- a/inherit_graph_12.map
+++ b/inherit_graph_12.map
@@ -1,3 +1,3 @@
diff --git a/inherit_graph_12.md5 b/inherit_graph_12.md5
index fed441c74..c563a0c98 100644
--- a/inherit_graph_12.md5
+++ b/inherit_graph_12.md5
@@ -1 +1 @@
-8b10ed21001ae43ebb02b0fc74f2c517
\ No newline at end of file
+d57400eb9de671d3442759337d4a98a7
\ No newline at end of file
diff --git a/inherit_graph_12.svg b/inherit_graph_12.svg
index 62e00425f..5e4880e22 100644
--- a/inherit_graph_12.svg
+++ b/inherit_graph_12.svg
@@ -4,18 +4,18 @@
-
Detailed Description
Implementation to check whether a number is a power of 2 or not.
This algorithm uses bit manipulation to check if a number is a power of 2 or not.
-
+
Algorithm
Let the input number be n, then the bitwise and between n and n-1 will let us know whether the number is power of 2 or not
For Example, If N= 32 then N-1 is 31, if we perform bitwise and of these two numbers then the result will be zero, which indicates that it is the power of 2 If N=23 then N-1 is 22, if we perform bitwise and of these two numbers then the result will not be zero , which indicates that it is not the power of 2
- Note
- This implementation is better than naive recursive or iterative approach.
Detailed Description
Implementation of Jarvis’s algorithm.
Given a set of points in the plane. the convex hull of the set is the smallest convex polygon that contains all the points of it.
-
+
Algorithm
The idea of Jarvis’s Algorithm is simple, we start from the leftmost point (or point with minimum x coordinate value) and we keep wrapping points in counterclockwise direction.
The idea is to use orientation() here. Next point is selected as the point that beats all other points at counterclockwise orientation, i.e., next point is q if for any other point r, we have “orientation(p, q, r) = counterclockwise”.
diff --git a/d4/d9f/selection__sort__recursive_8cpp.html b/d4/d9f/selection__sort__recursive_8cpp.html index 69ee52e4e..1f12431b3 100644 --- a/d4/d9f/selection__sort__recursive_8cpp.html +++ b/d4/d9f/selection__sort__recursive_8cpp.html @@ -139,7 +139,7 @@ FunctionsDetailed Description
Implementation of the Selection sort implementation using recursion.
The selection sort algorithm divides the input list into two parts: a sorted sublist of items which is built up from left to right at the front (left) of the list, and a sublist of the remaining unsorted items that occupy the rest of the list. Initially, the sorted sublist is empty, and the unsorted sublist is the entire input list. The algorithm proceeds by finding the smallest (or largest, depending on the sorting order) element in the unsorted sublist, exchanging (swapping) it with the leftmost unsorted element (putting it in sorted order), and moving the sublist boundaries one element to the right.
-
+
Implementation
FindMinIndex This function finds the minimum element of the array(list) recursively by simply comparing the minimum element of array reduced size by 1 and compares it to the last element of the array to find the minimum of the whole array.
SelectionSortRecursive Just like selection sort, it divides the list into two parts (i.e.: sorted and unsorted) and finds the minimum of the unsorted array. By calling the FindMinIndex function, it swaps the minimum element with the first element of the list, and then solves recursively for the remaining unsorted list.
Detailed Description
Gram Schmidt Orthogonalisation Process
Takes the input of Linearly Independent Vectors, returns vectors orthogonal to each other.
-
+
Algorithm
Take the first vector of given LI vectors as first vector of Orthogonal vectors. Take projection of second input vector on the first vector of Orthogonal vector and subtract it from the 2nd LI vector. Take projection of third vector on the second vector of Othogonal vectors and subtract it from the 3rd LI vector. Keep repeating the above process until all the vectors in the given input array are exhausted.
For Example: In R2, Input LI Vectors={(3,1),(2,2)} then Orthogonal Vectors= {(3, 1),(-0.4, 1.2)}
diff --git a/d5/d45/sublist__search_8cpp.html b/d5/d45/sublist__search_8cpp.html index 2d629b439..201817fd1 100644 --- a/d5/d45/sublist__search_8cpp.html +++ b/d5/d45/sublist__search_8cpp.html @@ -148,14 +148,14 @@ FunctionsDetailed Description
Implementation of the Sublist Search Algorithm
-
+
Algorithm
- Sublist search is used to detect a presence of one list in another list.
- Suppose we have a single-node list (let's say the first list), and we want to ensure that the list is present in another list (let's say the second list), then we can perform the sublist search to find it.
- For instance, the first list contains these elements: 23 -> 30 -> 41, and the second list contains these elements: 10 -> 15 -> 23 -> 30 -> 41 -> 49. At a glance, we see that the first list presents in the second list.
-
+
Working
- The sublist search algorithm works by comparing the first element of the first list with the first element of the second list.
diff --git a/d5/d88/md__d_i_r_e_c_t_o_r_y.html b/d5/d88/md__d_i_r_e_c_t_o_r_y.html
index 514ce65b3..c5af30faa 100644
--- a/d5/d88/md__d_i_r_e_c_t_o_r_y.html
+++ b/d5/d88/md__d_i_r_e_c_t_o_r_y.html
@@ -128,6 +128,11 @@ Ciphers
- Xor Cipher
+Cpu Scheduling Algorithms
+
+
Data Structures
- Avltree
@@ -169,12 +174,12 @@ Data Structures
- Trie Tree
- Trie Using Hashmap
-
+
Divide And Conquer
-
+
Dynamic Programming
- 0 1 Knapsack
@@ -205,13 +210,13 @@ Dynamic Programming
Working
- The sublist search algorithm works by comparing the first element of the first list with the first element of the second list. diff --git a/d5/d88/md__d_i_r_e_c_t_o_r_y.html b/d5/d88/md__d_i_r_e_c_t_o_r_y.html index 514ce65b3..c5af30faa 100644 --- a/d5/d88/md__d_i_r_e_c_t_o_r_y.html +++ b/d5/d88/md__d_i_r_e_c_t_o_r_y.html @@ -128,6 +128,11 @@ Ciphers
- Xor Cipher
+Cpu Scheduling Algorithms
+ +Data Structures
- Avltree @@ -169,12 +174,12 @@ Data Structures
- Trie Tree
- Trie Using Hashmap
+
Divide And Conquer
-
+
Dynamic Programming
- 0 1 Knapsack
@@ -205,13 +210,13 @@ Dynamic Programming
Dynamic Programming
- 0 1 Knapsack @@ -205,13 +210,13 @@ Dynamic Programming
+
Geometry
-
+
Graph
- Bidirectional Dijkstra
@@ -235,12 +240,12 @@ Graph
Graph
- Bidirectional Dijkstra @@ -235,12 +240,12 @@ Graph
+
Graphics
-
+
Greedy Algorithms
- Dijkstra
@@ -250,7 +255,7 @@ Greedy Algorithms
Greedy Algorithms
- Dijkstra @@ -250,7 +255,7 @@ Greedy Algorithms
+
Hashing
- Chaining
@@ -260,12 +265,12 @@ Hashing
+
Linear Algebra
-
+
Machine Learning
- A Star Search
@@ -276,7 +281,7 @@ Machine Learning
Machine Learning
- A Star Search @@ -276,7 +281,7 @@ Machine Learning
+
Math
- Armstrong Number
@@ -330,7 +335,7 @@ Math
+
Numerical Methods
- Bisection Method
@@ -351,7 +356,7 @@ Numerical Methods
+
Operations On Datastructures
- Array Left Rotation
@@ -366,7 +371,7 @@ Operations On Datastructures
+
Others
- Buzz Number
@@ -391,7 +396,7 @@ Others
+
Probability
- Addition Rule
@@ -401,7 +406,7 @@ Probability
+
Range Queries
- Fenwick Tree
@@ -412,7 +417,7 @@ Range Queries
+
Search
- Binary Search
@@ -430,7 +435,7 @@ Search
+
Sorting
- Bead Sort
@@ -473,7 +478,7 @@ Sorting
+
Strings
- Brute Force String Searching
diff --git a/d5/d96/md5_8cpp.html b/d5/d96/md5_8cpp.html
index fcef37251..653b5c1fe 100644
--- a/d5/d96/md5_8cpp.html
+++ b/d5/d96/md5_8cpp.html
@@ -164,7 +164,7 @@ Functions
- Store salted password
However MD5 has be know to be cryptographically weak for quite some time, yet it is still widely used. This weakness was exploited by the Flame Malware in 2012
-
+
Algorithm
First of all, all values are expected to be in little endian. This is especially important when using part of the bytestring as an integer.
The first step of the algorithm is to pad the message for its length to be a multiple of 64 (bytes). This is done by first adding 0x80 (10000000) and then only zeroes until the last 8 bytes must be filled, where then the 64 bit size of the input will be added
diff --git a/d5/ddb/bogo__sort_8cpp.html b/d5/ddb/bogo__sort_8cpp.html
index 5fca0b893..30e0a0c78 100644
--- a/d5/ddb/bogo__sort_8cpp.html
+++ b/d5/ddb/bogo__sort_8cpp.html
@@ -135,7 +135,7 @@ Functions
Detailed Description
Implementation of Bogosort algorithm
In computer science, bogosort (also known as permutation sort, stupid sort, slowsort, shotgun sort, random sort, monkey sort, bobosort or shuffle sort) is a highly inefficient sorting algorithm based on the generate and test paradigm. Two versions of this algorithm exist: a deterministic version that enumerates all permutations until it hits a sorted one, and a randomized version that randomly permutes its input.Randomized version is implemented here.
-
+
Algorithm
Shuffle the array untill array is sorted.
diff --git a/d6/d10/cut__rod_8cpp.html b/d6/d10/cut__rod_8cpp.html
index 5da32cc73..e6dad50c4 100644
--- a/d6/d10/cut__rod_8cpp.html
+++ b/d6/d10/cut__rod_8cpp.html
@@ -135,7 +135,7 @@ Functions
Detailed Description
Implementation of cutting a rod problem.
Given a rod of length n inches and an array of prices that contains prices of all pieces of size<=n. Determine the maximum profit obtainable by cutting up the rod and selling the pieces.
-
+
Algorithm
The idea is to break the given rod into every smaller piece as possible and then check profit for each piece, by calculating maximum profit for smaller pieces we will build the solution for larger pieces in bottom-up manner.
- Capitalize zero or more of
a's lowercase letters.
- Delete all of the remaining lowercase letters in
a.
-
+
Algorithm
The idea is in the problem statement itself: iterate through characters of string a and b (for character indexes i and j respectively):
- If
a[i] and b[j] are equal, then move to next position
diff --git a/d8/d7a/sha1_8cpp.html b/d8/d7a/sha1_8cpp.html
index 011c7725c..4a75469bc 100644
--- a/d8/d7a/sha1_8cpp.html
+++ b/d8/d7a/sha1_8cpp.html
@@ -150,7 +150,7 @@ Functions
Simple C++ implementation of the SHA-1 Hashing Algorithm
SHA-1 is a cryptographic hash function that was developped by the NSA 1995. SHA-1 is not considered secure since around 2010.
-
+
Algorithm
The first step of the algorithm is to pad the message for its length to be a multiple of 64 (bytes). This is done by first adding 0x80 (10000000) and then only zeroes until the last 8 bytes must be filled, where then the 64 bit size of the input will be added
Once this is done, the algo breaks down this padded message into 64 bytes chunks. Each chunk is used for one round, a round breaks the chunk into 16 blocks of 4 bytes. These 16 blocks are then extended to 80 blocks using XOR operations on existing blocks (see code for more details). The algorithm will then update its 160-bit state (here represented used 5 32-bits integer) using partial hashes computed using special functions on the blocks previously built. Please take a look at the wikipedia article for more precision on these operations
- Note
- This is a simple implementation for a byte string but some implmenetations can work on bytestream, messages of unknown length.
diff --git a/d8/d90/iterative__tree__traversals_8cpp.html b/d8/d90/iterative__tree__traversals_8cpp.html
index 73ac4c543..3efdda89b 100644
--- a/d8/d90/iterative__tree__traversals_8cpp.html
+++ b/d8/d90/iterative__tree__traversals_8cpp.html
@@ -157,13 +157,13 @@ Functions
Detailed Description
Iterative version of Preorder, Postorder, and preorder Traversal of the Tree
-
+
Iterative Preorder Traversal of a tree
Create a Stack that will store the Node of Tree. Push the root node into the stack. Save the root into the variabe named as current, and pop and elemnt from the stack. Store the data of current into the result array, and start traversing from it. Push both the child node of the current node into the stack, first right child then left child. Repeat the same set of steps untill the Stack becomes empty. And return the result array as the preorder traversal of a tree.
-
+
Iterative Postorder Traversal of a tree
Create a Stack that will store the Node of Tree. Push the root node into the stack. Save the root into the variabe named as current, and pop and elemnt from the stack. Store the data of current into the result array, and start traversing from it. Push both the child node of the current node into the stack, first left child then right child. Repeat the same set of steps untill the Stack becomes empty. Now reverse the result array and then return it to the calling function as a postorder traversal of a tree.
-
+
Iterative Inorder Traversal of a tree
Create a Stack that will store the Node of Tree. Push the root node into the stack. Save the root into the variabe named as current. Now iterate and take the current to the extreme left of the tree by traversing only to its left. Pop the elemnt from the stack and assign it to the current. Store the data of current into the result array. Repeat the same set of steps until the Stack becomes empty or the current becomes NULL. And return the result array as the inorder traversal of a tree.
Function Documentation
diff --git a/d8/d99/connected__components__with__dsu_8cpp.html b/d8/d99/connected__components__with__dsu_8cpp.html
index 75568d7b0..ab127c3d4 100644
--- a/d8/d99/connected__components__with__dsu_8cpp.html
+++ b/d8/d99/connected__components__with__dsu_8cpp.html
@@ -155,7 +155,7 @@ uint32_t graph::disjoint_u
Detailed Description
The Disjoint union is the technique to find connected component in graph efficiently.
-
+
Algorithm
In Graph, if you have to find out the number of connected components, there are 2 options
- Depth first search
diff --git a/d8/dc8/class_compare-members.html b/d8/dc8/class_compare-members.html
new file mode 100644
index 000000000..84ead1ecc
--- /dev/null
+++ b/d8/dc8/class_compare-members.html
@@ -0,0 +1,109 @@
+
+
+
+
+
+
+
+Algorithms_in_C++: Member List
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Algorithms_in_C++ 1.0.0
+
+ Set of algorithms implemented in C++.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Compare< S, T, E > Member List
+
+
+
+This is the complete list of members for Compare< S, T, E >, including all inherited members.
+
+ operator()(tuple< S, T, E, double, double, double > &t1, tuple< S, T, E, double, double, double > &t2) Compare< S, T, E > inline
+
+
+
+
+ - Generated by 1.9.2
+
+
+
+
diff --git a/d9/dfd/comb__sort_8cpp.html b/d9/dfd/comb__sort_8cpp.html
index 871becef3..117c91753 100644
--- a/d9/dfd/comb__sort_8cpp.html
+++ b/d9/dfd/comb__sort_8cpp.html
@@ -172,7 +172,7 @@ Functions
Initialize swapped as true to make sure that loop runs
Keep running until gap = 1 or none elements were swapped
Find next gap
-Compare all elements with current gap
+Compare all elements with current gap
diff --git a/da/d52/minimum__edit__distance_8cpp.html b/da/d52/minimum__edit__distance_8cpp.html
index 3567f6cd6..624a0f246 100644
--- a/da/d52/minimum__edit__distance_8cpp.html
+++ b/da/d52/minimum__edit__distance_8cpp.html
@@ -136,7 +136,7 @@ Functions
Detailed Description
Implementation of Minimum Edit Distance using Dynamic Programing.
Given two strings str1 & str2 and we have to calculate the minimum number of operations (Insert, Remove, Replace) required to convert str1 to str2.
-
+
Algorithm
We will solve this problem using Naive recursion. But as we are approaching with a DP solution. So, we will take a DP array to store the solution of all sub-problems so that we don't have to perform recursion again and again. Now to solve the problem, We can traverse all characters from either right side of the strings or left side. Suppose we will do it from the right side. So, there are two possibilities for every pair of characters being traversed.
- If the last characters of two strings are the same, Ignore the characters and get the count for the remaining string. So, we get the solution for lengths m-1 and n-1 in a DP array.
diff --git a/db/d16/0__1__knapsack_8cpp.html b/db/d16/0__1__knapsack_8cpp.html
index 433c48500..cfcf6167c 100644
--- a/db/d16/0__1__knapsack_8cpp.html
+++ b/db/d16/0__1__knapsack_8cpp.html
@@ -135,7 +135,7 @@ Functions
Detailed Description
Implementation of 0-1 Knapsack Problem
Given weights and values of n items, put these items in a knapsack of capacity W to get the maximum total value in the knapsack. In other words, given two integer arrays val[0..n-1] and wt[0..n-1] which represent values and weights associated with n items respectively. Also given an integer W which represents knapsack capacity, find out the maximum value subset of val[] such that sum of the weights of this subset is smaller than or equal to W. You cannot break an item, either pick the complete item or don’t pick it (0-1 property)
-
+
Algorithm
The idea is to consider all subsets of items and calculate the total weight and value of all subsets. Consider the only subsets whose total weight is smaller than W. From all such subsets, pick the maximum value subset.
- Author
- Anmol
diff --git a/db/dca/kadane2_8cpp.html b/db/dca/kadane2_8cpp.html
index 35dd96829..1dbb15c18 100644
--- a/db/dca/kadane2_8cpp.html
+++ b/db/dca/kadane2_8cpp.html
@@ -131,7 +131,7 @@ Functions
Detailed Description
Implementation of Kadane Algorithm
Kadane algorithm is used to find the maximum sum subarray in an array and maximum sum subarray problem is the task of finding a contiguous subarray with the largest sum
-
+
Algorithm
The simple idea of the algorithm is to search for all positive contiguous segments of the array and keep track of maximum sum contiguous segment among all positive segments(curr_sum is used for this) Each time we get a positive sum we compare it with max_sum and update max_sum if it is greater than curr_sum
diff --git a/dd/d47/namespacemath.html b/dd/d47/namespacemath.html
index c23f2ccf6..1d04b6d46 100644
--- a/dd/d47/namespacemath.html
+++ b/dd/d47/namespacemath.html
@@ -145,7 +145,7 @@ Functions
Mathematical algorithms
Given a recurrence relation; evaluate the value of nth term. For e.g., For fibonacci series, recurrence series is f(n) = f(n-1) + f(n-2) where f(0) = 0 and f(1) = 1. Note that the method used only demonstrates recurrence relation with one variable (n), unlike nCr problem, since it has two (n, r)
-
+
Algorithm
This problem can be solved using matrix exponentiation method.
- See also
- here for simple number exponentiation algorithm or explaination here.
diff --git a/dd/dca/class_f_c_f_s.html b/dd/dca/class_f_c_f_s.html
new file mode 100644
index 000000000..cc5a819ff
--- /dev/null
+++ b/dd/dca/class_f_c_f_s.html
@@ -0,0 +1,376 @@
+
+
+
+
+
+
+
+Algorithms_in_C++: FCFS< S, T, E > Class Template Reference
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Algorithms_in_C++ 1.0.0
+
+ Set of algorithms implemented in C++.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ FCFS< S, T, E > Class Template Reference
+
+
+
+Class which implements the FCFS scheduling algorithm.
+ More...
+
+
+Public Member Functions
void addProcess (S id, T arrival, E burst) Adds the process to the ready queue if it isn't already there. More...
vector< tuple< S, T, E, double, double, double > > scheduleForFcfs () Algorithm for scheduling CPU processes according to the First Come First Serve(FCFS) scheduling algorithm. More...
void printResult () Utility function for printing the status of each process after execution. More...
+
+Private Attributes
priority_queue< tuple< S, T, E, double, double, double >, vector< tuple< S, T, E, double, double, double > >, Compare< S, T, E > > schedule
+vector< tuple< S, T, E, double, double, double > > result
+unordered_set< S > idList
+Detailed Description
+template<typename S, typename T, typename E>
+class FCFS< S, T, E >Class which implements the FCFS scheduling algorithm.
+- Template Parameters
-
+
+ S Data type of Process ID T Data type of Arrival time E Data type of Burst time
+
+
+Member Function Documentation
+
+◆ addProcess()
+
+
+
+
+template<typename S , typename T , typename E >
+
+
+
+
+
+ void FCFS< S, T, E >::addProcess
+ (
+ S
+ id,
+
+
+ T
+ arrival,
+
+
+ E
+ burst
+
+
+ )
+
+
+
+
+inline
+
+
+
+
+Adds the process to the ready queue if it isn't already there.
+- Parameters
-
+
+ id Process ID arrival Arrival time of the process burst Burst time of the process
+
+
+- Returns
- void
+
+
+
+
+
+
+
+
+
+priority_queue< tuple< S, T, E, double, double, double >, vector< tuple< S, T, E, double, double, double > >, Compare< S, T, E > > scheduleDefinition: fcfs_scheduling.cpp:111
+T make_tuple(T... args)
+
+
+Here is the call graph for this function:
+
+
+
+
+
+
+
+
+◆ printResult()
+
+
+
+
+template<typename S , typename T , typename E >
+
+
+
+
+
+ void FCFS< S, T, E >::printResult
+ (
+ )
+
+
+
+
+inline
+
+
+
+
+Utility function for printing the status of each process after execution.
+- Returns
- void
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+T fixed(T... args)
+T left(T... args)
+
+T setprecision(T... args)
+T setw(T... args)
+
+Here is the call graph for this function:
+
+
+
+
+
+
+
+
+◆ scheduleForFcfs()
+
+
+
+
+template<typename S , typename T , typename E >
+
+
+
+
+
+ vector< tuple< S, T, E, double, double, double > > FCFS< S, T, E >::scheduleForFcfs
+ (
+ )
+
+
+
+
+inline
+
+
+
+
+Algorithm for scheduling CPU processes according to the First Come First Serve(FCFS) scheduling algorithm.
+FCFS is a non-preemptive algorithm in which the process which arrives first gets executed first. If two or more processes arrive together then the process with smaller process ID runs first (each process has a unique proces ID).
+I used a min priority queue of tuples to accomplish this task. The processes are ordered by their arrival times. If arrival times of some processes are equal, then they are ordered by their process ID.
+- Returns
- void
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Member Data Documentation
+
+◆ schedule
+
+
+
+
+template<typename S , typename T , typename E >
+
+
+
+
+
+ priority_queue<tuple<S, T, E, double, double, double>, vector<tuple<S, T, E, double, double, double> >, Compare<S, T, E> > FCFS< S, T, E >::schedule
+
+
+
+
+private
+
+
+
+Priority queue of schedules(stored as tuples) of processes. In each tuple 1st element: Process ID 2nd element: Arrival Time 3rd element: Burst time 4th element: Completion time 5th element: Turnaround time 6th element: Waiting time
+
+
+
+
The documentation for this class was generated from the following file:
+- cpu_scheduling_algorithms/fcfs_scheduling.cpp
+
+
+
+
+
+
+
+ - Generated by 1.9.2
+
+
+
+
diff --git a/dd/dca/class_f_c_f_s.js b/dd/dca/class_f_c_f_s.js
new file mode 100644
index 000000000..3c4ded1da
--- /dev/null
+++ b/dd/dca/class_f_c_f_s.js
@@ -0,0 +1,7 @@
+var class_f_c_f_s =
+[
+ [ "addProcess", "dd/dca/class_f_c_f_s.html#a8fbfe4d85f7576b4a7aade07d29fbd69", null ],
+ [ "printResult", "dd/dca/class_f_c_f_s.html#abb361a612b18bb189aa6d3c49288b793", null ],
+ [ "scheduleForFcfs", "dd/dca/class_f_c_f_s.html#aa25dbe30ba9930b5a7c1a6d11758bd91", null ],
+ [ "schedule", "dd/dca/class_f_c_f_s.html#af2594e22a867b308e027623940193d46", null ]
+];
\ No newline at end of file
diff --git a/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.map b/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.map
new file mode 100644
index 000000000..5ff1060ab
--- /dev/null
+++ b/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.map
@@ -0,0 +1,6 @@
+
diff --git a/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.md5 b/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.md5
new file mode 100644
index 000000000..f960e4771
--- /dev/null
+++ b/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.md5
@@ -0,0 +1 @@
+40be8724cd3544d6f4f7db4d23d50120
\ No newline at end of file
diff --git a/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.svg b/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.svg
new file mode 100644
index 000000000..4e2da5e1f
--- /dev/null
+++ b/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.svg
@@ -0,0 +1,69 @@
+
+
+
+
+
diff --git a/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.map b/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.map
new file mode 100644
index 000000000..bf9103337
--- /dev/null
+++ b/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.map
@@ -0,0 +1,6 @@
+
diff --git a/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.md5 b/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.md5
new file mode 100644
index 000000000..da9dbaf40
--- /dev/null
+++ b/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.md5
@@ -0,0 +1 @@
+fbc7b8c39328fdeb00baa02dadb94ca6
\ No newline at end of file
diff --git a/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.svg b/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.svg
new file mode 100644
index 000000000..e611a5eb6
--- /dev/null
+++ b/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.svg
@@ -0,0 +1,67 @@
+
+
+
+
+
diff --git a/de/d4a/class_compare.html b/de/d4a/class_compare.html
new file mode 100644
index 000000000..3bea0dd03
--- /dev/null
+++ b/de/d4a/class_compare.html
@@ -0,0 +1,195 @@
+
+
+
+
+
+
+
+Algorithms_in_C++: Compare< S, T, E > Class Template Reference
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Algorithms_in_C++ 1.0.0
+
+ Set of algorithms implemented in C++.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Compare< S, T, E > Class Template Reference
+
+
+
+Comparator class for priority queue.
+ More...
+
+
+Public Member Functions
bool operator() (tuple< S, T, E, double, double, double > &t1, tuple< S, T, E, double, double, double > &t2) A comparator function that checks whether to swap the two tuples or not. to https://www.geeksforgeeks.org/comparator-class-in-c-with-examples/ for detailed description of comparator. More...
+Detailed Description
+template<typename S, typename T, typename E>
+class Compare< S, T, E >Comparator class for priority queue.
+- Template Parameters
-
+
+ S Data type of Process ID T Data type of Arrival time E Data type of Burst time
+
+
+Member Function Documentation
+
+◆ operator()()
+
+
+
+
+template<typename S , typename T , typename E >
+
+
+
+
+
+ bool Compare< S, T, E >::operator()
+ (
+ tuple< S, T, E, double, double, double > &
+ t1,
+
+
+ tuple< S, T, E, double, double, double > &
+ t2
+
+
+ )
+
+
+
+
+inline
+
+
+
+
+A comparator function that checks whether to swap the two tuples or not. to https://www.geeksforgeeks.org/comparator-class-in-c-with-examples/ for detailed description of comparator.
+- Parameters
-
+
+ t1 First tuple t2 Second tuple
+
+
+- Returns
- true if the tuples SHOULD be swapped
+-
+false if the tuples SHOULDN'T be swapped
+
+
+
+
The documentation for this class was generated from the following file:
+- cpu_scheduling_algorithms/fcfs_scheduling.cpp
+
+
+
+
+
+
+
+ - Generated by 1.9.2
+
+
+
+
diff --git a/de/d4a/class_compare.js b/de/d4a/class_compare.js
new file mode 100644
index 000000000..f123aff03
--- /dev/null
+++ b/de/d4a/class_compare.js
@@ -0,0 +1,4 @@
+var class_compare =
+[
+ [ "operator()", "de/d4a/class_compare.html#afbdf9a44adb49728dc704155d7d1570c", null ]
+];
\ No newline at end of file
diff --git a/de/d8d/class_f_c_f_s-members.html b/de/d8d/class_f_c_f_s-members.html
new file mode 100644
index 000000000..5afa21c6c
--- /dev/null
+++ b/de/d8d/class_f_c_f_s-members.html
@@ -0,0 +1,114 @@
+
+
+
+
+
+
+
+Algorithms_in_C++: Member List
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Algorithms_in_C++ 1.0.0
+
+ Set of algorithms implemented in C++.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ FCFS< S, T, E > Member List
+
+
+
+This is the complete list of members for FCFS< S, T, E >, including all inherited members.
+
+ addProcess(S id, T arrival, E burst) FCFS< S, T, E > inline idList (defined in FCFS< S, T, E >) FCFS< S, T, E > private printResult() FCFS< S, T, E > inline result (defined in FCFS< S, T, E >) FCFS< S, T, E > private schedule FCFS< S, T, E > private scheduleForFcfs() FCFS< S, T, E > inline
+
+
+
+
+ - Generated by 1.9.2
+
+
+
+
diff --git a/df/d47/fcfs__scheduling_8cpp.html b/df/d47/fcfs__scheduling_8cpp.html
new file mode 100644
index 000000000..298493c7c
--- /dev/null
+++ b/df/d47/fcfs__scheduling_8cpp.html
@@ -0,0 +1,376 @@
+
+
+
+
+
+
+
+Algorithms_in_C++: cpu_scheduling_algorithms/fcfs_scheduling.cpp File Reference
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Algorithms_in_C++ 1.0.0
+
+ Set of algorithms implemented in C++.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Implementation of FCFS CPU scheduling algorithm.
+More...
+#include <algorithm>
+#include <cassert>
+#include <cstdlib>
+#include <ctime>
+#include <iomanip>
+#include <iostream>
+#include <queue>
+#include <unordered_set>
+#include <vector>
+
+Include dependency graph for fcfs_scheduling.cpp:
+
+
+
+
+
+
+Classes
class Compare< S, T, E > Comparator class for priority queue. More...
class FCFS< S, T, E > Class which implements the FCFS scheduling algorithm. More...
+
+Functions
template<typename S , typename T , typename E > bool sortcol (tuple< S, T, E > &t1, tuple< S, T, E > &t2) Comparator function for sorting a vector. More...
template<typename S , typename T , typename E > vector< tuple< S, T, E, double, double, double > > get_final_status (vector< tuple< uint32_t, uint32_t, uint32_t > > input) Function to be used for testing purposes. This function guarantees the correct solution for FCFS scheduling algorithm. More...
static void test () Self-test implementations. More...
int main () Entry point of the program. More...
+Detailed Description
+Implementation of FCFS CPU scheduling algorithm.
+FCFS is a non-preemptive CPU scheduling algorithm in which whichever process arrives first, gets executed first. If two or more processes arrive simultaneously, the process with smaller process ID gets executed first. https://bit.ly/3ABNXOCPratyush Vatsa
+Function Documentation
+
+◆ get_final_status()
+
+
+
+
+template<typename S , typename T , typename E >
+
+
+ vector< tuple< S, T, E, double, double, double > > get_final_status
+ (
+ vector< tuple< uint32_t, uint32_t, uint32_t > >
+ input )
+
+
+
+
+Function to be used for testing purposes. This function guarantees the correct solution for FCFS scheduling algorithm.
+- Parameters
-
+
+ input the input data
+
+
+Sorts the input vector according to arrival time. Processes whose arrival times are same get sorted according to process ID For each process, completion time, turnaround time and completion time are calculated, inserted in a tuple, which is added to the vector result.
- Returns
- A vector of tuples consisting of process ID, arrival time, burst time, completion time, turnaround time and waiting time for each process.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+T begin(T... args)
+T end(T... args)
+
+T size(T... args)
+T sort(T... args)
+
+
+
+
+
+◆ main()
+
+
+
+
+
+ int main
+ (
+ void
+ )
+
+
+
+
+
+◆ sortcol()
+
+
+
+
+template<typename S , typename T , typename E >
+
+
+ bool sortcol
+ (
+ tuple< S, T, E > &
+ t1,
+
+
+ tuple< S, T, E > &
+ t2
+
+
+ )
+
+
+
+
+Comparator function for sorting a vector.
+- Template Parameters
-
+
+ S Data type of Process ID T Data type of Arrival time E Data type of Burst time
+
+
+- Parameters
-
+
+ t1 First tuple t2 Second tuple
+
+
+- Returns
- true if t1 and t2 are in the CORRECT order
+-
+false if t1 and t2 are in the INCORRECT order
+
+
+
+
+◆ test()
+
+
+
+
+
+
+
+
+ static void test
+ (
+ )
+
+
+
+
+static
+
+
+
+
+Self-test implementations.
+- Returns
- void
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+void addProcess(S id, T arrival, E burst)Adds the process to the ready queue if it isn't already there.Definition: fcfs_scheduling.cpp:129
+vector< tuple< S, T, E, double, double, double > > scheduleForFcfs()Algorithm for scheduling CPU processes according to the First Come First Serve(FCFS) scheduling algor...Definition: fcfs_scheduling.cpp:154
+
+T rand(T... args)
+T srand(T... args)
+T time(T... args)
+
+Here is the call graph for this function:
+
+
+
+
+
+
+
+
+
+
+
+
+
+ - Generated by 1.9.2
+
+
+
+
diff --git a/df/d47/fcfs__scheduling_8cpp.js b/df/d47/fcfs__scheduling_8cpp.js
new file mode 100644
index 000000000..3ab097c7e
--- /dev/null
+++ b/df/d47/fcfs__scheduling_8cpp.js
@@ -0,0 +1,9 @@
+var fcfs__scheduling_8cpp =
+[
+ [ "Compare< S, T, E >", "de/d4a/class_compare.html", "de/d4a/class_compare" ],
+ [ "FCFS< S, T, E >", "dd/dca/class_f_c_f_s.html", "dd/dca/class_f_c_f_s" ],
+ [ "get_final_status", "df/d47/fcfs__scheduling_8cpp.html#a8f2b90cb64d63a7080965e66a05ccf86", null ],
+ [ "main", "df/d47/fcfs__scheduling_8cpp.html#ae66f6b31b5ad750f1fe042a706a4e3d4", null ],
+ [ "sortcol", "df/d47/fcfs__scheduling_8cpp.html#a18920aa331faf4476b251c8cdb2c2bec", null ],
+ [ "test", "df/d47/fcfs__scheduling_8cpp.html#aa8dca7b867074164d5f45b0f3851269d", null ]
+];
\ No newline at end of file
diff --git a/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.map b/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.map
new file mode 100644
index 000000000..fac5223b9
--- /dev/null
+++ b/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.map
@@ -0,0 +1,8 @@
+
diff --git a/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.md5 b/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.md5
new file mode 100644
index 000000000..60334c7c9
--- /dev/null
+++ b/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.md5
@@ -0,0 +1 @@
+eb25f61bb3c01f732953e7b177f935be
\ No newline at end of file
diff --git a/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.svg b/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.svg
new file mode 100644
index 000000000..861a9adf2
--- /dev/null
+++ b/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.svg
@@ -0,0 +1,99 @@
+
+
+
+
+
diff --git a/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.map b/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.map
new file mode 100644
index 000000000..ae5ce9e63
--- /dev/null
+++ b/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.map
@@ -0,0 +1,9 @@
+
diff --git a/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.md5 b/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.md5
new file mode 100644
index 000000000..ad9c7536b
--- /dev/null
+++ b/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.md5
@@ -0,0 +1 @@
+d1153ad5effebcdd01be2ae30d68c8af
\ No newline at end of file
diff --git a/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.svg b/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.svg
new file mode 100644
index 000000000..d4ff69629
--- /dev/null
+++ b/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.svg
@@ -0,0 +1,114 @@
+
+
+
+
+
diff --git a/df/d66/vector__cross__product_8cpp.html b/df/d66/vector__cross__product_8cpp.html
index 71f0fb3b7..cc70bdf6c 100644
--- a/df/d66/vector__cross__product_8cpp.html
+++ b/df/d66/vector__cross__product_8cpp.html
@@ -144,7 +144,7 @@ Functions
The direction ratios (DR) are calculated as follows: 1st DR, J: (b * z) - (c * y) 2nd DR, A: -((a * z) - (c * x)) 3rd DR, N: (a * y) - (b * x)
Therefore, the direction ratios of the cross product are: J, A, N The following C++ Program calculates the direction ratios of the cross products of two vector. The program uses a function, cross() for doing so. The direction ratios for the first and the second vector has to be passed one by one seperated by a space character.
Magnitude of a vector is the square root of the sum of the squares of the direction ratios.
-
+
Example:
An example of a running instance of the executable program:
Pass the first Vector: 1 2 3
Pass the second Vector: 4 5 6 The cross product is: -3 6 -3 Magnitude: 7.34847
diff --git a/dir_000002_000016.html b/dir_000002_000017.html
similarity index 100%
rename from dir_000002_000016.html
rename to dir_000002_000017.html
diff --git a/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.map b/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.map
index 623879934..72fef3963 100644
--- a/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.map
+++ b/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.map
@@ -1,5 +1,5 @@
diff --git a/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.md5 b/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.md5
index 5fd2b3301..257e4dba0 100644
--- a/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.md5
+++ b/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.md5
@@ -1 +1 @@
-92fa4d7ae23a16161aeff73e457c6e1f
\ No newline at end of file
+76e5d78bae3066db57a72fde536d8c2e
\ No newline at end of file
diff --git a/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.svg b/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.svg
index d7d51943b..7af541bfb 100644
--- a/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.svg
+++ b/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.svg
@@ -32,7 +32,7 @@
dir_4d6e05837bf820fb089a8a8cdf2f42b7->dir_9c6faab82c22511b50177aa2e38e2780
+
1
diff --git a/dir_cc8e79ed9d2b7756c78e8d0c87c6c0c7.html b/dir_cc8e79ed9d2b7756c78e8d0c87c6c0c7.html
new file mode 100644
index 000000000..7068e3381
--- /dev/null
+++ b/dir_cc8e79ed9d2b7756c78e8d0c87c6c0c7.html
@@ -0,0 +1,113 @@
+
+
+
+
+
+
+
+Algorithms_in_C++: cpu_scheduling_algorithms Directory Reference
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Algorithms_in_C++ 1.0.0
+
+ Set of algorithms implemented in C++.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ cpu_scheduling_algorithms Directory Reference
+
+
+
+
+Files
file fcfs_scheduling.cpp Implementation of FCFS CPU scheduling algorithm.
+
+
+
+
+
+
+ - Generated by 1.9.2
+
+
+
+
diff --git a/dir_cc8e79ed9d2b7756c78e8d0c87c6c0c7.js b/dir_cc8e79ed9d2b7756c78e8d0c87c6c0c7.js
new file mode 100644
index 000000000..804b70f89
--- /dev/null
+++ b/dir_cc8e79ed9d2b7756c78e8d0c87c6c0c7.js
@@ -0,0 +1,4 @@
+var dir_cc8e79ed9d2b7756c78e8d0c87c6c0c7 =
+[
+ [ "fcfs_scheduling.cpp", "df/d47/fcfs__scheduling_8cpp.html", "df/d47/fcfs__scheduling_8cpp" ]
+];
\ No newline at end of file
diff --git a/files.html b/files.html
index d3fdd7b77..6eaa50aa5 100644
--- a/files.html
+++ b/files.html
@@ -121,232 +121,234 @@ solve-a-rat-in-a-maze-c-java-pytho/"
- ► data_structures ► divide_and_conquer ► dynamic_programming ► geometry ► graph ► graphics ► greedy_algorithms ► hashing ► linear_algebra ► machine_learning ► math ► numerical_methods ► operations_on_datastructures ► others ► probability ► range_queries ► search ► sorting ► strings ► cpu_scheduling_algorithms ► data_structures ► divide_and_conquer ► dynamic_programming ► geometry ► graph ► graphics ► greedy_algorithms ► hashing ► linear_algebra ► machine_learning ► math ► numerical_methods ► operations_on_datastructures ► others ► probability ► range_queries ► search ► sorting ► strings
diff --git a/files_dup.js b/files_dup.js
index 927c6694b..685144116 100644
--- a/files_dup.js
+++ b/files_dup.js
@@ -3,6 +3,7 @@ var files_dup =
[ "backtracking", "dir_c11585dfcef32a26e29098facab6c144.html", "dir_c11585dfcef32a26e29098facab6c144" ],
[ "bit_manipulation", "dir_f3c4fbc4e901afa0a54d0623c5574aa7.html", "dir_f3c4fbc4e901afa0a54d0623c5574aa7" ],
[ "ciphers", "dir_4d6e05837bf820fb089a8a8cdf2f42b7.html", "dir_4d6e05837bf820fb089a8a8cdf2f42b7" ],
+ [ "cpu_scheduling_algorithms", "dir_cc8e79ed9d2b7756c78e8d0c87c6c0c7.html", "dir_cc8e79ed9d2b7756c78e8d0c87c6c0c7" ],
[ "data_structures", "dir_2e746e9d06bf2d8ff842208bcc6ebcfc.html", "dir_2e746e9d06bf2d8ff842208bcc6ebcfc" ],
[ "divide_and_conquer", "dir_93bc990c5cceb745f78af6949e9ef947.html", "dir_93bc990c5cceb745f78af6949e9ef947" ],
[ "dynamic_programming", "dir_8a20dd5bfd5341a725342bf72b6b686f.html", "dir_8a20dd5bfd5341a725342bf72b6b686f" ],
diff --git a/functions_a.html b/functions_a.html
index b6c1b9164..56bd8eb2f 100644
--- a/functions_a.html
+++ b/functions_a.html
@@ -103,6 +103,7 @@ $(document).ready(function(){initNavTree('functions_a.html',''); initResizable()
- add_digit() : large_number
- add_edge() : graph::Graph< T >, range_queries::heavy_light_decomposition::Tree< X >
- addEdge() : Graph, graph::HKGraph, graph::is_graph_bipartite::Graph
+- addProcess() : FCFS< S, T, E >
- addVertices() : Graph
- adj : graph::HKGraph, graph::is_graph_bipartite::Graph
- adjacency_list : graph::Graph< T >
diff --git a/functions_func_a.html b/functions_func_a.html
index 895b8d7b2..ce7a6fe56 100644
--- a/functions_func_a.html
+++ b/functions_func_a.html
@@ -101,6 +101,7 @@ $(document).ready(function(){initNavTree('functions_func_a.html',''); initResiza
- add_digit() : large_number
- add_edge() : graph::Graph< T >, range_queries::heavy_light_decomposition::Tree< X >
- addEdge() : Graph, graph::HKGraph, graph::is_graph_bipartite::Graph
+- addProcess() : FCFS< S, T, E >
- addVertices() : Graph
- arg() : Complex
- AyStarSearch() : machine_learning::aystar_search::AyStarSearch< Puzzle >
diff --git a/functions_func_i.html b/functions_func_i.html
index f6c10499c..b46256971 100644
--- a/functions_func_i.html
+++ b/functions_func_i.html
@@ -99,7 +99,7 @@ $(document).ready(function(){initNavTree('functions_func_i.html',''); initResiza
- init() : range_queries::heavy_light_decomposition::HLD< X >, range_queries::heavy_light_decomposition::Tree< X >
- inOrderIterative() : others::iterative_tree_traversals::BinaryTree
- insert() : binary_search_tree< T >, data_structures::linked_list::list, data_structures::list_array::list
-- Insert() : data_structures::tree_234::Tree234
+- Insert() : data_structures::tree_234::Tree234
- insert() : data_structures::trie, data_structures::trie_using_hashmap::Trie
- Insert() : operations_on_datastructures::trie_operations::Tnode
- insert() : probability::windowed_median::WindowedMedian, Trie
diff --git a/functions_func_o.html b/functions_func_o.html
index 2d36ddc58..524631ee8 100644
--- a/functions_func_o.html
+++ b/functions_func_o.html
@@ -105,7 +105,7 @@ $(document).ready(function(){initNavTree('functions_func_o.html',''); initResiza
- operator&() : uint128_t, uint256_t
- operator&&() : uint128_t, uint256_t
- operator&=() : uint128_t, uint256_t
-- operator()() : uint128_t, uint256_t
+- operator()() : Compare< S, T, E >, uint128_t, uint256_t
- operator*() : Complex, uint128_t, uint256_t
- operator*=() : large_number, uint128_t, uint256_t
- operator+() : Complex, uint128_t, uint256_t
diff --git a/functions_func_p.html b/functions_func_p.html
index 03847d40c..23611cdc6 100644
--- a/functions_func_p.html
+++ b/functions_func_p.html
@@ -103,6 +103,7 @@ $(document).ready(function(){initNavTree('functions_func_p.html',''); initResiza
- preOrderIterative() : others::iterative_tree_traversals::BinaryTree
- Print() : data_structures::tree_234::Tree234
- PrintNode() : data_structures::tree_234::Tree234
+- printResult() : FCFS< S, T, E >
- probability_density() : probability::geometric_dist::geometric_distribution
- push() : stack< Type >
- push_back() : data_structures::linked_list::list
diff --git a/functions_func_s.html b/functions_func_s.html
index 093c5d0f6..45a5ca001 100644
--- a/functions_func_s.html
+++ b/functions_func_s.html
@@ -94,6 +94,7 @@ $(document).ready(function(){initNavTree('functions_func_s.html',''); initResiza
- s -
- save_model() : machine_learning::neural_network::NeuralNetwork
+- scheduleForFcfs() : FCFS< S, T, E >
- search() : data_structures::linked_list::list, data_structures::trie, data_structures::trie_using_hashmap::Trie, Trie
- searchElement() : data_structures::SkipList
- SearchFreqSuggestions() : operations_on_datastructures::trie_operations::Tnode
diff --git a/functions_i.html b/functions_i.html
index 9c44e9eba..7f28ec0c7 100644
--- a/functions_i.html
+++ b/functions_i.html
@@ -99,7 +99,7 @@ $(document).ready(function(){initNavTree('functions_i.html',''); initResizable()
- init() : range_queries::heavy_light_decomposition::HLD< X >, range_queries::heavy_light_decomposition::Tree< X >
- inOrderIterative() : others::iterative_tree_traversals::BinaryTree
- insert() : binary_search_tree< T >, data_structures::linked_list::list, data_structures::list_array::list
-- Insert() : data_structures::tree_234::Tree234
+- Insert() : data_structures::tree_234::Tree234
- insert() : data_structures::trie, data_structures::trie_using_hashmap::Trie
- Insert() : operations_on_datastructures::trie_operations::Tnode
- insert() : probability::windowed_median::WindowedMedian, Trie
diff --git a/functions_o.html b/functions_o.html
index 6ac295c79..837e3e696 100644
--- a/functions_o.html
+++ b/functions_o.html
@@ -105,7 +105,7 @@ $(document).ready(function(){initNavTree('functions_o.html',''); initResizable()
- operator&() : uint128_t, uint256_t
- operator&&() : uint128_t, uint256_t
- operator&=() : uint128_t, uint256_t
-- operator()() : uint128_t, uint256_t
+- operator()() : Compare< S, T, E >, uint128_t, uint256_t
- operator*() : Complex, uint128_t, uint256_t
- operator*=() : large_number, uint128_t, uint256_t
- operator+() : Complex, large_number, uint128_t, uint256_t
diff --git a/functions_p.html b/functions_p.html
index 90430b6ff..183e64c23 100644
--- a/functions_p.html
+++ b/functions_p.html
@@ -110,6 +110,7 @@ $(document).ready(function(){initNavTree('functions_p.html',''); initResizable()
- preOrderIterative() : others::iterative_tree_traversals::BinaryTree
- Print() : data_structures::tree_234::Tree234
- PrintNode() : data_structures::tree_234::Tree234
+- printResult() : FCFS< S, T, E >
- probability_density() : probability::geometric_dist::geometric_distribution
- psucc : data_structures::linked_list::link
- ptrs : range_queries::perSegTree
diff --git a/functions_s.html b/functions_s.html
index d4dd818d0..32e7c85b4 100644
--- a/functions_s.html
+++ b/functions_s.html
@@ -96,6 +96,8 @@ $(document).ready(function(){initNavTree('functions_s.html',''); initResizable()
- s_size : range_queries::heavy_light_decomposition::SG< X >
- s_tree : range_queries::heavy_light_decomposition::SG< X >
- save_model() : machine_learning::neural_network::NeuralNetwork
+- schedule : FCFS< S, T, E >
+- scheduleForFcfs() : FCFS< S, T, E >
- search() : data_structures::linked_list::list, data_structures::trie, data_structures::trie_using_hashmap::Trie, Trie
- searchElement() : data_structures::SkipList
- SearchFreqSuggestions() : operations_on_datastructures::trie_operations::Tnode
diff --git a/functions_vars.html b/functions_vars.html
index 9752b512f..a47e938f3 100644
--- a/functions_vars.html
+++ b/functions_vars.html
@@ -217,6 +217,7 @@ $(document).ready(function(){initNavTree('functions_vars.html',''); initResizabl
- s -
- s_size : range_queries::heavy_light_decomposition::SG< X >
- s_tree : range_queries::heavy_light_decomposition::SG< X >
+- schedule : FCFS< S, T, E >
- side : graph::is_graph_bipartite::Graph
- size : stack< Type >
- size_ : binary_search_tree< T >
diff --git a/globals_func_g.html b/globals_func_g.html
index b8a49306e..dd9a8ec0e 100644
--- a/globals_func_g.html
+++ b/globals_func_g.html
@@ -96,6 +96,7 @@ $(document).ready(function(){initNavTree('globals_func_g.html',''); initResizabl
- gcd() : gcd_iterative_euclidean.cpp, gcd_of_n_numbers.cpp, gcd_recursive_euclidean.cpp, least_common_multiple.cpp
- genArray() : spiral_print.cpp
- get_clock_diff() : kohonen_som_topology.cpp, kohonen_som_trace.cpp
+- get_final_status() : fcfs_scheduling.cpp
- get_input() : ternary_search.cpp
- get_inverse() : ordinary_least_squares_regressor.cpp
- get_min_2d() : kohonen_som_topology.cpp
diff --git a/globals_func_i.html b/globals_func_i.html
index 7ce39a9c8..eaac1ff58 100644
--- a/globals_func_i.html
+++ b/globals_func_i.html
@@ -104,8 +104,8 @@ $(document).ready(function(){initNavTree('globals_func_i.html',''); initResizabl
- is_happy() : happy_number.cpp
- is_prime() : check_prime.cpp
- is_square() : ordinary_least_squares_regressor.cpp
-- isPrime() : modular_inverse_fermat_little_theorem.cpp
- IsPrime() : primality_test.cpp
+- isPrime() : modular_inverse_fermat_little_theorem.cpp
- it_ternary_search() : ternary_search.cpp
diff --git a/globals_func_m.html b/globals_func_m.html
index d58fdf390..875a674bd 100644
--- a/globals_func_m.html
+++ b/globals_func_m.html
@@ -93,7 +93,7 @@ $(document).ready(function(){initNavTree('globals_func_m.html',''); initResizabl
- m -
-- main() : graph_coloring.cpp, knight_tour.cpp, minimax.cpp, n_queens.cpp, n_queens_all_solution_optimised.cpp, nqueen_print_all_solutions.cpp, rat_maze.cpp, subarray_sum.cpp, subset_sum.cpp, sudoku_solve.cpp, wildcard_matching.cpp, count_of_set_bits.cpp, count_of_trailing_ciphers_in_factorial_n.cpp, hamming_distance.cpp, caesar_cipher.cpp, elliptic_curve_key_exchange.cpp, hill_cipher.cpp, morse_code.cpp, vigenere_cipher.cpp, xor_cipher.cpp, avltree.cpp, disjoint_set.cpp, linked_list.cpp, linkedlist_implentation_usingarray.cpp, list_array.cpp, queue_using_array.cpp, queue_using_two_stacks.cpp, reverse_a_linked_list.cpp, skip_list.cpp, sparse_table.cpp, tree_234.cpp, trie_modern.cpp, trie_tree.cpp, trie_using_hashmap.cpp, karatsuba_algorithm_for_fast_multiplication.cpp, 0_1_knapsack.cpp, abbreviation.cpp, coin_change_topdown.cpp, cut_rod.cpp, house_robber.cpp, kadane2.cpp, longest_increasing_subsequence.cpp, longest_palindromic_subsequence.cpp, minimum_edit_distance.cpp, palindrome_partitioning.cpp, shortest_common_supersequence.cpp, word_break.cpp, jarvis_algorithm.cpp, line_segment_intersection.cpp, bidirectional_dijkstra.cpp, breadth_first_search.cpp, connected_components.cpp, connected_components_with_dsu.cpp, depth_first_search.cpp, depth_first_search_with_stack.cpp, dijkstra.cpp, hamiltons_cycle.cpp, hopcroft_karp.cpp, is_graph_bipartite.cpp, lowest_common_ancestor.cpp, travelling_salesman_problem.cpp, spirograph.cpp, jumpgame.cpp, chaining.cpp, double_hash_hash_table.cpp, linear_probing_hash_table.cpp, md5.cpp, quadratic_probing_hash_table.cpp, sha1.cpp, gram_schmidt.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, neural_network.cpp, ordinary_least_squares_regressor.cpp, armstrong_number.cpp, binary_exponent.cpp, binomial_calculate.cpp, check_amicable_pair.cpp, check_factorial.cpp, check_prime.cpp, complex_numbers.cpp, double_factorial.cpp, eulers_totient_function.cpp, extended_euclid_algorithm.cpp, factorial.cpp, fast_power.cpp, fibonacci.cpp, fibonacci_fast.cpp, fibonacci_matrix_exponentiation.cpp, fibonacci_sum.cpp, finding_number_of_digits_in_a_number.cpp, gcd_iterative_euclidean.cpp, gcd_of_n_numbers.cpp, gcd_recursive_euclidean.cpp, integral_approximation.cpp, inv_sqrt.cpp, large_factorial.cpp, largest_power.cpp, lcm_sum.cpp, least_common_multiple.cpp, magic_number.cpp, miller_rabin.cpp, modular_division.cpp, modular_exponentiation.cpp, modular_inverse_fermat_little_theorem.cpp, n_bonacci.cpp, n_choose_r.cpp, ncr_modulo_p.cpp, number_of_positive_divisors.cpp, power_for_huge_numbers.cpp, power_of_two.cpp, prime_factorization.cpp, prime_numbers.cpp, primes_up_to_billion.cpp, realtime_stats.cpp, sieve_of_eratosthenes.cpp, sqrt_double.cpp, string_fibonacci.cpp, sum_of_binomial_coefficient.cpp, sum_of_digits.cpp, vector_cross_product.cpp, bisection_method.cpp, brent_method_extrema.cpp, false_position.cpp, gaussian_elimination.cpp, golden_search_extrema.cpp, lu_decompose.cpp, newton_raphson_method.cpp, ode_forward_euler.cpp, ode_midpoint_euler.cpp, ode_semi_implicit_euler.cpp, qr_decomposition.cpp, qr_eigen_values.cpp, rungekutta.cpp, successive_approximation.cpp, inorder_successor_of_bst.cpp, trie_multiple_search.cpp, buzz_number.cpp, decimal_to_hexadecimal.cpp, decimal_to_roman_numeral.cpp, fast_integer_input.cpp, happy_number.cpp, iterative_tree_traversals.cpp, kadanes3.cpp, lru_cache.cpp, matrix_exponentiation.cpp, palindrome_of_number.cpp, pascal_triangle.cpp, postfix_evaluation.cpp, primality_test.cpp, smallest_circle.cpp, sparse_matrix.cpp, spiral_print.cpp, stairs_pattern.cpp, tower_of_hanoi.cpp, vector_important_functions.cpp, addition_rule.cpp, bayes_theorem.cpp, binomial_dist.cpp, geometric_dist.cpp, poisson_dist.cpp, windowed_median.cpp, fenwick_tree.cpp, heavy_light_decomposition.cpp, persistent_seg_tree_lazy_prop.cpp, prefix_sum_array.cpp, sparse_table.cpp, binary_search.cpp, exponential_search.cpp, fibonacci_search.cpp, floyd_cycle_detection_algo.cpp, hash_search.cpp, interpolation_search.cpp, interpolation_search2.cpp, linear_search.cpp, median_search.cpp, saddleback_search.cpp, sublist_search.cpp, ternary_search.cpp, text_search.cpp, bogo_sort.cpp, comb_sort.cpp, count_inversions.cpp, cycle_sort.cpp, dnf_sort.cpp, gnome_sort.cpp, heap_sort.cpp, insertion_sort.cpp, merge_insertion_sort.cpp, merge_sort.cpp, pancake_sort.cpp, pigeonhole_sort.cpp, quick_sort.cpp, quick_sort_3.cpp, radix_sort2.cpp, random_pivot_quick_sort.cpp, recursive_bubble_sort.cpp, selection_sort_recursive.cpp, shell_sort2.cpp, strand_sort.cpp, wave_sort.cpp, brute_force_string_searching.cpp, horspool.cpp, knuth_morris_pratt.cpp, manacher_algorithm.cpp, rabin_karp.cpp, z_function.cpp
+- main() : graph_coloring.cpp, knight_tour.cpp, minimax.cpp, n_queens.cpp, n_queens_all_solution_optimised.cpp, nqueen_print_all_solutions.cpp, rat_maze.cpp, subarray_sum.cpp, subset_sum.cpp, sudoku_solve.cpp, wildcard_matching.cpp, count_of_set_bits.cpp, count_of_trailing_ciphers_in_factorial_n.cpp, hamming_distance.cpp, caesar_cipher.cpp, elliptic_curve_key_exchange.cpp, hill_cipher.cpp, morse_code.cpp, vigenere_cipher.cpp, xor_cipher.cpp, fcfs_scheduling.cpp, avltree.cpp, disjoint_set.cpp, linked_list.cpp, linkedlist_implentation_usingarray.cpp, list_array.cpp, queue_using_array.cpp, queue_using_two_stacks.cpp, reverse_a_linked_list.cpp, skip_list.cpp, sparse_table.cpp, tree_234.cpp, trie_modern.cpp, trie_tree.cpp, trie_using_hashmap.cpp, karatsuba_algorithm_for_fast_multiplication.cpp, 0_1_knapsack.cpp, abbreviation.cpp, coin_change_topdown.cpp, cut_rod.cpp, house_robber.cpp, kadane2.cpp, longest_increasing_subsequence.cpp, longest_palindromic_subsequence.cpp, minimum_edit_distance.cpp, palindrome_partitioning.cpp, shortest_common_supersequence.cpp, word_break.cpp, jarvis_algorithm.cpp, line_segment_intersection.cpp, bidirectional_dijkstra.cpp, breadth_first_search.cpp, connected_components.cpp, connected_components_with_dsu.cpp, depth_first_search.cpp, depth_first_search_with_stack.cpp, dijkstra.cpp, hamiltons_cycle.cpp, hopcroft_karp.cpp, is_graph_bipartite.cpp, lowest_common_ancestor.cpp, travelling_salesman_problem.cpp, spirograph.cpp, jumpgame.cpp, chaining.cpp, double_hash_hash_table.cpp, linear_probing_hash_table.cpp, md5.cpp, quadratic_probing_hash_table.cpp, sha1.cpp, gram_schmidt.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, neural_network.cpp, ordinary_least_squares_regressor.cpp, armstrong_number.cpp, binary_exponent.cpp, binomial_calculate.cpp, check_amicable_pair.cpp, check_factorial.cpp, check_prime.cpp, complex_numbers.cpp, double_factorial.cpp, eulers_totient_function.cpp, extended_euclid_algorithm.cpp, factorial.cpp, fast_power.cpp, fibonacci.cpp, fibonacci_fast.cpp, fibonacci_matrix_exponentiation.cpp, fibonacci_sum.cpp, finding_number_of_digits_in_a_number.cpp, gcd_iterative_euclidean.cpp, gcd_of_n_numbers.cpp, gcd_recursive_euclidean.cpp, integral_approximation.cpp, inv_sqrt.cpp, large_factorial.cpp, largest_power.cpp, lcm_sum.cpp, least_common_multiple.cpp, magic_number.cpp, miller_rabin.cpp, modular_division.cpp, modular_exponentiation.cpp, modular_inverse_fermat_little_theorem.cpp, n_bonacci.cpp, n_choose_r.cpp, ncr_modulo_p.cpp, number_of_positive_divisors.cpp, power_for_huge_numbers.cpp, power_of_two.cpp, prime_factorization.cpp, prime_numbers.cpp, primes_up_to_billion.cpp, realtime_stats.cpp, sieve_of_eratosthenes.cpp, sqrt_double.cpp, string_fibonacci.cpp, sum_of_binomial_coefficient.cpp, sum_of_digits.cpp, vector_cross_product.cpp, bisection_method.cpp, brent_method_extrema.cpp, false_position.cpp, gaussian_elimination.cpp, golden_search_extrema.cpp, lu_decompose.cpp, newton_raphson_method.cpp, ode_forward_euler.cpp, ode_midpoint_euler.cpp, ode_semi_implicit_euler.cpp, qr_decomposition.cpp, qr_eigen_values.cpp, rungekutta.cpp, successive_approximation.cpp, inorder_successor_of_bst.cpp, trie_multiple_search.cpp, buzz_number.cpp, decimal_to_hexadecimal.cpp, decimal_to_roman_numeral.cpp, fast_integer_input.cpp, happy_number.cpp, iterative_tree_traversals.cpp, kadanes3.cpp, lru_cache.cpp, matrix_exponentiation.cpp, palindrome_of_number.cpp, pascal_triangle.cpp, postfix_evaluation.cpp, primality_test.cpp, smallest_circle.cpp, sparse_matrix.cpp, spiral_print.cpp, stairs_pattern.cpp, tower_of_hanoi.cpp, vector_important_functions.cpp, addition_rule.cpp, bayes_theorem.cpp, binomial_dist.cpp, geometric_dist.cpp, poisson_dist.cpp, windowed_median.cpp, fenwick_tree.cpp, heavy_light_decomposition.cpp, persistent_seg_tree_lazy_prop.cpp, prefix_sum_array.cpp, sparse_table.cpp, binary_search.cpp, exponential_search.cpp, fibonacci_search.cpp, floyd_cycle_detection_algo.cpp, hash_search.cpp, interpolation_search.cpp, interpolation_search2.cpp, linear_search.cpp, median_search.cpp, saddleback_search.cpp, sublist_search.cpp, ternary_search.cpp, text_search.cpp, bogo_sort.cpp, comb_sort.cpp, count_inversions.cpp, cycle_sort.cpp, dnf_sort.cpp, gnome_sort.cpp, heap_sort.cpp, insertion_sort.cpp, merge_insertion_sort.cpp, merge_sort.cpp, pancake_sort.cpp, pigeonhole_sort.cpp, quick_sort.cpp, quick_sort_3.cpp, radix_sort2.cpp, random_pivot_quick_sort.cpp, recursive_bubble_sort.cpp, selection_sort_recursive.cpp, shell_sort2.cpp, strand_sort.cpp, wave_sort.cpp, brute_force_string_searching.cpp, horspool.cpp, knuth_morris_pratt.cpp, manacher_algorithm.cpp, rabin_karp.cpp, z_function.cpp
- mat_mul() : qr_eigen_values.cpp
- max_subarray_sum() : kadanes3.cpp
- merge() : merge_sort.cpp
diff --git a/globals_func_s.html b/globals_func_s.html
index a466aaaa6..660161a70 100644
--- a/globals_func_s.html
+++ b/globals_func_s.html
@@ -104,9 +104,10 @@ $(document).ready(function(){initNavTree('globals_func_s.html',''); initResizabl
- show_array() : bogo_sort.cpp
- show_data() : shell_sort2.cpp
- show_pascal() : pascal_triangle.cpp
-- sieve() : sieve_of_eratosthenes.cpp
- Sieve() : primes_up_to_billion.cpp
+- sieve() : sieve_of_eratosthenes.cpp
- SieveOfEratosthenes() : prime_factorization.cpp
+- sortcol() : fcfs_scheduling.cpp
- spiralPrint() : spiral_print.cpp
- Sqrt() : sqrt_double.cpp
- Standard_InvSqrt() : inv_sqrt.cpp
diff --git a/globals_func_t.html b/globals_func_t.html
index 71ab7f4f2..bc57baac7 100644
--- a/globals_func_t.html
+++ b/globals_func_t.html
@@ -94,7 +94,7 @@ $(document).ready(function(){initNavTree('globals_func_t.html',''); initResizabl
- t -
- ternary_search() : ternary_search.cpp
-- test() : rat_maze.cpp, subarray_sum.cpp, subset_sum.cpp, wildcard_matching.cpp, count_of_set_bits.cpp, count_of_trailing_ciphers_in_factorial_n.cpp, hamming_distance.cpp, caesar_cipher.cpp, elliptic_curve_key_exchange.cpp, morse_code.cpp, vigenere_cipher.cpp, xor_cipher.cpp, list_array.cpp, reverse_a_linked_list.cpp, sparse_table.cpp, trie_tree.cpp, trie_using_hashmap.cpp, karatsuba_algorithm_for_fast_multiplication.cpp, 0_1_knapsack.cpp, abbreviation.cpp, coin_change_topdown.cpp, cut_rod.cpp, house_robber.cpp, longest_increasing_subsequence.cpp, longest_palindromic_subsequence.cpp, minimum_edit_distance.cpp, palindrome_partitioning.cpp, shortest_common_supersequence.cpp, word_break.cpp, jarvis_algorithm.cpp, connected_components_with_dsu.cpp, is_graph_bipartite.cpp, jumpgame.cpp, md5.cpp, sha1.cpp, gram_schmidt.cpp, neural_network.cpp, armstrong_number.cpp, check_amicable_pair.cpp, double_factorial.cpp, fibonacci.cpp, fibonacci_matrix_exponentiation.cpp, fibonacci_sum.cpp, finding_number_of_digits_in_a_number.cpp, inv_sqrt.cpp, largest_power.cpp, lcm_sum.cpp, modular_division.cpp, modular_exponentiation.cpp, n_bonacci.cpp, n_choose_r.cpp, sum_of_binomial_coefficient.cpp, sum_of_digits.cpp, vector_cross_product.cpp, rungekutta.cpp, inorder_successor_of_bst.cpp, trie_multiple_search.cpp, kadanes3.cpp, smallest_circle.cpp, geometric_dist.cpp, windowed_median.cpp, persistent_seg_tree_lazy_prop.cpp, prefix_sum_array.cpp, floyd_cycle_detection_algo.cpp, median_search.cpp, saddleback_search.cpp, sublist_search.cpp, text_search.cpp, bogo_sort.cpp, count_inversions.cpp, cycle_sort.cpp, dnf_sort.cpp, gnome_sort.cpp, heap_sort.cpp, merge_insertion_sort.cpp, pancake_sort.cpp, random_pivot_quick_sort.cpp, recursive_bubble_sort.cpp, selection_sort_recursive.cpp, strand_sort.cpp, wave_sort.cpp, wiggle_sort.cpp, horspool.cpp, manacher_algorithm.cpp, z_function.cpp
+- test() : rat_maze.cpp, subarray_sum.cpp, subset_sum.cpp, wildcard_matching.cpp, count_of_set_bits.cpp, count_of_trailing_ciphers_in_factorial_n.cpp, hamming_distance.cpp, caesar_cipher.cpp, elliptic_curve_key_exchange.cpp, morse_code.cpp, vigenere_cipher.cpp, xor_cipher.cpp, fcfs_scheduling.cpp, list_array.cpp, reverse_a_linked_list.cpp, sparse_table.cpp, trie_tree.cpp, trie_using_hashmap.cpp, karatsuba_algorithm_for_fast_multiplication.cpp, 0_1_knapsack.cpp, abbreviation.cpp, coin_change_topdown.cpp, cut_rod.cpp, house_robber.cpp, longest_increasing_subsequence.cpp, longest_palindromic_subsequence.cpp, minimum_edit_distance.cpp, palindrome_partitioning.cpp, shortest_common_supersequence.cpp, word_break.cpp, jarvis_algorithm.cpp, connected_components_with_dsu.cpp, is_graph_bipartite.cpp, jumpgame.cpp, md5.cpp, sha1.cpp, gram_schmidt.cpp, neural_network.cpp, armstrong_number.cpp, check_amicable_pair.cpp, double_factorial.cpp, fibonacci.cpp, fibonacci_matrix_exponentiation.cpp, fibonacci_sum.cpp, finding_number_of_digits_in_a_number.cpp, inv_sqrt.cpp, largest_power.cpp, lcm_sum.cpp, modular_division.cpp, modular_exponentiation.cpp, n_bonacci.cpp, n_choose_r.cpp, sum_of_binomial_coefficient.cpp, sum_of_digits.cpp, vector_cross_product.cpp, rungekutta.cpp, inorder_successor_of_bst.cpp, trie_multiple_search.cpp, kadanes3.cpp, smallest_circle.cpp, geometric_dist.cpp, windowed_median.cpp, persistent_seg_tree_lazy_prop.cpp, prefix_sum_array.cpp, floyd_cycle_detection_algo.cpp, median_search.cpp, saddleback_search.cpp, sublist_search.cpp, text_search.cpp, bogo_sort.cpp, count_inversions.cpp, cycle_sort.cpp, dnf_sort.cpp, gnome_sort.cpp, heap_sort.cpp, merge_insertion_sort.cpp, pancake_sort.cpp, random_pivot_quick_sort.cpp, recursive_bubble_sort.cpp, selection_sort_recursive.cpp, strand_sort.cpp, wave_sort.cpp, wiggle_sort.cpp, horspool.cpp, manacher_algorithm.cpp, z_function.cpp
- test1() : hill_cipher.cpp, tree_234.cpp, hamiltons_cycle.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, large_factorial.cpp, sum_of_digits.cpp, brent_method_extrema.cpp, durand_kerner_roots.cpp, golden_search_extrema.cpp, lu_decompose.cpp, qr_eigen_values.cpp, iterative_tree_traversals.cpp
- test2() : hill_cipher.cpp, tree_234.cpp, hamiltons_cycle.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, large_factorial.cpp, sum_of_digits.cpp, brent_method_extrema.cpp, durand_kerner_roots.cpp, golden_search_extrema.cpp, lu_decompose.cpp, qr_eigen_values.cpp, iterative_tree_traversals.cpp, smallest_circle.cpp
- test3() : hamiltons_cycle.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, brent_method_extrema.cpp, golden_search_extrema.cpp, iterative_tree_traversals.cpp, smallest_circle.cpp
diff --git a/globals_g.html b/globals_g.html
index 3ac0c9f47..5ba25513f 100644
--- a/globals_g.html
+++ b/globals_g.html
@@ -96,6 +96,7 @@ $(document).ready(function(){initNavTree('globals_g.html',''); initResizable();
- gcd() : gcd_iterative_euclidean.cpp, gcd_of_n_numbers.cpp, gcd_recursive_euclidean.cpp, least_common_multiple.cpp
- genArray() : spiral_print.cpp
- get_clock_diff() : kohonen_som_topology.cpp, kohonen_som_trace.cpp
+- get_final_status() : fcfs_scheduling.cpp
- get_input() : ternary_search.cpp
- get_inverse() : ordinary_least_squares_regressor.cpp
- get_min_2d() : kohonen_som_topology.cpp
diff --git a/globals_i.html b/globals_i.html
index b5d750823..d3d28f433 100644
--- a/globals_i.html
+++ b/globals_i.html
@@ -105,9 +105,9 @@ $(document).ready(function(){initNavTree('globals_i.html',''); initResizable();
- is_happy() : happy_number.cpp
- is_prime() : check_prime.cpp
- is_square() : ordinary_least_squares_regressor.cpp
-- isprime : prime_factorization.cpp
-- isPrime() : modular_inverse_fermat_little_theorem.cpp
- IsPrime() : primality_test.cpp
+- isPrime() : modular_inverse_fermat_little_theorem.cpp
+- isprime : prime_factorization.cpp
- it_ternary_search() : ternary_search.cpp
diff --git a/globals_m.html b/globals_m.html
index 535edf2d6..20a5e3871 100644
--- a/globals_m.html
+++ b/globals_m.html
@@ -93,7 +93,7 @@ $(document).ready(function(){initNavTree('globals_m.html',''); initResizable();
Here is a list of all documented file members with links to the documentation:
- m -
-- main() : graph_coloring.cpp, knight_tour.cpp, minimax.cpp, n_queens.cpp, n_queens_all_solution_optimised.cpp, nqueen_print_all_solutions.cpp, rat_maze.cpp, subarray_sum.cpp, subset_sum.cpp, sudoku_solve.cpp, wildcard_matching.cpp, count_of_set_bits.cpp, count_of_trailing_ciphers_in_factorial_n.cpp, hamming_distance.cpp, caesar_cipher.cpp, elliptic_curve_key_exchange.cpp, hill_cipher.cpp, morse_code.cpp, vigenere_cipher.cpp, xor_cipher.cpp, avltree.cpp, disjoint_set.cpp, linked_list.cpp, linkedlist_implentation_usingarray.cpp, list_array.cpp, queue_using_array.cpp, queue_using_two_stacks.cpp, reverse_a_linked_list.cpp, skip_list.cpp, sparse_table.cpp, tree_234.cpp, trie_modern.cpp, trie_tree.cpp, trie_using_hashmap.cpp, karatsuba_algorithm_for_fast_multiplication.cpp, 0_1_knapsack.cpp, abbreviation.cpp, coin_change_topdown.cpp, cut_rod.cpp, house_robber.cpp, kadane2.cpp, longest_increasing_subsequence.cpp, longest_palindromic_subsequence.cpp, minimum_edit_distance.cpp, palindrome_partitioning.cpp, shortest_common_supersequence.cpp, word_break.cpp, jarvis_algorithm.cpp, line_segment_intersection.cpp, bidirectional_dijkstra.cpp, breadth_first_search.cpp, connected_components.cpp, connected_components_with_dsu.cpp, depth_first_search.cpp, depth_first_search_with_stack.cpp, dijkstra.cpp, hamiltons_cycle.cpp, hopcroft_karp.cpp, is_graph_bipartite.cpp, lowest_common_ancestor.cpp, travelling_salesman_problem.cpp, spirograph.cpp, jumpgame.cpp, chaining.cpp, double_hash_hash_table.cpp, linear_probing_hash_table.cpp, md5.cpp, quadratic_probing_hash_table.cpp, sha1.cpp, gram_schmidt.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, neural_network.cpp, ordinary_least_squares_regressor.cpp, armstrong_number.cpp, binary_exponent.cpp, binomial_calculate.cpp, check_amicable_pair.cpp, check_factorial.cpp, check_prime.cpp, complex_numbers.cpp, double_factorial.cpp, eulers_totient_function.cpp, extended_euclid_algorithm.cpp, factorial.cpp, fast_power.cpp, fibonacci.cpp, fibonacci_fast.cpp, fibonacci_matrix_exponentiation.cpp, fibonacci_sum.cpp, finding_number_of_digits_in_a_number.cpp, gcd_iterative_euclidean.cpp, gcd_of_n_numbers.cpp, gcd_recursive_euclidean.cpp, integral_approximation.cpp, inv_sqrt.cpp, large_factorial.cpp, largest_power.cpp, lcm_sum.cpp, least_common_multiple.cpp, magic_number.cpp, miller_rabin.cpp, modular_division.cpp, modular_exponentiation.cpp, modular_inverse_fermat_little_theorem.cpp, n_bonacci.cpp, n_choose_r.cpp, ncr_modulo_p.cpp, number_of_positive_divisors.cpp, power_for_huge_numbers.cpp, power_of_two.cpp, prime_factorization.cpp, prime_numbers.cpp, primes_up_to_billion.cpp, realtime_stats.cpp, sieve_of_eratosthenes.cpp, sqrt_double.cpp, string_fibonacci.cpp, sum_of_binomial_coefficient.cpp, sum_of_digits.cpp, vector_cross_product.cpp, bisection_method.cpp, brent_method_extrema.cpp, false_position.cpp, gaussian_elimination.cpp, golden_search_extrema.cpp, lu_decompose.cpp, newton_raphson_method.cpp, ode_forward_euler.cpp, ode_midpoint_euler.cpp, ode_semi_implicit_euler.cpp, qr_decomposition.cpp, qr_eigen_values.cpp, rungekutta.cpp, successive_approximation.cpp, inorder_successor_of_bst.cpp, trie_multiple_search.cpp, buzz_number.cpp, decimal_to_hexadecimal.cpp, decimal_to_roman_numeral.cpp, fast_integer_input.cpp, happy_number.cpp, iterative_tree_traversals.cpp, kadanes3.cpp, lru_cache.cpp, matrix_exponentiation.cpp, palindrome_of_number.cpp, pascal_triangle.cpp, postfix_evaluation.cpp, primality_test.cpp, smallest_circle.cpp, sparse_matrix.cpp, spiral_print.cpp, stairs_pattern.cpp, tower_of_hanoi.cpp, vector_important_functions.cpp, addition_rule.cpp, bayes_theorem.cpp, binomial_dist.cpp, geometric_dist.cpp, poisson_dist.cpp, windowed_median.cpp, fenwick_tree.cpp, heavy_light_decomposition.cpp, persistent_seg_tree_lazy_prop.cpp, prefix_sum_array.cpp, sparse_table.cpp, binary_search.cpp, exponential_search.cpp, fibonacci_search.cpp, floyd_cycle_detection_algo.cpp, hash_search.cpp, interpolation_search.cpp, interpolation_search2.cpp, linear_search.cpp, median_search.cpp, saddleback_search.cpp, sublist_search.cpp, ternary_search.cpp, text_search.cpp, bogo_sort.cpp, comb_sort.cpp, count_inversions.cpp, cycle_sort.cpp, dnf_sort.cpp, gnome_sort.cpp, heap_sort.cpp, insertion_sort.cpp, merge_insertion_sort.cpp, merge_sort.cpp, pancake_sort.cpp, pigeonhole_sort.cpp, quick_sort.cpp, quick_sort_3.cpp, radix_sort2.cpp, random_pivot_quick_sort.cpp, recursive_bubble_sort.cpp, selection_sort_recursive.cpp, shell_sort2.cpp, strand_sort.cpp, wave_sort.cpp, brute_force_string_searching.cpp, horspool.cpp, knuth_morris_pratt.cpp, manacher_algorithm.cpp, rabin_karp.cpp, z_function.cpp
+- main() : graph_coloring.cpp, knight_tour.cpp, minimax.cpp, n_queens.cpp, n_queens_all_solution_optimised.cpp, nqueen_print_all_solutions.cpp, rat_maze.cpp, subarray_sum.cpp, subset_sum.cpp, sudoku_solve.cpp, wildcard_matching.cpp, count_of_set_bits.cpp, count_of_trailing_ciphers_in_factorial_n.cpp, hamming_distance.cpp, caesar_cipher.cpp, elliptic_curve_key_exchange.cpp, hill_cipher.cpp, morse_code.cpp, vigenere_cipher.cpp, xor_cipher.cpp, fcfs_scheduling.cpp, avltree.cpp, disjoint_set.cpp, linked_list.cpp, linkedlist_implentation_usingarray.cpp, list_array.cpp, queue_using_array.cpp, queue_using_two_stacks.cpp, reverse_a_linked_list.cpp, skip_list.cpp, sparse_table.cpp, tree_234.cpp, trie_modern.cpp, trie_tree.cpp, trie_using_hashmap.cpp, karatsuba_algorithm_for_fast_multiplication.cpp, 0_1_knapsack.cpp, abbreviation.cpp, coin_change_topdown.cpp, cut_rod.cpp, house_robber.cpp, kadane2.cpp, longest_increasing_subsequence.cpp, longest_palindromic_subsequence.cpp, minimum_edit_distance.cpp, palindrome_partitioning.cpp, shortest_common_supersequence.cpp, word_break.cpp, jarvis_algorithm.cpp, line_segment_intersection.cpp, bidirectional_dijkstra.cpp, breadth_first_search.cpp, connected_components.cpp, connected_components_with_dsu.cpp, depth_first_search.cpp, depth_first_search_with_stack.cpp, dijkstra.cpp, hamiltons_cycle.cpp, hopcroft_karp.cpp, is_graph_bipartite.cpp, lowest_common_ancestor.cpp, travelling_salesman_problem.cpp, spirograph.cpp, jumpgame.cpp, chaining.cpp, double_hash_hash_table.cpp, linear_probing_hash_table.cpp, md5.cpp, quadratic_probing_hash_table.cpp, sha1.cpp, gram_schmidt.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, neural_network.cpp, ordinary_least_squares_regressor.cpp, armstrong_number.cpp, binary_exponent.cpp, binomial_calculate.cpp, check_amicable_pair.cpp, check_factorial.cpp, check_prime.cpp, complex_numbers.cpp, double_factorial.cpp, eulers_totient_function.cpp, extended_euclid_algorithm.cpp, factorial.cpp, fast_power.cpp, fibonacci.cpp, fibonacci_fast.cpp, fibonacci_matrix_exponentiation.cpp, fibonacci_sum.cpp, finding_number_of_digits_in_a_number.cpp, gcd_iterative_euclidean.cpp, gcd_of_n_numbers.cpp, gcd_recursive_euclidean.cpp, integral_approximation.cpp, inv_sqrt.cpp, large_factorial.cpp, largest_power.cpp, lcm_sum.cpp, least_common_multiple.cpp, magic_number.cpp, miller_rabin.cpp, modular_division.cpp, modular_exponentiation.cpp, modular_inverse_fermat_little_theorem.cpp, n_bonacci.cpp, n_choose_r.cpp, ncr_modulo_p.cpp, number_of_positive_divisors.cpp, power_for_huge_numbers.cpp, power_of_two.cpp, prime_factorization.cpp, prime_numbers.cpp, primes_up_to_billion.cpp, realtime_stats.cpp, sieve_of_eratosthenes.cpp, sqrt_double.cpp, string_fibonacci.cpp, sum_of_binomial_coefficient.cpp, sum_of_digits.cpp, vector_cross_product.cpp, bisection_method.cpp, brent_method_extrema.cpp, false_position.cpp, gaussian_elimination.cpp, golden_search_extrema.cpp, lu_decompose.cpp, newton_raphson_method.cpp, ode_forward_euler.cpp, ode_midpoint_euler.cpp, ode_semi_implicit_euler.cpp, qr_decomposition.cpp, qr_eigen_values.cpp, rungekutta.cpp, successive_approximation.cpp, inorder_successor_of_bst.cpp, trie_multiple_search.cpp, buzz_number.cpp, decimal_to_hexadecimal.cpp, decimal_to_roman_numeral.cpp, fast_integer_input.cpp, happy_number.cpp, iterative_tree_traversals.cpp, kadanes3.cpp, lru_cache.cpp, matrix_exponentiation.cpp, palindrome_of_number.cpp, pascal_triangle.cpp, postfix_evaluation.cpp, primality_test.cpp, smallest_circle.cpp, sparse_matrix.cpp, spiral_print.cpp, stairs_pattern.cpp, tower_of_hanoi.cpp, vector_important_functions.cpp, addition_rule.cpp, bayes_theorem.cpp, binomial_dist.cpp, geometric_dist.cpp, poisson_dist.cpp, windowed_median.cpp, fenwick_tree.cpp, heavy_light_decomposition.cpp, persistent_seg_tree_lazy_prop.cpp, prefix_sum_array.cpp, sparse_table.cpp, binary_search.cpp, exponential_search.cpp, fibonacci_search.cpp, floyd_cycle_detection_algo.cpp, hash_search.cpp, interpolation_search.cpp, interpolation_search2.cpp, linear_search.cpp, median_search.cpp, saddleback_search.cpp, sublist_search.cpp, ternary_search.cpp, text_search.cpp, bogo_sort.cpp, comb_sort.cpp, count_inversions.cpp, cycle_sort.cpp, dnf_sort.cpp, gnome_sort.cpp, heap_sort.cpp, insertion_sort.cpp, merge_insertion_sort.cpp, merge_sort.cpp, pancake_sort.cpp, pigeonhole_sort.cpp, quick_sort.cpp, quick_sort_3.cpp, radix_sort2.cpp, random_pivot_quick_sort.cpp, recursive_bubble_sort.cpp, selection_sort_recursive.cpp, shell_sort2.cpp, strand_sort.cpp, wave_sort.cpp, brute_force_string_searching.cpp, horspool.cpp, knuth_morris_pratt.cpp, manacher_algorithm.cpp, rabin_karp.cpp, z_function.cpp
- mat_mul() : qr_eigen_values.cpp
- mat_size : matrix_exponentiation.cpp
- matrix : lu_decomposition.h
diff --git a/globals_p.html b/globals_p.html
index 0e47ba48a..73d842724 100644
--- a/globals_p.html
+++ b/globals_p.html
@@ -105,8 +105,8 @@ $(document).ready(function(){initNavTree('globals_p.html',''); initResizable();
- pop() : paranthesis_matching.cpp
- power() : power_for_huge_numbers.cpp, matrix_exponentiation.cpp
- predict_OLS_regressor() : ordinary_least_squares_regressor.cpp
-- prime : primes_up_to_billion.cpp
- PRIME : rabin_karp.cpp
+- prime : primes_up_to_billion.cpp
- prime_factorization() : prime_factorization.cpp
- prime_numbers : prime_factorization.cpp
- primes() : prime_numbers.cpp
diff --git a/globals_s.html b/globals_s.html
index f161f7de4..d77d8bf54 100644
--- a/globals_s.html
+++ b/globals_s.html
@@ -104,9 +104,10 @@ $(document).ready(function(){initNavTree('globals_s.html',''); initResizable();
- show_array() : bogo_sort.cpp
- show_data() : shell_sort2.cpp
- show_pascal() : pascal_triangle.cpp
-- sieve() : sieve_of_eratosthenes.cpp
- Sieve() : primes_up_to_billion.cpp
+- sieve() : sieve_of_eratosthenes.cpp
- SieveOfEratosthenes() : prime_factorization.cpp
+- sortcol() : fcfs_scheduling.cpp
- spiralPrint() : spiral_print.cpp
- Sqrt() : sqrt_double.cpp
- stack : paranthesis_matching.cpp
diff --git a/globals_t.html b/globals_t.html
index e9776bdb2..4be523508 100644
--- a/globals_t.html
+++ b/globals_t.html
@@ -94,7 +94,7 @@ $(document).ready(function(){initNavTree('globals_t.html',''); initResizable();
- t -
- ternary_search() : ternary_search.cpp
-- test() : rat_maze.cpp, subarray_sum.cpp, subset_sum.cpp, wildcard_matching.cpp, count_of_set_bits.cpp, count_of_trailing_ciphers_in_factorial_n.cpp, hamming_distance.cpp, caesar_cipher.cpp, elliptic_curve_key_exchange.cpp, morse_code.cpp, vigenere_cipher.cpp, xor_cipher.cpp, list_array.cpp, reverse_a_linked_list.cpp, sparse_table.cpp, trie_tree.cpp, trie_using_hashmap.cpp, karatsuba_algorithm_for_fast_multiplication.cpp, 0_1_knapsack.cpp, abbreviation.cpp, coin_change_topdown.cpp, cut_rod.cpp, house_robber.cpp, longest_increasing_subsequence.cpp, longest_palindromic_subsequence.cpp, minimum_edit_distance.cpp, palindrome_partitioning.cpp, shortest_common_supersequence.cpp, word_break.cpp, jarvis_algorithm.cpp, connected_components_with_dsu.cpp, is_graph_bipartite.cpp, jumpgame.cpp, md5.cpp, sha1.cpp, gram_schmidt.cpp, neural_network.cpp, armstrong_number.cpp, check_amicable_pair.cpp, double_factorial.cpp, fibonacci.cpp, fibonacci_matrix_exponentiation.cpp, fibonacci_sum.cpp, finding_number_of_digits_in_a_number.cpp, inv_sqrt.cpp, largest_power.cpp, lcm_sum.cpp, modular_division.cpp, modular_exponentiation.cpp, n_bonacci.cpp, n_choose_r.cpp, sum_of_binomial_coefficient.cpp, sum_of_digits.cpp, vector_cross_product.cpp, rungekutta.cpp, inorder_successor_of_bst.cpp, trie_multiple_search.cpp, kadanes3.cpp, smallest_circle.cpp, geometric_dist.cpp, windowed_median.cpp, persistent_seg_tree_lazy_prop.cpp, prefix_sum_array.cpp, floyd_cycle_detection_algo.cpp, median_search.cpp, saddleback_search.cpp, sublist_search.cpp, text_search.cpp, bogo_sort.cpp, count_inversions.cpp, cycle_sort.cpp, dnf_sort.cpp, gnome_sort.cpp, heap_sort.cpp, merge_insertion_sort.cpp, pancake_sort.cpp, random_pivot_quick_sort.cpp, recursive_bubble_sort.cpp, selection_sort_recursive.cpp, strand_sort.cpp, wave_sort.cpp, wiggle_sort.cpp, horspool.cpp, manacher_algorithm.cpp, z_function.cpp
+- test() : rat_maze.cpp, subarray_sum.cpp, subset_sum.cpp, wildcard_matching.cpp, count_of_set_bits.cpp, count_of_trailing_ciphers_in_factorial_n.cpp, hamming_distance.cpp, caesar_cipher.cpp, elliptic_curve_key_exchange.cpp, morse_code.cpp, vigenere_cipher.cpp, xor_cipher.cpp, fcfs_scheduling.cpp, list_array.cpp, reverse_a_linked_list.cpp, sparse_table.cpp, trie_tree.cpp, trie_using_hashmap.cpp, karatsuba_algorithm_for_fast_multiplication.cpp, 0_1_knapsack.cpp, abbreviation.cpp, coin_change_topdown.cpp, cut_rod.cpp, house_robber.cpp, longest_increasing_subsequence.cpp, longest_palindromic_subsequence.cpp, minimum_edit_distance.cpp, palindrome_partitioning.cpp, shortest_common_supersequence.cpp, word_break.cpp, jarvis_algorithm.cpp, connected_components_with_dsu.cpp, is_graph_bipartite.cpp, jumpgame.cpp, md5.cpp, sha1.cpp, gram_schmidt.cpp, neural_network.cpp, armstrong_number.cpp, check_amicable_pair.cpp, double_factorial.cpp, fibonacci.cpp, fibonacci_matrix_exponentiation.cpp, fibonacci_sum.cpp, finding_number_of_digits_in_a_number.cpp, inv_sqrt.cpp, largest_power.cpp, lcm_sum.cpp, modular_division.cpp, modular_exponentiation.cpp, n_bonacci.cpp, n_choose_r.cpp, sum_of_binomial_coefficient.cpp, sum_of_digits.cpp, vector_cross_product.cpp, rungekutta.cpp, inorder_successor_of_bst.cpp, trie_multiple_search.cpp, kadanes3.cpp, smallest_circle.cpp, geometric_dist.cpp, windowed_median.cpp, persistent_seg_tree_lazy_prop.cpp, prefix_sum_array.cpp, floyd_cycle_detection_algo.cpp, median_search.cpp, saddleback_search.cpp, sublist_search.cpp, text_search.cpp, bogo_sort.cpp, count_inversions.cpp, cycle_sort.cpp, dnf_sort.cpp, gnome_sort.cpp, heap_sort.cpp, merge_insertion_sort.cpp, pancake_sort.cpp, random_pivot_quick_sort.cpp, recursive_bubble_sort.cpp, selection_sort_recursive.cpp, strand_sort.cpp, wave_sort.cpp, wiggle_sort.cpp, horspool.cpp, manacher_algorithm.cpp, z_function.cpp
- test1() : hill_cipher.cpp, tree_234.cpp, hamiltons_cycle.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, large_factorial.cpp, sum_of_digits.cpp, brent_method_extrema.cpp, durand_kerner_roots.cpp, golden_search_extrema.cpp, lu_decompose.cpp, qr_eigen_values.cpp, iterative_tree_traversals.cpp
- test2() : hill_cipher.cpp, tree_234.cpp, hamiltons_cycle.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, large_factorial.cpp, sum_of_digits.cpp, brent_method_extrema.cpp, durand_kerner_roots.cpp, golden_search_extrema.cpp, lu_decompose.cpp, qr_eigen_values.cpp, iterative_tree_traversals.cpp, smallest_circle.cpp
- test3() : hamiltons_cycle.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, brent_method_extrema.cpp, golden_search_extrema.cpp, iterative_tree_traversals.cpp, smallest_circle.cpp
diff --git a/hierarchy.html b/hierarchy.html
index 6cdc2a251..15fb8a93a 100644
--- a/hierarchy.html
+++ b/hierarchy.html
@@ -104,92 +104,94 @@ This inheritance list is sorted roughly, but not completely, alphabetically: Cbinary_search_tree< T >::bst_node A struct to represent a node in the Binary Search Tree
CBtree Ccll Ccompare Cmachine_learning::aystar_search::AyStarSearch< Puzzle >::comparison_operator Custom comparator for open_list CComplex Class Complex to represent complex numbers as a field Cgeometry::jarvis::Convexhull CCycleCheck Cmachine_learning::neural_network::layers::DenseLayer Cdouble_linked_list CEdge Cmachine_learning::aystar_search::EightPuzzle< N > A class defining EightPuzzle/15-Puzzle game Cdouble_hashing::Entry Clinear_probing::Entry Cquadratic_probing::Entry CFenwickTree Cprobability::geometric_dist::geometric_distribution A class to model the geometric distribution CGraph ▼Cgraph::Graph< T > Cgraph::RootedTree Cgraph::is_graph_bipartite::Graph Class for representing graph as an adjacency list Chash_chain Chain class with a given modulus Cciphers::HillCipher Implementation of Hill Cipher algorithm Cgraph::HKGraph Represents Bipartite graph for Hopcroft Karp implementation Cmachine_learning::aystar_search::AyStarSearch< Puzzle >::Info Struct that handles all the information related to the current state CItem Clarge_number Cdata_structures::linked_list::link Clinkedlist Cdata_structures::linked_list::list Cdata_structures::list_array::list Structure of List with supporting methods Clist Cgraph::LowestCommonAncestor Cothers::lru_cache::LRUCache LRU cache class CMinHeap CMinHeapNode Cmst Cmath::ncr_modulo_p::NCRModuloP Class which contains all methods required for calculating nCr mod p Cmachine_learning::neural_network::NeuralNetwork Cdata_structures::linked_list::Node Cdata_structures::Node Cdata_structures::tree_234::Node 2-3-4 tree node class Cdata_structures::trie_using_hashmap::Trie::Node Struct representing a trie node CNode Cnode< Kind > Coperations_on_datastructures::inorder_traversal_of_bst::Node A Node structure representing a single node in BST Cothers::iterative_tree_traversals::Node Defines the structure of a node of the tree Crange_queries::perSegTree::Node Csearch::sublist_search::Node A Node structure representing a single link Node in a linked list Crange_queries::perSegTree Range query here is range sum, but the code can be modified to make different queries like range max or min Cciphers::elliptic_curve_key_exchange::Point Definition of struct Point Cgeometry::jarvis::Point CPoint Cquery Cqueue< Kind > CQueue Cdata_structures::queue_using_array::Queue_Array Queue_Array class containing the main data and also index of head and tail of the array CRBtree CSegmentIntersection ▼Crange_queries::heavy_light_decomposition::SG< X > Segment Tree, to store heavy chains Crange_queries::heavy_light_decomposition::HLD< X > The Heavy-Light Decomposition class Cdata_structures::SkipList CSolution Cdata_structures::sparse_table::Sparse_table Cothers::postfix_expression::Stack Creates an array to be used as stack for storing values Cstack< Type > Cstack_linkedList Cstatistics::stats_computer1< T > Cstatistics::stats_computer2< T > CTestCases Class encapsulating the necessary test cases Coperations_on_datastructures::trie_operations::Tnode Class defining the structure of trie node and containing the methods to perform operations on them Ctower ▼Crange_queries::heavy_light_decomposition::Tree< X > A Basic Tree, which supports binary lifting Crange_queries::heavy_light_decomposition::HLD< X > The Heavy-Light Decomposition class Cdata_structures::tree_234::Tree234 2-3-4 tree class Cdata_structures::trie Trie implementation for small-case English alphabets a-z Cdata_structures::trie_using_hashmap::Trie Trie class, implementation of trie using hashmap in each trie node for all the characters of char16_t(UTF-16)type with methods to insert, delete, search, start with and to recommend words based on a given prefix CTrie CTrie::TrieNode ▼Cstd::true_type [external] Cstd::is_arithmetic< uint128_t > Cstd::is_arithmetic< uint256_t > Cstd::is_integral< uint128_t > Cstd::is_integral< uint256_t > Cstd::is_unsigned< uint128_t > Cstd::is_unsigned< uint256_t > Cuint128_t Class for 128-bit unsigned integer Cuint256_t Class for 256-bit unsigned integer Cprobability::windowed_median::WindowedMedian A class to calculate the median of a leading sliding window at the back of a stream of integer values CCompare< S, T, E > Comparator class for priority queue Ccompare Cmachine_learning::aystar_search::AyStarSearch< Puzzle >::comparison_operator Custom comparator for open_list CComplex Class Complex to represent complex numbers as a field Cgeometry::jarvis::Convexhull CCycleCheck Cmachine_learning::neural_network::layers::DenseLayer Cdouble_linked_list CEdge Cmachine_learning::aystar_search::EightPuzzle< N > A class defining EightPuzzle/15-Puzzle game Cdouble_hashing::Entry Clinear_probing::Entry Cquadratic_probing::Entry CFCFS< S, T, E > Class which implements the FCFS scheduling algorithm CFenwickTree Cprobability::geometric_dist::geometric_distribution A class to model the geometric distribution CGraph ▼Cgraph::Graph< T > Cgraph::RootedTree Cgraph::is_graph_bipartite::Graph Class for representing graph as an adjacency list Chash_chain Chain class with a given modulus Cciphers::HillCipher Implementation of Hill Cipher algorithm Cgraph::HKGraph Represents Bipartite graph for Hopcroft Karp implementation Cmachine_learning::aystar_search::AyStarSearch< Puzzle >::Info Struct that handles all the information related to the current state CItem Clarge_number Cdata_structures::linked_list::link Clinkedlist Cdata_structures::linked_list::list Cdata_structures::list_array::list Structure of List with supporting methods Clist Cgraph::LowestCommonAncestor Cothers::lru_cache::LRUCache LRU cache class CMinHeap CMinHeapNode Cmst Cmath::ncr_modulo_p::NCRModuloP Class which contains all methods required for calculating nCr mod p Cmachine_learning::neural_network::NeuralNetwork Cdata_structures::linked_list::Node Cdata_structures::Node Cdata_structures::tree_234::Node 2-3-4 tree node class Cdata_structures::trie_using_hashmap::Trie::Node Struct representing a trie node CNode Cnode< Kind > Coperations_on_datastructures::inorder_traversal_of_bst::Node A Node structure representing a single node in BST Cothers::iterative_tree_traversals::Node Defines the structure of a node of the tree Crange_queries::perSegTree::Node Csearch::sublist_search::Node A Node structure representing a single link Node in a linked list Crange_queries::perSegTree Range query here is range sum, but the code can be modified to make different queries like range max or min Cciphers::elliptic_curve_key_exchange::Point Definition of struct Point Cgeometry::jarvis::Point CPoint Cquery Cqueue< Kind > CQueue Cdata_structures::queue_using_array::Queue_Array Queue_Array class containing the main data and also index of head and tail of the array CRBtree CSegmentIntersection ▼Crange_queries::heavy_light_decomposition::SG< X > Segment Tree, to store heavy chains Crange_queries::heavy_light_decomposition::HLD< X > The Heavy-Light Decomposition class Cdata_structures::SkipList CSolution Cdata_structures::sparse_table::Sparse_table Cothers::postfix_expression::Stack Creates an array to be used as stack for storing values Cstack< Type > Cstack_linkedList Cstatistics::stats_computer1< T > Cstatistics::stats_computer2< T > CTestCases Class encapsulating the necessary test cases Coperations_on_datastructures::trie_operations::Tnode Class defining the structure of trie node and containing the methods to perform operations on them Ctower ▼Crange_queries::heavy_light_decomposition::Tree< X > A Basic Tree, which supports binary lifting Crange_queries::heavy_light_decomposition::HLD< X > The Heavy-Light Decomposition class Cdata_structures::tree_234::Tree234 2-3-4 tree class Cdata_structures::trie Trie implementation for small-case English alphabets a-z Cdata_structures::trie_using_hashmap::Trie Trie class, implementation of trie using hashmap in each trie node for all the characters of char16_t(UTF-16)type with methods to insert, delete, search, start with and to recommend words based on a given prefix CTrie CTrie::TrieNode ▼Cstd::true_type [external] Cstd::is_arithmetic< uint128_t > Cstd::is_arithmetic< uint256_t > Cstd::is_integral< uint128_t > Cstd::is_integral< uint256_t > Cstd::is_unsigned< uint128_t > Cstd::is_unsigned< uint256_t > Cuint128_t Class for 128-bit unsigned integer Cuint256_t Class for 256-bit unsigned integer Cprobability::windowed_median::WindowedMedian A class to calculate the median of a leading sliding window at the back of a stream of integer values
diff --git a/hierarchy.js b/hierarchy.js
index cc5d4c317..d62633ce2 100644
--- a/hierarchy.js
+++ b/hierarchy.js
@@ -7,6 +7,7 @@ var hierarchy =
[ "binary_search_tree< T >::bst_node", "dd/db6/structbinary__search__tree_1_1bst__node.html", null ],
[ "Btree", "d9/d90/struct_btree.html", null ],
[ "cll", "d5/d15/classcll.html", null ],
+ [ "Compare< S, T, E >", "de/d4a/class_compare.html", null ],
[ "compare", "d1/db3/structcompare.html", null ],
[ "machine_learning::aystar_search::AyStarSearch< Puzzle >::comparison_operator", "d3/d2a/structmachine__learning_1_1aystar__search_1_1_ay_star_search_1_1comparison__operator.html", null ],
[ "Complex", "da/d5a/class_complex.html", null ],
@@ -19,6 +20,7 @@ var hierarchy =
[ "double_hashing::Entry", "d9/dde/structdouble__hashing_1_1_entry.html", null ],
[ "linear_probing::Entry", "db/d19/structlinear__probing_1_1_entry.html", null ],
[ "quadratic_probing::Entry", "da/dd1/structquadratic__probing_1_1_entry.html", null ],
+ [ "FCFS< S, T, E >", "dd/dca/class_f_c_f_s.html", null ],
[ "FenwickTree", "dd/d91/class_fenwick_tree.html", null ],
[ "probability::geometric_dist::geometric_distribution", "da/d19/classprobability_1_1geometric__dist_1_1geometric__distribution.html", null ],
[ "Graph", "da/d9a/class_graph.html", null ],
diff --git a/index.html b/index.html
index 9b5825758..538225e93 100644
--- a/index.html
+++ b/index.html
@@ -95,10 +95,10 @@ $(document).ready(function(){initNavTree('index.html',''); initResizable(); });
-
+
Overview
This repository is a collection of open-source implementation of a variety of algorithms implemented in C++ and licensed under MIT License. These algorithms span a variety of topics from computer science, mathematics and statistics, data science, machine learning, engineering, etc.. The implementations and the associated documentation are meant to provide a learning resource for educators and students. Hence, one may find more than one implementation for the same objective but using a different algorithm strategies and optimizations.
-
+
Features
- The repository provides implementations of various algorithms in one of the most fundamental general purpose languages - C++.
@@ -109,12 +109,12 @@ Features
- Self-checks within programs ensure correct implementations with confidence.
- Modular implementations and OpenSource licensing enable the functions to be utilized conveniently in other applications.
-
+
Documentation
Online Documentation is generated from the repository source codes directly. The documentation contains all resources including source code snippets, details on execution of the programs, diagrammatic representation of program flow, and links to external resources where necessary. The documentation also introduces interactive source code with links to documentation for C++ STL library functions used. Click on Files menu to see the list of all the files documented with the code.
Documentation of Algorithms in C++ by The Algorithms Contributors is licensed under CC BY-SA 4.0
-
+
Contributions
As a community developed and maintained repository, we welcome new un-plagiarized quality contributions. Please read our Contribution Guidelines.
diff --git a/inherit_graph_10.map b/inherit_graph_10.map
index 32a286108..e3ea338d1 100644
--- a/inherit_graph_10.map
+++ b/inherit_graph_10.map
@@ -1,3 +1,3 @@
diff --git a/inherit_graph_10.md5 b/inherit_graph_10.md5
index 679531e7b..7bca58621 100644
--- a/inherit_graph_10.md5
+++ b/inherit_graph_10.md5
@@ -1 +1 @@
-5eb287a2fb56ae0e7e71100d4f42a21c
\ No newline at end of file
+5320309e3bffbba4f4360758b1ad97f4
\ No newline at end of file
diff --git a/inherit_graph_10.svg b/inherit_graph_10.svg
index 66bb71fe6..4ad91dbea 100644
--- a/inherit_graph_10.svg
+++ b/inherit_graph_10.svg
@@ -12,10 +12,10 @@
Node0
-
+
data_structures::linked
-_list::list
+_list::link
diff --git a/inherit_graph_11.map b/inherit_graph_11.map
index 7d4ec9a8d..32a286108 100644
--- a/inherit_graph_11.map
+++ b/inherit_graph_11.map
@@ -1,3 +1,3 @@
diff --git a/inherit_graph_11.md5 b/inherit_graph_11.md5
index c563a0c98..679531e7b 100644
--- a/inherit_graph_11.md5
+++ b/inherit_graph_11.md5
@@ -1 +1 @@
-d57400eb9de671d3442759337d4a98a7
\ No newline at end of file
+5eb287a2fb56ae0e7e71100d4f42a21c
\ No newline at end of file
diff --git a/inherit_graph_11.svg b/inherit_graph_11.svg
index 5e4880e22..66bb71fe6 100644
--- a/inherit_graph_11.svg
+++ b/inherit_graph_11.svg
@@ -12,10 +12,10 @@
Node0
-
+
data_structures::linked
-_list::Node
+_list::list
diff --git a/inherit_graph_12.map b/inherit_graph_12.map
index 087a17e54..7d4ec9a8d 100644
--- a/inherit_graph_12.map
+++ b/inherit_graph_12.map
@@ -1,3 +1,3 @@
diff --git a/inherit_graph_12.md5 b/inherit_graph_12.md5
index fed441c74..c563a0c98 100644
--- a/inherit_graph_12.md5
+++ b/inherit_graph_12.md5
@@ -1 +1 @@
-8b10ed21001ae43ebb02b0fc74f2c517
\ No newline at end of file
+d57400eb9de671d3442759337d4a98a7
\ No newline at end of file
diff --git a/inherit_graph_12.svg b/inherit_graph_12.svg
index 62e00425f..5e4880e22 100644
--- a/inherit_graph_12.svg
+++ b/inherit_graph_12.svg
@@ -4,18 +4,18 @@
-
However MD5 has be know to be cryptographically weak for quite some time, yet it is still widely used. This weakness was exploited by the Flame Malware in 2012
-
+
Algorithm
First of all, all values are expected to be in little endian. This is especially important when using part of the bytestring as an integer.
The first step of the algorithm is to pad the message for its length to be a multiple of 64 (bytes). This is done by first adding 0x80 (10000000) and then only zeroes until the last 8 bytes must be filled, where then the 64 bit size of the input will be added
diff --git a/d5/ddb/bogo__sort_8cpp.html b/d5/ddb/bogo__sort_8cpp.html index 5fca0b893..30e0a0c78 100644 --- a/d5/ddb/bogo__sort_8cpp.html +++ b/d5/ddb/bogo__sort_8cpp.html @@ -135,7 +135,7 @@ FunctionsDetailed Description
Implementation of Bogosort algorithm
In computer science, bogosort (also known as permutation sort, stupid sort, slowsort, shotgun sort, random sort, monkey sort, bobosort or shuffle sort) is a highly inefficient sorting algorithm based on the generate and test paradigm. Two versions of this algorithm exist: a deterministic version that enumerates all permutations until it hits a sorted one, and a randomized version that randomly permutes its input.Randomized version is implemented here.
-
+
Algorithm
Shuffle the array untill array is sorted.
diff --git a/d6/d10/cut__rod_8cpp.html b/d6/d10/cut__rod_8cpp.html index 5da32cc73..e6dad50c4 100644 --- a/d6/d10/cut__rod_8cpp.html +++ b/d6/d10/cut__rod_8cpp.html @@ -135,7 +135,7 @@ FunctionsDetailed Description
Implementation of cutting a rod problem.
Given a rod of length n inches and an array of prices that contains prices of all pieces of size<=n. Determine the maximum profit obtainable by cutting up the rod and selling the pieces.
-
+
Algorithm
The idea is to break the given rod into every smaller piece as possible and then check profit for each piece, by calculating maximum profit for smaller pieces we will build the solution for larger pieces in bottom-up manner.
a's lowercase letters.a.
+
Algorithm
The idea is in the problem statement itself: iterate through characters of string a and b (for character indexes i and j respectively):
- If
a[i]andb[j]are equal, then move to next position
diff --git a/d8/d7a/sha1_8cpp.html b/d8/d7a/sha1_8cpp.html
index 011c7725c..4a75469bc 100644
--- a/d8/d7a/sha1_8cpp.html
+++ b/d8/d7a/sha1_8cpp.html
@@ -150,7 +150,7 @@ Functions
- Note
- This is a simple implementation for a byte string but some implmenetations can work on bytestream, messages of unknown length.
- Depth first search diff --git a/d8/dc8/class_compare-members.html b/d8/dc8/class_compare-members.html new file mode 100644 index 000000000..84ead1ecc --- /dev/null +++ b/d8/dc8/class_compare-members.html @@ -0,0 +1,109 @@ + + + + + + + +
- Generated by 1.9.2
+
- If the last characters of two strings are the same, Ignore the characters and get the count for the remaining string. So, we get the solution for lengths m-1 and n-1 in a DP array. diff --git a/db/d16/0__1__knapsack_8cpp.html b/db/d16/0__1__knapsack_8cpp.html index 433c48500..cfcf6167c 100644 --- a/db/d16/0__1__knapsack_8cpp.html +++ b/db/d16/0__1__knapsack_8cpp.html @@ -135,7 +135,7 @@ Functions
- Author
- Anmol diff --git a/db/dca/kadane2_8cpp.html b/db/dca/kadane2_8cpp.html index 35dd96829..1dbb15c18 100644 --- a/db/dca/kadane2_8cpp.html +++ b/db/dca/kadane2_8cpp.html @@ -131,7 +131,7 @@ Functions
- See also
- here for simple number exponentiation algorithm or explaination here.
- Template Parameters
-
+
+
+S Data type of Process ID T Data type of Arrival time E Data type of Burst time
+ - Parameters
-
+
+
+id Process ID arrival Arrival time of the process burst Burst time of the process
+ - Returns
- void
- Returns
- void
- Returns
- void
- cpu_scheduling_algorithms/fcfs_scheduling.cpp +
- Generated by 1.9.2
+
- Template Parameters
-
+
+
+S Data type of Process ID T Data type of Arrival time E Data type of Burst time
+ - Parameters
-
+
+
+t1 First tuple t2 Second tuple
+ - Returns
- true if the tuples SHOULD be swapped +
- +false if the tuples SHOULDN'T be swapped
- cpu_scheduling_algorithms/fcfs_scheduling.cpp +
- Generated by 1.9.2
+
- Generated by 1.9.2
+
- Parameters
-
+
+
+input the input data
+ - Returns
- A vector of tuples consisting of process ID, arrival time, burst time, completion time, turnaround time and waiting time for each process.
- Template Parameters
-
+
+
+S Data type of Process ID T Data type of Arrival time E Data type of Burst time
+ - Parameters
-
+
+
+t1 First tuple t2 Second tuple
+ - Returns
- true if t1 and t2 are in the CORRECT order +
- +false if t1 and t2 are in the INCORRECT order
- Returns
- void
- Generated by 1.9.2
+
- Generated by 1.9.2
+
- add_digit() : large_number
- add_edge() : graph::Graph< T >, range_queries::heavy_light_decomposition::Tree< X >
- addEdge() : Graph, graph::HKGraph, graph::is_graph_bipartite::Graph +
- addProcess() : FCFS< S, T, E >
- addVertices() : Graph
- adj : graph::HKGraph, graph::is_graph_bipartite::Graph
- adjacency_list : graph::Graph< T > diff --git a/functions_func_a.html b/functions_func_a.html index 895b8d7b2..ce7a6fe56 100644 --- a/functions_func_a.html +++ b/functions_func_a.html @@ -101,6 +101,7 @@ $(document).ready(function(){initNavTree('functions_func_a.html',''); initResiza
- add_digit() : large_number
- add_edge() : graph::Graph< T >, range_queries::heavy_light_decomposition::Tree< X >
- addEdge() : Graph, graph::HKGraph, graph::is_graph_bipartite::Graph +
- addProcess() : FCFS< S, T, E >
- addVertices() : Graph
- arg() : Complex
- AyStarSearch() : machine_learning::aystar_search::AyStarSearch< Puzzle > diff --git a/functions_func_i.html b/functions_func_i.html index f6c10499c..b46256971 100644 --- a/functions_func_i.html +++ b/functions_func_i.html @@ -99,7 +99,7 @@ $(document).ready(function(){initNavTree('functions_func_i.html',''); initResiza
- init() : range_queries::heavy_light_decomposition::HLD< X >, range_queries::heavy_light_decomposition::Tree< X >
- inOrderIterative() : others::iterative_tree_traversals::BinaryTree
- insert() : binary_search_tree< T >, data_structures::linked_list::list, data_structures::list_array::list -
- Insert() : data_structures::tree_234::Tree234 +
- Insert() : data_structures::tree_234::Tree234
- insert() : data_structures::trie, data_structures::trie_using_hashmap::Trie
- Insert() : operations_on_datastructures::trie_operations::Tnode
- insert() : probability::windowed_median::WindowedMedian, Trie diff --git a/functions_func_o.html b/functions_func_o.html index 2d36ddc58..524631ee8 100644 --- a/functions_func_o.html +++ b/functions_func_o.html @@ -105,7 +105,7 @@ $(document).ready(function(){initNavTree('functions_func_o.html',''); initResiza
- operator&() : uint128_t, uint256_t
- operator&&() : uint128_t, uint256_t
- operator&=() : uint128_t, uint256_t -
- operator()() : uint128_t, uint256_t +
- operator()() : Compare< S, T, E >, uint128_t, uint256_t
- operator*() : Complex, uint128_t, uint256_t
- operator*=() : large_number, uint128_t, uint256_t
- operator+() : Complex, uint128_t, uint256_t diff --git a/functions_func_p.html b/functions_func_p.html index 03847d40c..23611cdc6 100644 --- a/functions_func_p.html +++ b/functions_func_p.html @@ -103,6 +103,7 @@ $(document).ready(function(){initNavTree('functions_func_p.html',''); initResiza
- preOrderIterative() : others::iterative_tree_traversals::BinaryTree
- Print() : data_structures::tree_234::Tree234
- PrintNode() : data_structures::tree_234::Tree234 +
- printResult() : FCFS< S, T, E >
- probability_density() : probability::geometric_dist::geometric_distribution
- push() : stack< Type >
- push_back() : data_structures::linked_list::list diff --git a/functions_func_s.html b/functions_func_s.html index 093c5d0f6..45a5ca001 100644 --- a/functions_func_s.html +++ b/functions_func_s.html @@ -94,6 +94,7 @@ $(document).ready(function(){initNavTree('functions_func_s.html',''); initResiza
- save_model() : machine_learning::neural_network::NeuralNetwork +
- scheduleForFcfs() : FCFS< S, T, E >
- search() : data_structures::linked_list::list, data_structures::trie, data_structures::trie_using_hashmap::Trie, Trie
- searchElement() : data_structures::SkipList
- SearchFreqSuggestions() : operations_on_datastructures::trie_operations::Tnode diff --git a/functions_i.html b/functions_i.html index 9c44e9eba..7f28ec0c7 100644 --- a/functions_i.html +++ b/functions_i.html @@ -99,7 +99,7 @@ $(document).ready(function(){initNavTree('functions_i.html',''); initResizable()
- init() : range_queries::heavy_light_decomposition::HLD< X >, range_queries::heavy_light_decomposition::Tree< X >
- inOrderIterative() : others::iterative_tree_traversals::BinaryTree
- insert() : binary_search_tree< T >, data_structures::linked_list::list, data_structures::list_array::list -
- Insert() : data_structures::tree_234::Tree234 +
- Insert() : data_structures::tree_234::Tree234
- insert() : data_structures::trie, data_structures::trie_using_hashmap::Trie
- Insert() : operations_on_datastructures::trie_operations::Tnode
- insert() : probability::windowed_median::WindowedMedian, Trie diff --git a/functions_o.html b/functions_o.html index 6ac295c79..837e3e696 100644 --- a/functions_o.html +++ b/functions_o.html @@ -105,7 +105,7 @@ $(document).ready(function(){initNavTree('functions_o.html',''); initResizable()
- operator&() : uint128_t, uint256_t
- operator&&() : uint128_t, uint256_t
- operator&=() : uint128_t, uint256_t -
- operator()() : uint128_t, uint256_t +
- operator()() : Compare< S, T, E >, uint128_t, uint256_t
- operator*() : Complex, uint128_t, uint256_t
- operator*=() : large_number, uint128_t, uint256_t
- operator+() : Complex, large_number, uint128_t, uint256_t diff --git a/functions_p.html b/functions_p.html index 90430b6ff..183e64c23 100644 --- a/functions_p.html +++ b/functions_p.html @@ -110,6 +110,7 @@ $(document).ready(function(){initNavTree('functions_p.html',''); initResizable()
- preOrderIterative() : others::iterative_tree_traversals::BinaryTree
- Print() : data_structures::tree_234::Tree234
- PrintNode() : data_structures::tree_234::Tree234 +
- printResult() : FCFS< S, T, E >
- probability_density() : probability::geometric_dist::geometric_distribution
- psucc : data_structures::linked_list::link
- ptrs : range_queries::perSegTree diff --git a/functions_s.html b/functions_s.html index d4dd818d0..32e7c85b4 100644 --- a/functions_s.html +++ b/functions_s.html @@ -96,6 +96,8 @@ $(document).ready(function(){initNavTree('functions_s.html',''); initResizable()
- s_size : range_queries::heavy_light_decomposition::SG< X >
- s_tree : range_queries::heavy_light_decomposition::SG< X >
- save_model() : machine_learning::neural_network::NeuralNetwork +
- schedule : FCFS< S, T, E > +
- scheduleForFcfs() : FCFS< S, T, E >
- search() : data_structures::linked_list::list, data_structures::trie, data_structures::trie_using_hashmap::Trie, Trie
- searchElement() : data_structures::SkipList
- SearchFreqSuggestions() : operations_on_datastructures::trie_operations::Tnode diff --git a/functions_vars.html b/functions_vars.html index 9752b512f..a47e938f3 100644 --- a/functions_vars.html +++ b/functions_vars.html @@ -217,6 +217,7 @@ $(document).ready(function(){initNavTree('functions_vars.html',''); initResizabl
- s_size : range_queries::heavy_light_decomposition::SG< X >
- s_tree : range_queries::heavy_light_decomposition::SG< X > +
- schedule : FCFS< S, T, E >
- side : graph::is_graph_bipartite::Graph
- size : stack< Type >
- size_ : binary_search_tree< T > diff --git a/globals_func_g.html b/globals_func_g.html index b8a49306e..dd9a8ec0e 100644 --- a/globals_func_g.html +++ b/globals_func_g.html @@ -96,6 +96,7 @@ $(document).ready(function(){initNavTree('globals_func_g.html',''); initResizabl
- gcd() : gcd_iterative_euclidean.cpp, gcd_of_n_numbers.cpp, gcd_recursive_euclidean.cpp, least_common_multiple.cpp
- genArray() : spiral_print.cpp
- get_clock_diff() : kohonen_som_topology.cpp, kohonen_som_trace.cpp +
- get_final_status() : fcfs_scheduling.cpp
- get_input() : ternary_search.cpp
- get_inverse() : ordinary_least_squares_regressor.cpp
- get_min_2d() : kohonen_som_topology.cpp diff --git a/globals_func_i.html b/globals_func_i.html index 7ce39a9c8..eaac1ff58 100644 --- a/globals_func_i.html +++ b/globals_func_i.html @@ -104,8 +104,8 @@ $(document).ready(function(){initNavTree('globals_func_i.html',''); initResizabl
- is_happy() : happy_number.cpp
- is_prime() : check_prime.cpp
- is_square() : ordinary_least_squares_regressor.cpp -
- isPrime() : modular_inverse_fermat_little_theorem.cpp
- IsPrime() : primality_test.cpp +
- isPrime() : modular_inverse_fermat_little_theorem.cpp
- it_ternary_search() : ternary_search.cpp
- main() : graph_coloring.cpp, knight_tour.cpp, minimax.cpp, n_queens.cpp, n_queens_all_solution_optimised.cpp, nqueen_print_all_solutions.cpp, rat_maze.cpp, subarray_sum.cpp, subset_sum.cpp, sudoku_solve.cpp, wildcard_matching.cpp, count_of_set_bits.cpp, count_of_trailing_ciphers_in_factorial_n.cpp, hamming_distance.cpp, caesar_cipher.cpp, elliptic_curve_key_exchange.cpp, hill_cipher.cpp, morse_code.cpp, vigenere_cipher.cpp, xor_cipher.cpp, avltree.cpp, disjoint_set.cpp, linked_list.cpp, linkedlist_implentation_usingarray.cpp, list_array.cpp, queue_using_array.cpp, queue_using_two_stacks.cpp, reverse_a_linked_list.cpp, skip_list.cpp, sparse_table.cpp, tree_234.cpp, trie_modern.cpp, trie_tree.cpp, trie_using_hashmap.cpp, karatsuba_algorithm_for_fast_multiplication.cpp, 0_1_knapsack.cpp, abbreviation.cpp, coin_change_topdown.cpp, cut_rod.cpp, house_robber.cpp, kadane2.cpp, longest_increasing_subsequence.cpp, longest_palindromic_subsequence.cpp, minimum_edit_distance.cpp, palindrome_partitioning.cpp, shortest_common_supersequence.cpp, word_break.cpp, jarvis_algorithm.cpp, line_segment_intersection.cpp, bidirectional_dijkstra.cpp, breadth_first_search.cpp, connected_components.cpp, connected_components_with_dsu.cpp, depth_first_search.cpp, depth_first_search_with_stack.cpp, dijkstra.cpp, hamiltons_cycle.cpp, hopcroft_karp.cpp, is_graph_bipartite.cpp, lowest_common_ancestor.cpp, travelling_salesman_problem.cpp, spirograph.cpp, jumpgame.cpp, chaining.cpp, double_hash_hash_table.cpp, linear_probing_hash_table.cpp, md5.cpp, quadratic_probing_hash_table.cpp, sha1.cpp, gram_schmidt.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, neural_network.cpp, ordinary_least_squares_regressor.cpp, armstrong_number.cpp, binary_exponent.cpp, binomial_calculate.cpp, check_amicable_pair.cpp, check_factorial.cpp, check_prime.cpp, complex_numbers.cpp, double_factorial.cpp, eulers_totient_function.cpp, extended_euclid_algorithm.cpp, factorial.cpp, fast_power.cpp, fibonacci.cpp, fibonacci_fast.cpp, fibonacci_matrix_exponentiation.cpp, fibonacci_sum.cpp, finding_number_of_digits_in_a_number.cpp, gcd_iterative_euclidean.cpp, gcd_of_n_numbers.cpp, gcd_recursive_euclidean.cpp, integral_approximation.cpp, inv_sqrt.cpp, large_factorial.cpp, largest_power.cpp, lcm_sum.cpp, least_common_multiple.cpp, magic_number.cpp, miller_rabin.cpp, modular_division.cpp, modular_exponentiation.cpp, modular_inverse_fermat_little_theorem.cpp, n_bonacci.cpp, n_choose_r.cpp, ncr_modulo_p.cpp, number_of_positive_divisors.cpp, power_for_huge_numbers.cpp, power_of_two.cpp, prime_factorization.cpp, prime_numbers.cpp, primes_up_to_billion.cpp, realtime_stats.cpp, sieve_of_eratosthenes.cpp, sqrt_double.cpp, string_fibonacci.cpp, sum_of_binomial_coefficient.cpp, sum_of_digits.cpp, vector_cross_product.cpp, bisection_method.cpp, brent_method_extrema.cpp, false_position.cpp, gaussian_elimination.cpp, golden_search_extrema.cpp, lu_decompose.cpp, newton_raphson_method.cpp, ode_forward_euler.cpp, ode_midpoint_euler.cpp, ode_semi_implicit_euler.cpp, qr_decomposition.cpp, qr_eigen_values.cpp, rungekutta.cpp, successive_approximation.cpp, inorder_successor_of_bst.cpp, trie_multiple_search.cpp, buzz_number.cpp, decimal_to_hexadecimal.cpp, decimal_to_roman_numeral.cpp, fast_integer_input.cpp, happy_number.cpp, iterative_tree_traversals.cpp, kadanes3.cpp, lru_cache.cpp, matrix_exponentiation.cpp, palindrome_of_number.cpp, pascal_triangle.cpp, postfix_evaluation.cpp, primality_test.cpp, smallest_circle.cpp, sparse_matrix.cpp, spiral_print.cpp, stairs_pattern.cpp, tower_of_hanoi.cpp, vector_important_functions.cpp, addition_rule.cpp, bayes_theorem.cpp, binomial_dist.cpp, geometric_dist.cpp, poisson_dist.cpp, windowed_median.cpp, fenwick_tree.cpp, heavy_light_decomposition.cpp, persistent_seg_tree_lazy_prop.cpp, prefix_sum_array.cpp, sparse_table.cpp, binary_search.cpp, exponential_search.cpp, fibonacci_search.cpp, floyd_cycle_detection_algo.cpp, hash_search.cpp, interpolation_search.cpp, interpolation_search2.cpp, linear_search.cpp, median_search.cpp, saddleback_search.cpp, sublist_search.cpp, ternary_search.cpp, text_search.cpp, bogo_sort.cpp, comb_sort.cpp, count_inversions.cpp, cycle_sort.cpp, dnf_sort.cpp, gnome_sort.cpp, heap_sort.cpp, insertion_sort.cpp, merge_insertion_sort.cpp, merge_sort.cpp, pancake_sort.cpp, pigeonhole_sort.cpp, quick_sort.cpp, quick_sort_3.cpp, radix_sort2.cpp, random_pivot_quick_sort.cpp, recursive_bubble_sort.cpp, selection_sort_recursive.cpp, shell_sort2.cpp, strand_sort.cpp, wave_sort.cpp, brute_force_string_searching.cpp, horspool.cpp, knuth_morris_pratt.cpp, manacher_algorithm.cpp, rabin_karp.cpp, z_function.cpp +
- main() : graph_coloring.cpp, knight_tour.cpp, minimax.cpp, n_queens.cpp, n_queens_all_solution_optimised.cpp, nqueen_print_all_solutions.cpp, rat_maze.cpp, subarray_sum.cpp, subset_sum.cpp, sudoku_solve.cpp, wildcard_matching.cpp, count_of_set_bits.cpp, count_of_trailing_ciphers_in_factorial_n.cpp, hamming_distance.cpp, caesar_cipher.cpp, elliptic_curve_key_exchange.cpp, hill_cipher.cpp, morse_code.cpp, vigenere_cipher.cpp, xor_cipher.cpp, fcfs_scheduling.cpp, avltree.cpp, disjoint_set.cpp, linked_list.cpp, linkedlist_implentation_usingarray.cpp, list_array.cpp, queue_using_array.cpp, queue_using_two_stacks.cpp, reverse_a_linked_list.cpp, skip_list.cpp, sparse_table.cpp, tree_234.cpp, trie_modern.cpp, trie_tree.cpp, trie_using_hashmap.cpp, karatsuba_algorithm_for_fast_multiplication.cpp, 0_1_knapsack.cpp, abbreviation.cpp, coin_change_topdown.cpp, cut_rod.cpp, house_robber.cpp, kadane2.cpp, longest_increasing_subsequence.cpp, longest_palindromic_subsequence.cpp, minimum_edit_distance.cpp, palindrome_partitioning.cpp, shortest_common_supersequence.cpp, word_break.cpp, jarvis_algorithm.cpp, line_segment_intersection.cpp, bidirectional_dijkstra.cpp, breadth_first_search.cpp, connected_components.cpp, connected_components_with_dsu.cpp, depth_first_search.cpp, depth_first_search_with_stack.cpp, dijkstra.cpp, hamiltons_cycle.cpp, hopcroft_karp.cpp, is_graph_bipartite.cpp, lowest_common_ancestor.cpp, travelling_salesman_problem.cpp, spirograph.cpp, jumpgame.cpp, chaining.cpp, double_hash_hash_table.cpp, linear_probing_hash_table.cpp, md5.cpp, quadratic_probing_hash_table.cpp, sha1.cpp, gram_schmidt.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, neural_network.cpp, ordinary_least_squares_regressor.cpp, armstrong_number.cpp, binary_exponent.cpp, binomial_calculate.cpp, check_amicable_pair.cpp, check_factorial.cpp, check_prime.cpp, complex_numbers.cpp, double_factorial.cpp, eulers_totient_function.cpp, extended_euclid_algorithm.cpp, factorial.cpp, fast_power.cpp, fibonacci.cpp, fibonacci_fast.cpp, fibonacci_matrix_exponentiation.cpp, fibonacci_sum.cpp, finding_number_of_digits_in_a_number.cpp, gcd_iterative_euclidean.cpp, gcd_of_n_numbers.cpp, gcd_recursive_euclidean.cpp, integral_approximation.cpp, inv_sqrt.cpp, large_factorial.cpp, largest_power.cpp, lcm_sum.cpp, least_common_multiple.cpp, magic_number.cpp, miller_rabin.cpp, modular_division.cpp, modular_exponentiation.cpp, modular_inverse_fermat_little_theorem.cpp, n_bonacci.cpp, n_choose_r.cpp, ncr_modulo_p.cpp, number_of_positive_divisors.cpp, power_for_huge_numbers.cpp, power_of_two.cpp, prime_factorization.cpp, prime_numbers.cpp, primes_up_to_billion.cpp, realtime_stats.cpp, sieve_of_eratosthenes.cpp, sqrt_double.cpp, string_fibonacci.cpp, sum_of_binomial_coefficient.cpp, sum_of_digits.cpp, vector_cross_product.cpp, bisection_method.cpp, brent_method_extrema.cpp, false_position.cpp, gaussian_elimination.cpp, golden_search_extrema.cpp, lu_decompose.cpp, newton_raphson_method.cpp, ode_forward_euler.cpp, ode_midpoint_euler.cpp, ode_semi_implicit_euler.cpp, qr_decomposition.cpp, qr_eigen_values.cpp, rungekutta.cpp, successive_approximation.cpp, inorder_successor_of_bst.cpp, trie_multiple_search.cpp, buzz_number.cpp, decimal_to_hexadecimal.cpp, decimal_to_roman_numeral.cpp, fast_integer_input.cpp, happy_number.cpp, iterative_tree_traversals.cpp, kadanes3.cpp, lru_cache.cpp, matrix_exponentiation.cpp, palindrome_of_number.cpp, pascal_triangle.cpp, postfix_evaluation.cpp, primality_test.cpp, smallest_circle.cpp, sparse_matrix.cpp, spiral_print.cpp, stairs_pattern.cpp, tower_of_hanoi.cpp, vector_important_functions.cpp, addition_rule.cpp, bayes_theorem.cpp, binomial_dist.cpp, geometric_dist.cpp, poisson_dist.cpp, windowed_median.cpp, fenwick_tree.cpp, heavy_light_decomposition.cpp, persistent_seg_tree_lazy_prop.cpp, prefix_sum_array.cpp, sparse_table.cpp, binary_search.cpp, exponential_search.cpp, fibonacci_search.cpp, floyd_cycle_detection_algo.cpp, hash_search.cpp, interpolation_search.cpp, interpolation_search2.cpp, linear_search.cpp, median_search.cpp, saddleback_search.cpp, sublist_search.cpp, ternary_search.cpp, text_search.cpp, bogo_sort.cpp, comb_sort.cpp, count_inversions.cpp, cycle_sort.cpp, dnf_sort.cpp, gnome_sort.cpp, heap_sort.cpp, insertion_sort.cpp, merge_insertion_sort.cpp, merge_sort.cpp, pancake_sort.cpp, pigeonhole_sort.cpp, quick_sort.cpp, quick_sort_3.cpp, radix_sort2.cpp, random_pivot_quick_sort.cpp, recursive_bubble_sort.cpp, selection_sort_recursive.cpp, shell_sort2.cpp, strand_sort.cpp, wave_sort.cpp, brute_force_string_searching.cpp, horspool.cpp, knuth_morris_pratt.cpp, manacher_algorithm.cpp, rabin_karp.cpp, z_function.cpp
- mat_mul() : qr_eigen_values.cpp
- max_subarray_sum() : kadanes3.cpp
- merge() : merge_sort.cpp diff --git a/globals_func_s.html b/globals_func_s.html index a466aaaa6..660161a70 100644 --- a/globals_func_s.html +++ b/globals_func_s.html @@ -104,9 +104,10 @@ $(document).ready(function(){initNavTree('globals_func_s.html',''); initResizabl
- show_array() : bogo_sort.cpp
- show_data() : shell_sort2.cpp
- show_pascal() : pascal_triangle.cpp -
- sieve() : sieve_of_eratosthenes.cpp
- Sieve() : primes_up_to_billion.cpp +
- sieve() : sieve_of_eratosthenes.cpp
- SieveOfEratosthenes() : prime_factorization.cpp +
- sortcol() : fcfs_scheduling.cpp
- spiralPrint() : spiral_print.cpp
- Sqrt() : sqrt_double.cpp
- Standard_InvSqrt() : inv_sqrt.cpp diff --git a/globals_func_t.html b/globals_func_t.html index 71ab7f4f2..bc57baac7 100644 --- a/globals_func_t.html +++ b/globals_func_t.html @@ -94,7 +94,7 @@ $(document).ready(function(){initNavTree('globals_func_t.html',''); initResizabl
- ternary_search() : ternary_search.cpp -
- test() : rat_maze.cpp, subarray_sum.cpp, subset_sum.cpp, wildcard_matching.cpp, count_of_set_bits.cpp, count_of_trailing_ciphers_in_factorial_n.cpp, hamming_distance.cpp, caesar_cipher.cpp, elliptic_curve_key_exchange.cpp, morse_code.cpp, vigenere_cipher.cpp, xor_cipher.cpp, list_array.cpp, reverse_a_linked_list.cpp, sparse_table.cpp, trie_tree.cpp, trie_using_hashmap.cpp, karatsuba_algorithm_for_fast_multiplication.cpp, 0_1_knapsack.cpp, abbreviation.cpp, coin_change_topdown.cpp, cut_rod.cpp, house_robber.cpp, longest_increasing_subsequence.cpp, longest_palindromic_subsequence.cpp, minimum_edit_distance.cpp, palindrome_partitioning.cpp, shortest_common_supersequence.cpp, word_break.cpp, jarvis_algorithm.cpp, connected_components_with_dsu.cpp, is_graph_bipartite.cpp, jumpgame.cpp, md5.cpp, sha1.cpp, gram_schmidt.cpp, neural_network.cpp, armstrong_number.cpp, check_amicable_pair.cpp, double_factorial.cpp, fibonacci.cpp, fibonacci_matrix_exponentiation.cpp, fibonacci_sum.cpp, finding_number_of_digits_in_a_number.cpp, inv_sqrt.cpp, largest_power.cpp, lcm_sum.cpp, modular_division.cpp, modular_exponentiation.cpp, n_bonacci.cpp, n_choose_r.cpp, sum_of_binomial_coefficient.cpp, sum_of_digits.cpp, vector_cross_product.cpp, rungekutta.cpp, inorder_successor_of_bst.cpp, trie_multiple_search.cpp, kadanes3.cpp, smallest_circle.cpp, geometric_dist.cpp, windowed_median.cpp, persistent_seg_tree_lazy_prop.cpp, prefix_sum_array.cpp, floyd_cycle_detection_algo.cpp, median_search.cpp, saddleback_search.cpp, sublist_search.cpp, text_search.cpp, bogo_sort.cpp, count_inversions.cpp, cycle_sort.cpp, dnf_sort.cpp, gnome_sort.cpp, heap_sort.cpp, merge_insertion_sort.cpp, pancake_sort.cpp, random_pivot_quick_sort.cpp, recursive_bubble_sort.cpp, selection_sort_recursive.cpp, strand_sort.cpp, wave_sort.cpp, wiggle_sort.cpp, horspool.cpp, manacher_algorithm.cpp, z_function.cpp +
- test() : rat_maze.cpp, subarray_sum.cpp, subset_sum.cpp, wildcard_matching.cpp, count_of_set_bits.cpp, count_of_trailing_ciphers_in_factorial_n.cpp, hamming_distance.cpp, caesar_cipher.cpp, elliptic_curve_key_exchange.cpp, morse_code.cpp, vigenere_cipher.cpp, xor_cipher.cpp, fcfs_scheduling.cpp, list_array.cpp, reverse_a_linked_list.cpp, sparse_table.cpp, trie_tree.cpp, trie_using_hashmap.cpp, karatsuba_algorithm_for_fast_multiplication.cpp, 0_1_knapsack.cpp, abbreviation.cpp, coin_change_topdown.cpp, cut_rod.cpp, house_robber.cpp, longest_increasing_subsequence.cpp, longest_palindromic_subsequence.cpp, minimum_edit_distance.cpp, palindrome_partitioning.cpp, shortest_common_supersequence.cpp, word_break.cpp, jarvis_algorithm.cpp, connected_components_with_dsu.cpp, is_graph_bipartite.cpp, jumpgame.cpp, md5.cpp, sha1.cpp, gram_schmidt.cpp, neural_network.cpp, armstrong_number.cpp, check_amicable_pair.cpp, double_factorial.cpp, fibonacci.cpp, fibonacci_matrix_exponentiation.cpp, fibonacci_sum.cpp, finding_number_of_digits_in_a_number.cpp, inv_sqrt.cpp, largest_power.cpp, lcm_sum.cpp, modular_division.cpp, modular_exponentiation.cpp, n_bonacci.cpp, n_choose_r.cpp, sum_of_binomial_coefficient.cpp, sum_of_digits.cpp, vector_cross_product.cpp, rungekutta.cpp, inorder_successor_of_bst.cpp, trie_multiple_search.cpp, kadanes3.cpp, smallest_circle.cpp, geometric_dist.cpp, windowed_median.cpp, persistent_seg_tree_lazy_prop.cpp, prefix_sum_array.cpp, floyd_cycle_detection_algo.cpp, median_search.cpp, saddleback_search.cpp, sublist_search.cpp, text_search.cpp, bogo_sort.cpp, count_inversions.cpp, cycle_sort.cpp, dnf_sort.cpp, gnome_sort.cpp, heap_sort.cpp, merge_insertion_sort.cpp, pancake_sort.cpp, random_pivot_quick_sort.cpp, recursive_bubble_sort.cpp, selection_sort_recursive.cpp, strand_sort.cpp, wave_sort.cpp, wiggle_sort.cpp, horspool.cpp, manacher_algorithm.cpp, z_function.cpp
- test1() : hill_cipher.cpp, tree_234.cpp, hamiltons_cycle.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, large_factorial.cpp, sum_of_digits.cpp, brent_method_extrema.cpp, durand_kerner_roots.cpp, golden_search_extrema.cpp, lu_decompose.cpp, qr_eigen_values.cpp, iterative_tree_traversals.cpp
- test2() : hill_cipher.cpp, tree_234.cpp, hamiltons_cycle.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, large_factorial.cpp, sum_of_digits.cpp, brent_method_extrema.cpp, durand_kerner_roots.cpp, golden_search_extrema.cpp, lu_decompose.cpp, qr_eigen_values.cpp, iterative_tree_traversals.cpp, smallest_circle.cpp
- test3() : hamiltons_cycle.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, brent_method_extrema.cpp, golden_search_extrema.cpp, iterative_tree_traversals.cpp, smallest_circle.cpp diff --git a/globals_g.html b/globals_g.html index 3ac0c9f47..5ba25513f 100644 --- a/globals_g.html +++ b/globals_g.html @@ -96,6 +96,7 @@ $(document).ready(function(){initNavTree('globals_g.html',''); initResizable();
- gcd() : gcd_iterative_euclidean.cpp, gcd_of_n_numbers.cpp, gcd_recursive_euclidean.cpp, least_common_multiple.cpp
- genArray() : spiral_print.cpp
- get_clock_diff() : kohonen_som_topology.cpp, kohonen_som_trace.cpp +
- get_final_status() : fcfs_scheduling.cpp
- get_input() : ternary_search.cpp
- get_inverse() : ordinary_least_squares_regressor.cpp
- get_min_2d() : kohonen_som_topology.cpp diff --git a/globals_i.html b/globals_i.html index b5d750823..d3d28f433 100644 --- a/globals_i.html +++ b/globals_i.html @@ -105,9 +105,9 @@ $(document).ready(function(){initNavTree('globals_i.html',''); initResizable();
- is_happy() : happy_number.cpp
- is_prime() : check_prime.cpp
- is_square() : ordinary_least_squares_regressor.cpp -
- isprime : prime_factorization.cpp -
- isPrime() : modular_inverse_fermat_little_theorem.cpp
- IsPrime() : primality_test.cpp +
- isPrime() : modular_inverse_fermat_little_theorem.cpp +
- isprime : prime_factorization.cpp
- it_ternary_search() : ternary_search.cpp
- main() : graph_coloring.cpp, knight_tour.cpp, minimax.cpp, n_queens.cpp, n_queens_all_solution_optimised.cpp, nqueen_print_all_solutions.cpp, rat_maze.cpp, subarray_sum.cpp, subset_sum.cpp, sudoku_solve.cpp, wildcard_matching.cpp, count_of_set_bits.cpp, count_of_trailing_ciphers_in_factorial_n.cpp, hamming_distance.cpp, caesar_cipher.cpp, elliptic_curve_key_exchange.cpp, hill_cipher.cpp, morse_code.cpp, vigenere_cipher.cpp, xor_cipher.cpp, avltree.cpp, disjoint_set.cpp, linked_list.cpp, linkedlist_implentation_usingarray.cpp, list_array.cpp, queue_using_array.cpp, queue_using_two_stacks.cpp, reverse_a_linked_list.cpp, skip_list.cpp, sparse_table.cpp, tree_234.cpp, trie_modern.cpp, trie_tree.cpp, trie_using_hashmap.cpp, karatsuba_algorithm_for_fast_multiplication.cpp, 0_1_knapsack.cpp, abbreviation.cpp, coin_change_topdown.cpp, cut_rod.cpp, house_robber.cpp, kadane2.cpp, longest_increasing_subsequence.cpp, longest_palindromic_subsequence.cpp, minimum_edit_distance.cpp, palindrome_partitioning.cpp, shortest_common_supersequence.cpp, word_break.cpp, jarvis_algorithm.cpp, line_segment_intersection.cpp, bidirectional_dijkstra.cpp, breadth_first_search.cpp, connected_components.cpp, connected_components_with_dsu.cpp, depth_first_search.cpp, depth_first_search_with_stack.cpp, dijkstra.cpp, hamiltons_cycle.cpp, hopcroft_karp.cpp, is_graph_bipartite.cpp, lowest_common_ancestor.cpp, travelling_salesman_problem.cpp, spirograph.cpp, jumpgame.cpp, chaining.cpp, double_hash_hash_table.cpp, linear_probing_hash_table.cpp, md5.cpp, quadratic_probing_hash_table.cpp, sha1.cpp, gram_schmidt.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, neural_network.cpp, ordinary_least_squares_regressor.cpp, armstrong_number.cpp, binary_exponent.cpp, binomial_calculate.cpp, check_amicable_pair.cpp, check_factorial.cpp, check_prime.cpp, complex_numbers.cpp, double_factorial.cpp, eulers_totient_function.cpp, extended_euclid_algorithm.cpp, factorial.cpp, fast_power.cpp, fibonacci.cpp, fibonacci_fast.cpp, fibonacci_matrix_exponentiation.cpp, fibonacci_sum.cpp, finding_number_of_digits_in_a_number.cpp, gcd_iterative_euclidean.cpp, gcd_of_n_numbers.cpp, gcd_recursive_euclidean.cpp, integral_approximation.cpp, inv_sqrt.cpp, large_factorial.cpp, largest_power.cpp, lcm_sum.cpp, least_common_multiple.cpp, magic_number.cpp, miller_rabin.cpp, modular_division.cpp, modular_exponentiation.cpp, modular_inverse_fermat_little_theorem.cpp, n_bonacci.cpp, n_choose_r.cpp, ncr_modulo_p.cpp, number_of_positive_divisors.cpp, power_for_huge_numbers.cpp, power_of_two.cpp, prime_factorization.cpp, prime_numbers.cpp, primes_up_to_billion.cpp, realtime_stats.cpp, sieve_of_eratosthenes.cpp, sqrt_double.cpp, string_fibonacci.cpp, sum_of_binomial_coefficient.cpp, sum_of_digits.cpp, vector_cross_product.cpp, bisection_method.cpp, brent_method_extrema.cpp, false_position.cpp, gaussian_elimination.cpp, golden_search_extrema.cpp, lu_decompose.cpp, newton_raphson_method.cpp, ode_forward_euler.cpp, ode_midpoint_euler.cpp, ode_semi_implicit_euler.cpp, qr_decomposition.cpp, qr_eigen_values.cpp, rungekutta.cpp, successive_approximation.cpp, inorder_successor_of_bst.cpp, trie_multiple_search.cpp, buzz_number.cpp, decimal_to_hexadecimal.cpp, decimal_to_roman_numeral.cpp, fast_integer_input.cpp, happy_number.cpp, iterative_tree_traversals.cpp, kadanes3.cpp, lru_cache.cpp, matrix_exponentiation.cpp, palindrome_of_number.cpp, pascal_triangle.cpp, postfix_evaluation.cpp, primality_test.cpp, smallest_circle.cpp, sparse_matrix.cpp, spiral_print.cpp, stairs_pattern.cpp, tower_of_hanoi.cpp, vector_important_functions.cpp, addition_rule.cpp, bayes_theorem.cpp, binomial_dist.cpp, geometric_dist.cpp, poisson_dist.cpp, windowed_median.cpp, fenwick_tree.cpp, heavy_light_decomposition.cpp, persistent_seg_tree_lazy_prop.cpp, prefix_sum_array.cpp, sparse_table.cpp, binary_search.cpp, exponential_search.cpp, fibonacci_search.cpp, floyd_cycle_detection_algo.cpp, hash_search.cpp, interpolation_search.cpp, interpolation_search2.cpp, linear_search.cpp, median_search.cpp, saddleback_search.cpp, sublist_search.cpp, ternary_search.cpp, text_search.cpp, bogo_sort.cpp, comb_sort.cpp, count_inversions.cpp, cycle_sort.cpp, dnf_sort.cpp, gnome_sort.cpp, heap_sort.cpp, insertion_sort.cpp, merge_insertion_sort.cpp, merge_sort.cpp, pancake_sort.cpp, pigeonhole_sort.cpp, quick_sort.cpp, quick_sort_3.cpp, radix_sort2.cpp, random_pivot_quick_sort.cpp, recursive_bubble_sort.cpp, selection_sort_recursive.cpp, shell_sort2.cpp, strand_sort.cpp, wave_sort.cpp, brute_force_string_searching.cpp, horspool.cpp, knuth_morris_pratt.cpp, manacher_algorithm.cpp, rabin_karp.cpp, z_function.cpp +
- main() : graph_coloring.cpp, knight_tour.cpp, minimax.cpp, n_queens.cpp, n_queens_all_solution_optimised.cpp, nqueen_print_all_solutions.cpp, rat_maze.cpp, subarray_sum.cpp, subset_sum.cpp, sudoku_solve.cpp, wildcard_matching.cpp, count_of_set_bits.cpp, count_of_trailing_ciphers_in_factorial_n.cpp, hamming_distance.cpp, caesar_cipher.cpp, elliptic_curve_key_exchange.cpp, hill_cipher.cpp, morse_code.cpp, vigenere_cipher.cpp, xor_cipher.cpp, fcfs_scheduling.cpp, avltree.cpp, disjoint_set.cpp, linked_list.cpp, linkedlist_implentation_usingarray.cpp, list_array.cpp, queue_using_array.cpp, queue_using_two_stacks.cpp, reverse_a_linked_list.cpp, skip_list.cpp, sparse_table.cpp, tree_234.cpp, trie_modern.cpp, trie_tree.cpp, trie_using_hashmap.cpp, karatsuba_algorithm_for_fast_multiplication.cpp, 0_1_knapsack.cpp, abbreviation.cpp, coin_change_topdown.cpp, cut_rod.cpp, house_robber.cpp, kadane2.cpp, longest_increasing_subsequence.cpp, longest_palindromic_subsequence.cpp, minimum_edit_distance.cpp, palindrome_partitioning.cpp, shortest_common_supersequence.cpp, word_break.cpp, jarvis_algorithm.cpp, line_segment_intersection.cpp, bidirectional_dijkstra.cpp, breadth_first_search.cpp, connected_components.cpp, connected_components_with_dsu.cpp, depth_first_search.cpp, depth_first_search_with_stack.cpp, dijkstra.cpp, hamiltons_cycle.cpp, hopcroft_karp.cpp, is_graph_bipartite.cpp, lowest_common_ancestor.cpp, travelling_salesman_problem.cpp, spirograph.cpp, jumpgame.cpp, chaining.cpp, double_hash_hash_table.cpp, linear_probing_hash_table.cpp, md5.cpp, quadratic_probing_hash_table.cpp, sha1.cpp, gram_schmidt.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, neural_network.cpp, ordinary_least_squares_regressor.cpp, armstrong_number.cpp, binary_exponent.cpp, binomial_calculate.cpp, check_amicable_pair.cpp, check_factorial.cpp, check_prime.cpp, complex_numbers.cpp, double_factorial.cpp, eulers_totient_function.cpp, extended_euclid_algorithm.cpp, factorial.cpp, fast_power.cpp, fibonacci.cpp, fibonacci_fast.cpp, fibonacci_matrix_exponentiation.cpp, fibonacci_sum.cpp, finding_number_of_digits_in_a_number.cpp, gcd_iterative_euclidean.cpp, gcd_of_n_numbers.cpp, gcd_recursive_euclidean.cpp, integral_approximation.cpp, inv_sqrt.cpp, large_factorial.cpp, largest_power.cpp, lcm_sum.cpp, least_common_multiple.cpp, magic_number.cpp, miller_rabin.cpp, modular_division.cpp, modular_exponentiation.cpp, modular_inverse_fermat_little_theorem.cpp, n_bonacci.cpp, n_choose_r.cpp, ncr_modulo_p.cpp, number_of_positive_divisors.cpp, power_for_huge_numbers.cpp, power_of_two.cpp, prime_factorization.cpp, prime_numbers.cpp, primes_up_to_billion.cpp, realtime_stats.cpp, sieve_of_eratosthenes.cpp, sqrt_double.cpp, string_fibonacci.cpp, sum_of_binomial_coefficient.cpp, sum_of_digits.cpp, vector_cross_product.cpp, bisection_method.cpp, brent_method_extrema.cpp, false_position.cpp, gaussian_elimination.cpp, golden_search_extrema.cpp, lu_decompose.cpp, newton_raphson_method.cpp, ode_forward_euler.cpp, ode_midpoint_euler.cpp, ode_semi_implicit_euler.cpp, qr_decomposition.cpp, qr_eigen_values.cpp, rungekutta.cpp, successive_approximation.cpp, inorder_successor_of_bst.cpp, trie_multiple_search.cpp, buzz_number.cpp, decimal_to_hexadecimal.cpp, decimal_to_roman_numeral.cpp, fast_integer_input.cpp, happy_number.cpp, iterative_tree_traversals.cpp, kadanes3.cpp, lru_cache.cpp, matrix_exponentiation.cpp, palindrome_of_number.cpp, pascal_triangle.cpp, postfix_evaluation.cpp, primality_test.cpp, smallest_circle.cpp, sparse_matrix.cpp, spiral_print.cpp, stairs_pattern.cpp, tower_of_hanoi.cpp, vector_important_functions.cpp, addition_rule.cpp, bayes_theorem.cpp, binomial_dist.cpp, geometric_dist.cpp, poisson_dist.cpp, windowed_median.cpp, fenwick_tree.cpp, heavy_light_decomposition.cpp, persistent_seg_tree_lazy_prop.cpp, prefix_sum_array.cpp, sparse_table.cpp, binary_search.cpp, exponential_search.cpp, fibonacci_search.cpp, floyd_cycle_detection_algo.cpp, hash_search.cpp, interpolation_search.cpp, interpolation_search2.cpp, linear_search.cpp, median_search.cpp, saddleback_search.cpp, sublist_search.cpp, ternary_search.cpp, text_search.cpp, bogo_sort.cpp, comb_sort.cpp, count_inversions.cpp, cycle_sort.cpp, dnf_sort.cpp, gnome_sort.cpp, heap_sort.cpp, insertion_sort.cpp, merge_insertion_sort.cpp, merge_sort.cpp, pancake_sort.cpp, pigeonhole_sort.cpp, quick_sort.cpp, quick_sort_3.cpp, radix_sort2.cpp, random_pivot_quick_sort.cpp, recursive_bubble_sort.cpp, selection_sort_recursive.cpp, shell_sort2.cpp, strand_sort.cpp, wave_sort.cpp, brute_force_string_searching.cpp, horspool.cpp, knuth_morris_pratt.cpp, manacher_algorithm.cpp, rabin_karp.cpp, z_function.cpp
- mat_mul() : qr_eigen_values.cpp
- mat_size : matrix_exponentiation.cpp
- matrix : lu_decomposition.h diff --git a/globals_p.html b/globals_p.html index 0e47ba48a..73d842724 100644 --- a/globals_p.html +++ b/globals_p.html @@ -105,8 +105,8 @@ $(document).ready(function(){initNavTree('globals_p.html',''); initResizable();
- pop() : paranthesis_matching.cpp
- power() : power_for_huge_numbers.cpp, matrix_exponentiation.cpp
- predict_OLS_regressor() : ordinary_least_squares_regressor.cpp -
- prime : primes_up_to_billion.cpp
- PRIME : rabin_karp.cpp +
- prime : primes_up_to_billion.cpp
- prime_factorization() : prime_factorization.cpp
- prime_numbers : prime_factorization.cpp
- primes() : prime_numbers.cpp diff --git a/globals_s.html b/globals_s.html index f161f7de4..d77d8bf54 100644 --- a/globals_s.html +++ b/globals_s.html @@ -104,9 +104,10 @@ $(document).ready(function(){initNavTree('globals_s.html',''); initResizable();
- show_array() : bogo_sort.cpp
- show_data() : shell_sort2.cpp
- show_pascal() : pascal_triangle.cpp -
- sieve() : sieve_of_eratosthenes.cpp
- Sieve() : primes_up_to_billion.cpp +
- sieve() : sieve_of_eratosthenes.cpp
- SieveOfEratosthenes() : prime_factorization.cpp +
- sortcol() : fcfs_scheduling.cpp
- spiralPrint() : spiral_print.cpp
- Sqrt() : sqrt_double.cpp
- stack : paranthesis_matching.cpp diff --git a/globals_t.html b/globals_t.html index e9776bdb2..4be523508 100644 --- a/globals_t.html +++ b/globals_t.html @@ -94,7 +94,7 @@ $(document).ready(function(){initNavTree('globals_t.html',''); initResizable();
- ternary_search() : ternary_search.cpp -
- test() : rat_maze.cpp, subarray_sum.cpp, subset_sum.cpp, wildcard_matching.cpp, count_of_set_bits.cpp, count_of_trailing_ciphers_in_factorial_n.cpp, hamming_distance.cpp, caesar_cipher.cpp, elliptic_curve_key_exchange.cpp, morse_code.cpp, vigenere_cipher.cpp, xor_cipher.cpp, list_array.cpp, reverse_a_linked_list.cpp, sparse_table.cpp, trie_tree.cpp, trie_using_hashmap.cpp, karatsuba_algorithm_for_fast_multiplication.cpp, 0_1_knapsack.cpp, abbreviation.cpp, coin_change_topdown.cpp, cut_rod.cpp, house_robber.cpp, longest_increasing_subsequence.cpp, longest_palindromic_subsequence.cpp, minimum_edit_distance.cpp, palindrome_partitioning.cpp, shortest_common_supersequence.cpp, word_break.cpp, jarvis_algorithm.cpp, connected_components_with_dsu.cpp, is_graph_bipartite.cpp, jumpgame.cpp, md5.cpp, sha1.cpp, gram_schmidt.cpp, neural_network.cpp, armstrong_number.cpp, check_amicable_pair.cpp, double_factorial.cpp, fibonacci.cpp, fibonacci_matrix_exponentiation.cpp, fibonacci_sum.cpp, finding_number_of_digits_in_a_number.cpp, inv_sqrt.cpp, largest_power.cpp, lcm_sum.cpp, modular_division.cpp, modular_exponentiation.cpp, n_bonacci.cpp, n_choose_r.cpp, sum_of_binomial_coefficient.cpp, sum_of_digits.cpp, vector_cross_product.cpp, rungekutta.cpp, inorder_successor_of_bst.cpp, trie_multiple_search.cpp, kadanes3.cpp, smallest_circle.cpp, geometric_dist.cpp, windowed_median.cpp, persistent_seg_tree_lazy_prop.cpp, prefix_sum_array.cpp, floyd_cycle_detection_algo.cpp, median_search.cpp, saddleback_search.cpp, sublist_search.cpp, text_search.cpp, bogo_sort.cpp, count_inversions.cpp, cycle_sort.cpp, dnf_sort.cpp, gnome_sort.cpp, heap_sort.cpp, merge_insertion_sort.cpp, pancake_sort.cpp, random_pivot_quick_sort.cpp, recursive_bubble_sort.cpp, selection_sort_recursive.cpp, strand_sort.cpp, wave_sort.cpp, wiggle_sort.cpp, horspool.cpp, manacher_algorithm.cpp, z_function.cpp +
- test() : rat_maze.cpp, subarray_sum.cpp, subset_sum.cpp, wildcard_matching.cpp, count_of_set_bits.cpp, count_of_trailing_ciphers_in_factorial_n.cpp, hamming_distance.cpp, caesar_cipher.cpp, elliptic_curve_key_exchange.cpp, morse_code.cpp, vigenere_cipher.cpp, xor_cipher.cpp, fcfs_scheduling.cpp, list_array.cpp, reverse_a_linked_list.cpp, sparse_table.cpp, trie_tree.cpp, trie_using_hashmap.cpp, karatsuba_algorithm_for_fast_multiplication.cpp, 0_1_knapsack.cpp, abbreviation.cpp, coin_change_topdown.cpp, cut_rod.cpp, house_robber.cpp, longest_increasing_subsequence.cpp, longest_palindromic_subsequence.cpp, minimum_edit_distance.cpp, palindrome_partitioning.cpp, shortest_common_supersequence.cpp, word_break.cpp, jarvis_algorithm.cpp, connected_components_with_dsu.cpp, is_graph_bipartite.cpp, jumpgame.cpp, md5.cpp, sha1.cpp, gram_schmidt.cpp, neural_network.cpp, armstrong_number.cpp, check_amicable_pair.cpp, double_factorial.cpp, fibonacci.cpp, fibonacci_matrix_exponentiation.cpp, fibonacci_sum.cpp, finding_number_of_digits_in_a_number.cpp, inv_sqrt.cpp, largest_power.cpp, lcm_sum.cpp, modular_division.cpp, modular_exponentiation.cpp, n_bonacci.cpp, n_choose_r.cpp, sum_of_binomial_coefficient.cpp, sum_of_digits.cpp, vector_cross_product.cpp, rungekutta.cpp, inorder_successor_of_bst.cpp, trie_multiple_search.cpp, kadanes3.cpp, smallest_circle.cpp, geometric_dist.cpp, windowed_median.cpp, persistent_seg_tree_lazy_prop.cpp, prefix_sum_array.cpp, floyd_cycle_detection_algo.cpp, median_search.cpp, saddleback_search.cpp, sublist_search.cpp, text_search.cpp, bogo_sort.cpp, count_inversions.cpp, cycle_sort.cpp, dnf_sort.cpp, gnome_sort.cpp, heap_sort.cpp, merge_insertion_sort.cpp, pancake_sort.cpp, random_pivot_quick_sort.cpp, recursive_bubble_sort.cpp, selection_sort_recursive.cpp, strand_sort.cpp, wave_sort.cpp, wiggle_sort.cpp, horspool.cpp, manacher_algorithm.cpp, z_function.cpp
- test1() : hill_cipher.cpp, tree_234.cpp, hamiltons_cycle.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, large_factorial.cpp, sum_of_digits.cpp, brent_method_extrema.cpp, durand_kerner_roots.cpp, golden_search_extrema.cpp, lu_decompose.cpp, qr_eigen_values.cpp, iterative_tree_traversals.cpp
- test2() : hill_cipher.cpp, tree_234.cpp, hamiltons_cycle.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, large_factorial.cpp, sum_of_digits.cpp, brent_method_extrema.cpp, durand_kerner_roots.cpp, golden_search_extrema.cpp, lu_decompose.cpp, qr_eigen_values.cpp, iterative_tree_traversals.cpp, smallest_circle.cpp
- test3() : hamiltons_cycle.cpp, adaline_learning.cpp, kohonen_som_topology.cpp, kohonen_som_trace.cpp, brent_method_extrema.cpp, golden_search_extrema.cpp, iterative_tree_traversals.cpp, smallest_circle.cpp diff --git a/hierarchy.html b/hierarchy.html index 6cdc2a251..15fb8a93a 100644 --- a/hierarchy.html +++ b/hierarchy.html @@ -104,92 +104,94 @@ This inheritance list is sorted roughly, but not completely, alphabetically:
Simple C++ implementation of the SHA-1 Hashing Algorithm
SHA-1 is a cryptographic hash function that was developped by the NSA 1995. SHA-1 is not considered secure since around 2010.
-
+
Algorithm
The first step of the algorithm is to pad the message for its length to be a multiple of 64 (bytes). This is done by first adding 0x80 (10000000) and then only zeroes until the last 8 bytes must be filled, where then the 64 bit size of the input will be added
Once this is done, the algo breaks down this padded message into 64 bytes chunks. Each chunk is used for one round, a round breaks the chunk into 16 blocks of 4 bytes. These 16 blocks are then extended to 80 blocks using XOR operations on existing blocks (see code for more details). The algorithm will then update its 160-bit state (here represented used 5 32-bits integer) using partial hashes computed using special functions on the blocks previously built. Please take a look at the wikipedia article for more precision on these operations
Detailed Description
Iterative version of Preorder, Postorder, and preorder Traversal of the Tree
-
+
Iterative Preorder Traversal of a tree
Create a Stack that will store the Node of Tree. Push the root node into the stack. Save the root into the variabe named as current, and pop and elemnt from the stack. Store the data of current into the result array, and start traversing from it. Push both the child node of the current node into the stack, first right child then left child. Repeat the same set of steps untill the Stack becomes empty. And return the result array as the preorder traversal of a tree.
-
+
Iterative Postorder Traversal of a tree
Create a Stack that will store the Node of Tree. Push the root node into the stack. Save the root into the variabe named as current, and pop and elemnt from the stack. Store the data of current into the result array, and start traversing from it. Push both the child node of the current node into the stack, first left child then right child. Repeat the same set of steps untill the Stack becomes empty. Now reverse the result array and then return it to the calling function as a postorder traversal of a tree.
-
+
Iterative Inorder Traversal of a tree
Create a Stack that will store the Node of Tree. Push the root node into the stack. Save the root into the variabe named as current. Now iterate and take the current to the extreme left of the tree by traversing only to its left. Pop the elemnt from the stack and assign it to the current. Store the data of current into the result array. Repeat the same set of steps until the Stack becomes empty or the current becomes NULL. And return the result array as the inorder traversal of a tree.
Function Documentation
diff --git a/d8/d99/connected__components__with__dsu_8cpp.html b/d8/d99/connected__components__with__dsu_8cpp.html index 75568d7b0..ab127c3d4 100644 --- a/d8/d99/connected__components__with__dsu_8cpp.html +++ b/d8/d99/connected__components__with__dsu_8cpp.html @@ -155,7 +155,7 @@ uint32_tDetailed Description
The Disjoint union is the technique to find connected component in graph efficiently.
-
+
Algorithm
In Graph, if you have to find out the number of connected components, there are 2 options
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+|
+ Algorithms_in_C++ 1.0.0
+
+ Set of algorithms implemented in C++.
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Compare< S, T, E > Member List
+
+
+
+This is the complete list of members for Compare< S, T, E >, including all inherited members.
+| operator()(tuple< S, T, E, double, double, double > &t1, tuple< S, T, E, double, double, double > &t2) | Compare< S, T, E > | inline |
+
+
+
diff --git a/d9/dfd/comb__sort_8cpp.html b/d9/dfd/comb__sort_8cpp.html
index 871becef3..117c91753 100644
--- a/d9/dfd/comb__sort_8cpp.html
+++ b/d9/dfd/comb__sort_8cpp.html
@@ -172,7 +172,7 @@ Functions-
+
Initialize swapped as true to make sure that loop runs
Keep running until gap = 1 or none elements were swapped
Find next gap
-Compare all elements with current gap
+Compare all elements with current gap
diff --git a/da/d52/minimum__edit__distance_8cpp.html b/da/d52/minimum__edit__distance_8cpp.html
index 3567f6cd6..624a0f246 100644
--- a/da/d52/minimum__edit__distance_8cpp.html
+++ b/da/d52/minimum__edit__distance_8cpp.html
@@ -136,7 +136,7 @@ Functions
+
diff --git a/files_dup.js b/files_dup.js
index 927c6694b..685144116 100644
--- a/files_dup.js
+++ b/files_dup.js
@@ -3,6 +3,7 @@ var files_dup =
[ "backtracking", "dir_c11585dfcef32a26e29098facab6c144.html", "dir_c11585dfcef32a26e29098facab6c144" ],
[ "bit_manipulation", "dir_f3c4fbc4e901afa0a54d0623c5574aa7.html", "dir_f3c4fbc4e901afa0a54d0623c5574aa7" ],
[ "ciphers", "dir_4d6e05837bf820fb089a8a8cdf2f42b7.html", "dir_4d6e05837bf820fb089a8a8cdf2f42b7" ],
+ [ "cpu_scheduling_algorithms", "dir_cc8e79ed9d2b7756c78e8d0c87c6c0c7.html", "dir_cc8e79ed9d2b7756c78e8d0c87c6c0c7" ],
[ "data_structures", "dir_2e746e9d06bf2d8ff842208bcc6ebcfc.html", "dir_2e746e9d06bf2d8ff842208bcc6ebcfc" ],
[ "divide_and_conquer", "dir_93bc990c5cceb745f78af6949e9ef947.html", "dir_93bc990c5cceb745f78af6949e9ef947" ],
[ "dynamic_programming", "dir_8a20dd5bfd5341a725342bf72b6b686f.html", "dir_8a20dd5bfd5341a725342bf72b6b686f" ],
diff --git a/functions_a.html b/functions_a.html
index b6c1b9164..56bd8eb2f 100644
--- a/functions_a.html
+++ b/functions_a.html
@@ -103,6 +103,7 @@ $(document).ready(function(){initNavTree('functions_a.html',''); initResizable()
diff --git a/globals_func_m.html b/globals_func_m.html
index d58fdf390..875a674bd 100644
--- a/globals_func_m.html
+++ b/globals_func_m.html
@@ -93,7 +93,7 @@ $(document).ready(function(){initNavTree('globals_func_m.html',''); initResizabl
Detailed Description
Implementation of Minimum Edit Distance using Dynamic Programing.
Given two strings str1 & str2 and we have to calculate the minimum number of operations (Insert, Remove, Replace) required to convert str1 to str2.
-
+
Algorithm
We will solve this problem using Naive recursion. But as we are approaching with a DP solution. So, we will take a DP array to store the solution of all sub-problems so that we don't have to perform recursion again and again. Now to solve the problem, We can traverse all characters from either right side of the strings or left side. Suppose we will do it from the right side. So, there are two possibilities for every pair of characters being traversed.
Detailed Description
Implementation of 0-1 Knapsack Problem
Given weights and values of n items, put these items in a knapsack of capacity W to get the maximum total value in the knapsack. In other words, given two integer arrays val[0..n-1] and wt[0..n-1] which represent values and weights associated with n items respectively. Also given an integer W which represents knapsack capacity, find out the maximum value subset of val[] such that sum of the weights of this subset is smaller than or equal to W. You cannot break an item, either pick the complete item or don’t pick it (0-1 property)
+
Algorithm
The idea is to consider all subsets of items and calculate the total weight and value of all subsets. Consider the only subsets whose total weight is smaller than W. From all such subsets, pick the maximum value subset.
Detailed Description
Implementation of Kadane Algorithm
Kadane algorithm is used to find the maximum sum subarray in an array and maximum sum subarray problem is the task of finding a contiguous subarray with the largest sum
-
+
Algorithm
The simple idea of the algorithm is to search for all positive contiguous segments of the array and keep track of maximum sum contiguous segment among all positive segments(curr_sum is used for this) Each time we get a positive sum we compare it with max_sum and update max_sum if it is greater than curr_sum
diff --git a/dd/d47/namespacemath.html b/dd/d47/namespacemath.html index c23f2ccf6..1d04b6d46 100644 --- a/dd/d47/namespacemath.html +++ b/dd/d47/namespacemath.html @@ -145,7 +145,7 @@ FunctionsMathematical algorithms
Given a recurrence relation; evaluate the value of nth term. For e.g., For fibonacci series, recurrence series is f(n) = f(n-1) + f(n-2) where f(0) = 0 and f(1) = 1. Note that the method used only demonstrates recurrence relation with one variable (n), unlike nCr problem, since it has two (n, r)
+
Algorithm
This problem can be solved using matrix exponentiation method.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+|
+ Algorithms_in_C++ 1.0.0
+
+ Set of algorithms implemented in C++.
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+FCFS< S, T, E > Class Template Reference
+
+
+
+
+
The documentation for this class was generated from the following file:
+Class which implements the FCFS scheduling algorithm. + More...
++Public Member Functions | |
| void | addProcess (S id, T arrival, E burst) |
| Adds the process to the ready queue if it isn't already there. More... | |
| vector< tuple< S, T, E, double, double, double > > | scheduleForFcfs () |
| Algorithm for scheduling CPU processes according to the First Come First Serve(FCFS) scheduling algorithm. More... | |
| void | printResult () |
| Utility function for printing the status of each process after execution. More... | |
+Private Attributes | |
| priority_queue< tuple< S, T, E, double, double, double >, vector< tuple< S, T, E, double, double, double > >, Compare< S, T, E > > | schedule |
| +vector< tuple< S, T, E, double, double, double > > | result |
| +unordered_set< S > | idList |
Detailed Description
+template<typename S, typename T, typename E>
+class FCFS< S, T, E >
+class FCFS< S, T, E >
Class which implements the FCFS scheduling algorithm.
+Member Function Documentation
+ +◆ addProcess()
+ +
+
+
+
+
+
+
+template<typename S , typename T , typename E >
+
+
|
+ +inline | +
+
+
+Adds the process to the ready queue if it isn't already there.
+
+
+
+
+
+
+
+
+
+
+
+
+
priority_queue< tuple< S, T, E, double, double, double >, vector< tuple< S, T, E, double, double, double > >, Compare< S, T, E > > schedule
Definition: fcfs_scheduling.cpp:111
T make_tuple(T... args)
+Here is the call graph for this function:
+
+
+
+
+
+◆ printResult()
+ +
+
+
+
+
+
+
+template<typename S , typename T , typename E >
+
+
|
+ +inline | +
+
+
+Utility function for printing the status of each process after execution.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
T fixed(T... args)
T left(T... args)
T setprecision(T... args)
T setw(T... args)
+Here is the call graph for this function:
+
+
+
+
+
+◆ scheduleForFcfs()
+ +
+
+
+
+
+
+template<typename S , typename T , typename E >
+
+
|
+ +inline | +
+
+
+Algorithm for scheduling CPU processes according to the First Come First Serve(FCFS) scheduling algorithm.
+FCFS is a non-preemptive algorithm in which the process which arrives first gets executed first. If two or more processes arrive together then the process with smaller process ID runs first (each process has a unique proces ID).
+I used a min priority queue of tuples to accomplish this task. The processes are ordered by their arrival times. If arrival times of some processes are equal, then they are ordered by their process ID.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Member Data Documentation
+ +◆ schedule
+ +
+
+
+
+
+
+template<typename S , typename T , typename E >
+
+
|
+ +private | +
+
+Priority queue of schedules(stored as tuples) of processes. In each tuple 1st element: Process ID 2nd element: Arrival Time 3rd element: Burst time 4th element: Completion time 5th element: Turnaround time 6th element: Waiting time
+ +The documentation for this class was generated from the following file:
-
+
+
+
+
diff --git a/dd/dca/class_f_c_f_s.js b/dd/dca/class_f_c_f_s.js
new file mode 100644
index 000000000..3c4ded1da
--- /dev/null
+++ b/dd/dca/class_f_c_f_s.js
@@ -0,0 +1,7 @@
+var class_f_c_f_s =
+[
+ [ "addProcess", "dd/dca/class_f_c_f_s.html#a8fbfe4d85f7576b4a7aade07d29fbd69", null ],
+ [ "printResult", "dd/dca/class_f_c_f_s.html#abb361a612b18bb189aa6d3c49288b793", null ],
+ [ "scheduleForFcfs", "dd/dca/class_f_c_f_s.html#aa25dbe30ba9930b5a7c1a6d11758bd91", null ],
+ [ "schedule", "dd/dca/class_f_c_f_s.html#af2594e22a867b308e027623940193d46", null ]
+];
\ No newline at end of file
diff --git a/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.map b/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.map
new file mode 100644
index 000000000..5ff1060ab
--- /dev/null
+++ b/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.map
@@ -0,0 +1,6 @@
+
diff --git a/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.md5 b/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.md5
new file mode 100644
index 000000000..f960e4771
--- /dev/null
+++ b/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.md5
@@ -0,0 +1 @@
+40be8724cd3544d6f4f7db4d23d50120
\ No newline at end of file
diff --git a/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.svg b/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.svg
new file mode 100644
index 000000000..4e2da5e1f
--- /dev/null
+++ b/dd/dca/class_f_c_f_s_a8fbfe4d85f7576b4a7aade07d29fbd69_cgraph.svg
@@ -0,0 +1,69 @@
+
+
+
+
+
diff --git a/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.map b/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.map
new file mode 100644
index 000000000..bf9103337
--- /dev/null
+++ b/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.map
@@ -0,0 +1,6 @@
+
diff --git a/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.md5 b/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.md5
new file mode 100644
index 000000000..da9dbaf40
--- /dev/null
+++ b/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.md5
@@ -0,0 +1 @@
+fbc7b8c39328fdeb00baa02dadb94ca6
\ No newline at end of file
diff --git a/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.svg b/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.svg
new file mode 100644
index 000000000..e611a5eb6
--- /dev/null
+++ b/dd/dca/class_f_c_f_s_abb361a612b18bb189aa6d3c49288b793_cgraph.svg
@@ -0,0 +1,67 @@
+
+
+
+
+
diff --git a/de/d4a/class_compare.html b/de/d4a/class_compare.html
new file mode 100644
index 000000000..3bea0dd03
--- /dev/null
+++ b/de/d4a/class_compare.html
@@ -0,0 +1,195 @@
+
+
+
+
+
+
+
+-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+|
+ Algorithms_in_C++ 1.0.0
+
+ Set of algorithms implemented in C++.
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Compare< S, T, E > Class Template Reference
+
+
+
+
The documentation for this class was generated from the following file:
+Comparator class for priority queue. + More...
++Public Member Functions | |
| bool | operator() (tuple< S, T, E, double, double, double > &t1, tuple< S, T, E, double, double, double > &t2) |
| A comparator function that checks whether to swap the two tuples or not. to https://www.geeksforgeeks.org/comparator-class-in-c-with-examples/ for detailed description of comparator. More... | |
Detailed Description
+template<typename S, typename T, typename E>
+class Compare< S, T, E >
+class Compare< S, T, E >
Comparator class for priority queue.
+Member Function Documentation
+ +◆ operator()()
+ +
+
+
+
+
+
+template<typename S , typename T , typename E >
+
+
|
+ +inline | +
+
+
+A comparator function that checks whether to swap the two tuples or not. to https://www.geeksforgeeks.org/comparator-class-in-c-with-examples/ for detailed description of comparator.
+The documentation for this class was generated from the following file:
-
+
+
+
+
diff --git a/de/d4a/class_compare.js b/de/d4a/class_compare.js
new file mode 100644
index 000000000..f123aff03
--- /dev/null
+++ b/de/d4a/class_compare.js
@@ -0,0 +1,4 @@
+var class_compare =
+[
+ [ "operator()", "de/d4a/class_compare.html#afbdf9a44adb49728dc704155d7d1570c", null ]
+];
\ No newline at end of file
diff --git a/de/d8d/class_f_c_f_s-members.html b/de/d8d/class_f_c_f_s-members.html
new file mode 100644
index 000000000..5afa21c6c
--- /dev/null
+++ b/de/d8d/class_f_c_f_s-members.html
@@ -0,0 +1,114 @@
+
+
+
+
+
+
+
+-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+|
+ Algorithms_in_C++ 1.0.0
+
+ Set of algorithms implemented in C++.
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+FCFS< S, T, E > Member List
+
+
+
+This is the complete list of members for FCFS< S, T, E >, including all inherited members.
+| addProcess(S id, T arrival, E burst) | FCFS< S, T, E > | inline |
| idList (defined in FCFS< S, T, E >) | FCFS< S, T, E > | private |
| printResult() | FCFS< S, T, E > | inline |
| result (defined in FCFS< S, T, E >) | FCFS< S, T, E > | private |
| schedule | FCFS< S, T, E > | private |
| scheduleForFcfs() | FCFS< S, T, E > | inline |
+
+
+
diff --git a/df/d47/fcfs__scheduling_8cpp.html b/df/d47/fcfs__scheduling_8cpp.html
new file mode 100644
index 000000000..298493c7c
--- /dev/null
+++ b/df/d47/fcfs__scheduling_8cpp.html
@@ -0,0 +1,376 @@
+
+
+
+
+
+
+
+-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+|
+ Algorithms_in_C++ 1.0.0
+
+ Set of algorithms implemented in C++.
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Implementation of FCFS CPU scheduling algorithm. +More...
+#include <algorithm>+
#include <cassert>+
#include <cstdlib>+
#include <ctime>+
#include <iomanip>+
#include <iostream>+
#include <queue>+
#include <unordered_set>+
#include <vector>+
+Include dependency graph for fcfs_scheduling.cpp:
+
+
+
+
++Classes | |
| class | Compare< S, T, E > |
| Comparator class for priority queue. More... | |
| class | FCFS< S, T, E > |
| Class which implements the FCFS scheduling algorithm. More... | |
+Functions | |
| template<typename S , typename T , typename E > | |
| bool | sortcol (tuple< S, T, E > &t1, tuple< S, T, E > &t2) |
| Comparator function for sorting a vector. More... | |
| template<typename S , typename T , typename E > | |
| vector< tuple< S, T, E, double, double, double > > | get_final_status (vector< tuple< uint32_t, uint32_t, uint32_t > > input) |
| Function to be used for testing purposes. This function guarantees the correct solution for FCFS scheduling algorithm. More... | |
| static void | test () |
| Self-test implementations. More... | |
| int | main () |
| Entry point of the program. More... | |
Detailed Description
+Implementation of FCFS CPU scheduling algorithm.
+FCFS is a non-preemptive CPU scheduling algorithm in which whichever process arrives first, gets executed first. If two or more processes arrive simultaneously, the process with smaller process ID gets executed first. https://bit.ly/3ABNXOCPratyush Vatsa
+Function Documentation
+ +◆ get_final_status()
+ +
+
+
+
+
+
+
+template<typename S , typename T , typename E >
+ | vector< tuple< S, T, E, double, double, double > > get_final_status | +( | +vector< tuple< uint32_t, uint32_t, uint32_t > > | +input | ) | ++ |
+
+
+Function to be used for testing purposes. This function guarantees the correct solution for FCFS scheduling algorithm.
+Sorts the input vector according to arrival time. Processes whose arrival times are same get sorted according to process ID For each process, completion time, turnaround time and completion time are calculated, inserted in a tuple, which is added to the vector result.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+T begin(T... args)
T end(T... args)
T size(T... args)
T sort(T... args)
◆ main()
+ +
+
+
+
+
+
+
+| int main | +( | +void | +) | ++ |
◆ sortcol()
+ +
+
+
+
+
+
+
+template<typename S , typename T , typename E >
+ | bool sortcol | +( | +tuple< S, T, E > & | +t1, | +
| + | + | tuple< S, T, E > & | +t2 | +
| + | ) | ++ |
+
+
+Comparator function for sorting a vector.
+◆ test()
+ +
+
+
+
+
+
+
|
+ +static | +
+
+
+Self-test implementations.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
void addProcess(S id, T arrival, E burst)
Adds the process to the ready queue if it isn't already there.
Definition: fcfs_scheduling.cpp:129
vector< tuple< S, T, E, double, double, double > > scheduleForFcfs()
Algorithm for scheduling CPU processes according to the First Come First Serve(FCFS) scheduling algor...
Definition: fcfs_scheduling.cpp:154
T rand(T... args)
T srand(T... args)
T time(T... args)
+Here is the call graph for this function:
+
+
+
+
+
+
+
+
+
diff --git a/df/d47/fcfs__scheduling_8cpp.js b/df/d47/fcfs__scheduling_8cpp.js
new file mode 100644
index 000000000..3ab097c7e
--- /dev/null
+++ b/df/d47/fcfs__scheduling_8cpp.js
@@ -0,0 +1,9 @@
+var fcfs__scheduling_8cpp =
+[
+ [ "Compare< S, T, E >", "de/d4a/class_compare.html", "de/d4a/class_compare" ],
+ [ "FCFS< S, T, E >", "dd/dca/class_f_c_f_s.html", "dd/dca/class_f_c_f_s" ],
+ [ "get_final_status", "df/d47/fcfs__scheduling_8cpp.html#a8f2b90cb64d63a7080965e66a05ccf86", null ],
+ [ "main", "df/d47/fcfs__scheduling_8cpp.html#ae66f6b31b5ad750f1fe042a706a4e3d4", null ],
+ [ "sortcol", "df/d47/fcfs__scheduling_8cpp.html#a18920aa331faf4476b251c8cdb2c2bec", null ],
+ [ "test", "df/d47/fcfs__scheduling_8cpp.html#aa8dca7b867074164d5f45b0f3851269d", null ]
+];
\ No newline at end of file
diff --git a/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.map b/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.map
new file mode 100644
index 000000000..fac5223b9
--- /dev/null
+++ b/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.map
@@ -0,0 +1,8 @@
+
diff --git a/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.md5 b/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.md5
new file mode 100644
index 000000000..60334c7c9
--- /dev/null
+++ b/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.md5
@@ -0,0 +1 @@
+eb25f61bb3c01f732953e7b177f935be
\ No newline at end of file
diff --git a/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.svg b/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.svg
new file mode 100644
index 000000000..861a9adf2
--- /dev/null
+++ b/df/d47/fcfs__scheduling_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.svg
@@ -0,0 +1,99 @@
+
+
+
+
+
diff --git a/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.map b/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.map
new file mode 100644
index 000000000..ae5ce9e63
--- /dev/null
+++ b/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.map
@@ -0,0 +1,9 @@
+
diff --git a/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.md5 b/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.md5
new file mode 100644
index 000000000..ad9c7536b
--- /dev/null
+++ b/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.md5
@@ -0,0 +1 @@
+d1153ad5effebcdd01be2ae30d68c8af
\ No newline at end of file
diff --git a/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.svg b/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.svg
new file mode 100644
index 000000000..d4ff69629
--- /dev/null
+++ b/df/d47/fcfs__scheduling_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.svg
@@ -0,0 +1,114 @@
+
+
+
+
+
diff --git a/df/d66/vector__cross__product_8cpp.html b/df/d66/vector__cross__product_8cpp.html
index 71f0fb3b7..cc70bdf6c 100644
--- a/df/d66/vector__cross__product_8cpp.html
+++ b/df/d66/vector__cross__product_8cpp.html
@@ -144,7 +144,7 @@ Functions
-
+
+
The direction ratios (DR) are calculated as follows: 1st DR, J: (b * z) - (c * y) 2nd DR, A: -((a * z) - (c * x)) 3rd DR, N: (a * y) - (b * x)
Therefore, the direction ratios of the cross product are: J, A, N The following C++ Program calculates the direction ratios of the cross products of two vector. The program uses a function, cross() for doing so. The direction ratios for the first and the second vector has to be passed one by one seperated by a space character.
Magnitude of a vector is the square root of the sum of the squares of the direction ratios.
-
+
Example:
An example of a running instance of the executable program:
Pass the first Vector: 1 2 3
Pass the second Vector: 4 5 6 The cross product is: -3 6 -3 Magnitude: 7.34847
diff --git a/dir_000002_000016.html b/dir_000002_000017.html similarity index 100% rename from dir_000002_000016.html rename to dir_000002_000017.html diff --git a/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.map b/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.map index 623879934..72fef3963 100644 --- a/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.map +++ b/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.map @@ -1,5 +1,5 @@ diff --git a/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.md5 b/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.md5 index 5fd2b3301..257e4dba0 100644 --- a/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.md5 +++ b/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.md5 @@ -1 +1 @@ -92fa4d7ae23a16161aeff73e457c6e1f \ No newline at end of file +76e5d78bae3066db57a72fde536d8c2e \ No newline at end of file diff --git a/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.svg b/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.svg index d7d51943b..7af541bfb 100644 --- a/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.svg +++ b/dir_4d6e05837bf820fb089a8a8cdf2f42b7_dep.svg @@ -32,7 +32,7 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+|
+ Algorithms_in_C++ 1.0.0
+
+ Set of algorithms implemented in C++.
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+cpu_scheduling_algorithms Directory Reference
+
+
+
++Files | |
| file | fcfs_scheduling.cpp |
| Implementation of FCFS CPU scheduling algorithm. | |
+
+
+
diff --git a/dir_cc8e79ed9d2b7756c78e8d0c87c6c0c7.js b/dir_cc8e79ed9d2b7756c78e8d0c87c6c0c7.js
new file mode 100644
index 000000000..804b70f89
--- /dev/null
+++ b/dir_cc8e79ed9d2b7756c78e8d0c87c6c0c7.js
@@ -0,0 +1,4 @@
+var dir_cc8e79ed9d2b7756c78e8d0c87c6c0c7 =
+[
+ [ "fcfs_scheduling.cpp", "df/d47/fcfs__scheduling_8cpp.html", "df/d47/fcfs__scheduling_8cpp" ]
+];
\ No newline at end of file
diff --git a/files.html b/files.html
index d3fdd7b77..6eaa50aa5 100644
--- a/files.html
+++ b/files.html
@@ -121,232 +121,234 @@ solve-a-rat-in-a-maze-c-java-pytho/"
--
+
+
- s -
- s -
- m -
-
-
- t -
Here is a list of all documented file members with links to the documentation:
- m -
-
-
- t -
a-z a-z
+
Overview
This repository is a collection of open-source implementation of a variety of algorithms implemented in C++ and licensed under MIT License. These algorithms span a variety of topics from computer science, mathematics and statistics, data science, machine learning, engineering, etc.. The implementations and the associated documentation are meant to provide a learning resource for educators and students. Hence, one may find more than one implementation for the same objective but using a different algorithm strategies and optimizations.
-
+
Features
- The repository provides implementations of various algorithms in one of the most fundamental general purpose languages - C++.
@@ -109,12 +109,12 @@ Features
+
Documentation
Online Documentation is generated from the repository source codes directly. The documentation contains all resources including source code snippets, details on execution of the programs, diagrammatic representation of program flow, and links to external resources where necessary. The documentation also introduces interactive source code with links to documentation for C++ STL library functions used. Click on Files menu to see the list of all the files documented with the code.
Documentation of Algorithms in C++ by The Algorithms Contributors is licensed under CC BY-SA 4.0
+
Contributions
As a community developed and maintained repository, we welcome new un-plagiarized quality contributions. Please read our Contribution Guidelines.