Added documentation for Linear Search and added Minkowski Distance for Distance between 2 points

ddhira123 · ddhira123 · commit 3d1d197d402d · 2020-10-02T16:10:39.000+07:00
diff --git a/docs/distance-between-points.md b/docs/distance-between-points.md
@@ -119,11 +119,38 @@ manhattan_distance(P, Q) {
 }
 ```
 
+## Minkowski Distance
+
+**Minkowski Distance** is a metric in a normed vector space which can be considered as a generalization of both the Euclidean distance and the Manhattan distance. It is named after the German mathematician Hermann Minkowski.
+
+### Formula
+
+The formula below applies when calculating the Minkowski distance over an N-dimensional grid:
+
+$P = (p_1, p_2, ..., p_n)\\$
+$Q = (q_1, q_2, ..., q_n)\\$
+$d(P, Q) = \left( \sum_{i=1}^{n} |p_i - q_i|^m \right) ^ {\frac{1}{m}}$
+
+### Algorithm
+
+```
+/* Assume that P and Q are N-dimensional arrays */
+manhattan_distance(P, Q) {
+   N = dim(P)
+   distance = 0.0                             /* initialize running sum */
+   for dimension i from 1 to N {              /* iterate over all dimensions */
+      distance = distance + abs(P[i] - Q[i])^m  /* sum the processed differences */
+   }
+   return distance^(1/m);
+}
+```
+
+
 ## Performance
 
-Both algorithms for each respective distance definition are linear
+Both Euclidean and Manhattan distance algorithms for each respective distance definition are linear
 (O(n)) with respect to the number of dimensions with which each point is
-represented.
+represented. The Minkowski distance algorithm's complexity is around O(nm) for n dimensional vector and the factor power m.
 
 
 ## Implementations
@@ -136,11 +163,13 @@ represented.
 
 - [Euclidean distance][euclidean]
 - [Manhattan distance][manhattan]
+- [Minkowski distance][minkowski]
 - [Norm][norm] a generalization of the concept of distance
 - [L<sup>p</sup> space][lp-space] a generalization of a class of norms
 
 
 [euclidean]: https://en.wikipedia.org/wiki/Euclidean_distance
 [manhattan]: https://en.wikipedia.org/wiki/Taxicab_geometry
+[minkowski]: https://en.wikipedia.org/wiki/Minkowski_distance
 [norm]: https://en.wikipedia.org/wiki/Norm_(mathematics)
 [lp-space]: https://en.wikipedia.org/wiki/Lp_space
diff --git a/docs/linear-search.md b/docs/linear-search.md
@@ -4,4 +4,36 @@ title: Linear search
 sidebar_label: Linear search
 ---
 
-[Open a pull request](https://github.com/AllAlgorithms/algorithms/tree/master/docs/linear-search.md) to add the content for this algorithm.
+**Linear Search** or commonly called as sequential search is a method for finding an element within a list. It sequentially checks each element of the list until a match is found or the whole list has been searched.
+
+## Algorithm
+
+Linear Search requires two parameters: the array/list and the key. It traverses the entire array/list starting from the first element to the last element of the array. During the traversal, the algorithm checks if the element is equal to the key. Once it finds an element that equals to the key, the function immediately returns the index. The result will be considered as `NOT FOUND` if there is no any element in the array equals the key.
+
+The algorithm can be expressed in pseudocode as follows:
+
+```
+LinearSearch(array, key){
+    idx = 0
+    for idx = 0...n
+        if array[idx] = key then
+            return idx
+    
+    return -1
+}
+```
+
+Here is the simulation of Linear Search Algorithm:
+
+<img src="https://www.tutorialspoint.com/data_structures_algorithms/images/linear_search.gif"/>
+Source: Tutorialspoint
+
+## Complexity
+
+As the algorithm traverses entire list during runtime, then it has the complexity O(N). 
+
+## Implementation
+
+| | Language | Link |
+|:-: | :-: | :-: |
+| <img src="https://cdn.abranhe.com/projects/algorithms/logos/python.svg" width="30px"> | Python | [dbscan.py](https://github.com/AllAlgorithms/python/blob/master/algorithms/searches/linear_search.py) |
