Fix formatting and tables

Author: vbrazo

en/Data Structures/Linked Lists/Doubly Linked List.md

@@ -17,7 +17,7 @@ In singly linked list, to delete a node, pointer to the previous node is needed.
 ### Time Complexity
 
 | Operation | Average | Worst |
-|:---------:|:-------:|:-----:|
+|-----------|---------|-------|
 | Access    |   Θ(n)  |  O(n) |
 | Search    |   Θ(n)  |  O(n) |
 | Insertion |   Θ(1)  |  O(1) |

en/Data Structures/Linked Lists/Singly Linked List.md

@@ -15,7 +15,7 @@ Singly Linked List is a linear and connected data structure made of Nodes. Each
 ### Time Complexity
 
 | Operation | Average | Worst |
-|:---------:|:-------:|:-----:|
+|-----------|---------|-------|
 | Access    |   O(n)  |  O(n) |
 | Search    |   O(n)  |  O(n) |
 | Insertion |   O(1)  |  O(1) |

en/Dynamic Programming/Longest Common Subseqence.md

@@ -2,7 +2,7 @@
 
 #### Problem Statement
 
-Given two strings `S` and `T`, find the length of the longest common subsequence (<b>LCS</b>). 
+Given two strings `S` and `T`, find the length of the longest common subsequence (<b>LCS</b>).
 
 #### Approach
 
@@ -19,14 +19,14 @@ We could see that we can fill our `dp` table row by row, column by column. So ou
 - Let's say that we have strings `S` of the length N and `T` of the length M (numbered from 1). Let's create the table `dp` of size `(N + 1) x (M + 1)` numbered from 0.
 - Let's fill the 0th row and the 0th column of `dp` with 0.
 - Then, we follow the algorithm:
-    ```
-        for i in range(1..N):
-            for j in range(1..M):
-                if(S[i] == T[j])
-                    dp[i][j] = dp[i - 1][j - 1] + 1
-                else
-                    dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
-    ```
+```
+for i in range(1..N):
+    for j in range(1..M):
+        if(S[i] == T[j])
+            dp[i][j] = dp[i - 1][j - 1] + 1
+        else
+            dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
+```
 
 
 #### Time Complexity
@@ -35,8 +35,8 @@ We could see that we can fill our `dp` table row by row, column by column. So ou
 
 #### Space Complexity
 
-`O(N * M)` - simple implementation 
-`O(min {N, M})` - two-layers implementation (as `dp[i][j]` depends on only i-th and i-th layers, we coudld store only two layers). 
+`O(N * M)` - simple implementation
+`O(min {N, M})` - two-layers implementation (as `dp[i][j]` depends on only i-th and i-th layers, we coudld store only two layers).
 
 #### Example
 

en/Search Algorithms/Binary Search.md

@@ -22,7 +22,7 @@ O(1) Best Case (If middle element of initial array is the target element)
 #### Space Complexity
 
 O(1) For iterative approach          
-O(log n) For recursive approach due to recursion call stack 
+O(log n) For recursive approach due to recursion call stack
 
 #### Example
 
@@ -36,7 +36,7 @@ Here we find the middle element equal to target element so we return its index i
 
 target = 9          
 Binary Search should return -1 as 9 is not present in the array
- ```
+```
 
 #### Code Implementation Links
 

en/Search Algorithms/Linear Search.md

@@ -31,7 +31,7 @@ Linear Search should return index 3 as 5 is on index 3
 
 target = 6           
 Linear Search should return -1 as 6 is not present in the array
- ```
+```
 
 #### Code Implementation Links
 

en/Sorting Algorithms/Bubble Sort.md

@@ -15,15 +15,15 @@ Given an unsorted array of n elements, write a function to sort the array
 
 #### Time Complexity
 
-O(n^2) Worst case performance
+`O(n^2)` Worst case performance
 
-O(n) Best-case performance
+`O(n)` Best-case performance
 
-O(n^2) Average performance
+`O(n^2)` Average performance
 
 #### Space Complexity
 
-O(1) Worst case
+`O(1)` Worst case
 
 #### Founder's Name
 
@@ -46,7 +46,7 @@ Indexes: 0   1   2   3
 7. 80 > 30, swap 80 and 30
 8. The array now is {10, 40, 30, 80}
 
-	Repeat the Above Steps again
+Repeat the Above Steps again
 
 arr[] = {10, 40, 30, 80}
 Indexes: 0   1   2   3   
@@ -62,7 +62,7 @@ Indexes: 0   1   2   3
 7. 40 < 80, do nothing
 8. The array now is {10, 30, 40, 80}
 
-	Repeat the Above Steps again
+Repeat the Above Steps again
 
 arr[] = {10, 30, 40, 80}
 Indexes: 0   1   2   3   
@@ -76,11 +76,8 @@ Indexes: 0   1   2   3
 5. Index = 2, Number = 40
 6. 40 < 80, do nothing
 
-	Since there are no swaps in above steps, it means the array is sorted and we can stop here.
-
-
- ```
-
+Since there are no swaps in above steps, it means the array is sorted and we can stop here.
+```
 
 #### Code Implementation Links
 
@@ -94,7 +91,6 @@ Indexes: 0   1   2   3
 - [Scala](https://github.com/TheAlgorithms/Scala/blob/master/src/main/scala/Sort/BubbleSort.scala)
 - [Javascript](https://github.com/TheAlgorithms/Javascript/blob/master/Sorts/BubbleSort.js)
 
-
 #### Video Explanation
 
 [A video explaining the Bubble Sort Algorithm](https://www.youtube.com/watch?v=Jdtq5uKz-w4)
@@ -106,4 +102,3 @@ Bubble sort is also known as Sinking sort.
 #### Animation Explanation
 
 - [Tute Board](https://boardhub.github.io/tute/?wd=bubbleSortAlgo2)
-

en/Sorting Algorithms/Heap Sort.md

@@ -12,16 +12,16 @@ Given an unsorted array of n elements, write a function to sort the array
 
 #### Time Complexity
 
-O(n log n) Worst case performance
+`O(n log n)` Worst case performance
 
-O(n log n) (distinct keys)
-or O(n) (equal keys) Best-case performance 
+`O(n log n)` (distinct keys)
+or O(n) (equal keys) Best-case performance
 
-O(n log n)  Average performance
+`O(n log n)` Average performance
 
 #### Space Complexity
 
-O(1) Worst case auxiliary
+`O(1)` Worst case auxiliary
 
 
 #### Example
@@ -33,7 +33,7 @@ Input data: 4, 10, 3, 5, 1
     /   \
  5(3)    1(4)
 
-The numbers in bracket represent the indices in the array 
+The numbers in bracket represent the indices in the array
 representation of data.
 
 Applying heapify procedure to index 1:
@@ -52,7 +52,7 @@ Applying heapify procedure to index 0:
 The heapify procedure calls itself recursively to build heap
  in top down manner.
   ```
-  
+
 ![heap-image](https://upload.wikimedia.org/wikipedia/commons/1/1b/Sorting_heapsort_anim.gif "Heap Sort")
 
 #### Code Implementation Links
@@ -66,7 +66,6 @@ The heapify procedure calls itself recursively to build heap
 - [C](https://github.com/TheAlgorithms/C/blob/master/sorting/heap_sort.c)
 - [Javascript](https://github.com/TheAlgorithms/Javascript/blob/master/Sorts/HeapSort.js)
 
-
 #### Video Explanation
 
 [A video explaining the Selection Sort Algorithm](https://www.youtube.com/watch?v=MtQL_ll5KhQ)

en/Sorting Algorithms/Insertion Sort.md

@@ -8,19 +8,18 @@ Given an array of n elements, write a function to sort the array in increasing o
 
 - Define a "key" index, the subarray to the left of which is sorted.
 - Initiate "key" as 1, ie. the second element of array(as there is only one element to left of the second element, which can be considered as sorted array with one element).
-
 - If value of element at (key - 1) position is less than value of element at (key) position; increment "key".
 - Else move elements of sorted subarray that are greater than value of element at "key" to one position ahead of their current position. Put the value of element at "key" in the newly created void.
 
 #### Time Complexity
 
-О(n^2) comparisons, О(n^2) swaps -- Worst Case
+- `О(n^2)` comparisons, `О(n^2)` swaps -- Worst Case
 
-O(n) comparisons, O(1) swaps -- Best Case
+- `O(n)` comparisons, `O(1)` swaps -- Best Case
 
 #### Space Complexity
 
-O(1) -- (No extra space needed, sorting done in place)
+`O(1)` -- (No extra space needed, sorting done in place)
 
 #### Example
 
@@ -47,7 +46,7 @@ i = 4.
 6 will move to position after 5,
 and elements from 11 to 13 will move one position ahead of their current position.
 5, 6, 11, 12, 13  -- sorted array
- ```
+```
 
 #### Code Implementation Links
 

en/Sorting Algorithms/Merge Sort.md

@@ -12,11 +12,11 @@ Given an array of n elements, write a function to sort the array
 
 #### Time Complexity
 
-O(nLogn)
+`O(n log n)`
 
 #### Space Complexity
 
-O(n)
+`O(n)`
 
 #### Example
 
@@ -29,7 +29,7 @@ Recursively call merge sort function for both these halves which will provide so
 => [1, 3, 9] & [0, 2, 5]
 
 Now merge both these halves to get the sorted array [0, 1, 2, 3, 5, 9]
- ```
+```
 
 #### Code Implementation Links
 

en/Sorting Algorithms/Quick Sort.md

@@ -9,16 +9,16 @@ Given an unsorted array of n elements, write a function to sort the array
 - partition the array using pivot value
 - quicksort left partition recursively
 - quicksort right partition recursively
-#### Time Complexity
 
-O(n^2) Worst case performance
+#### Time Complexity
 
-O(n log n) Best-case performance
+- `O(n^2)` Worst case performance
+- `O(n log n)` Best-case performance
+- `O(n log n)` Average performance
 
-O(n log n) Average performance
 #### Space Complexity
 
-O(log(n)) Worst case
+`O(log n)` Worst case
 
 #### Founder's Name
 
@@ -64,7 +64,7 @@ arr[] = {10, 30, 40, 50, 70, 90, 80} // 80 and 70 Swapped
 Now 70 is at its correct place. All elements smaller than
 70 are before it and all elements greater than 70 are after
 it.
- ```
+```
 
 #### Code Implementation Links