diff --git a/guide/portuguese/algorithms/sorting-algorithms/merge-sort/index.md b/guide/portuguese/algorithms/sorting-algorithms/merge-sort/index.md
index 7f97374353..61d727df8c 100644
--- a/guide/portuguese/algorithms/sorting-algorithms/merge-sort/index.md
+++ b/guide/portuguese/algorithms/sorting-algorithms/merge-sort/index.md
@@ -38,167 +38,495 @@ MergeSort(arr[], left, right):
- ### Properties:
- * Space Complexity: O(n)
- * Time Complexity: O(n*log(n)). The time complexity for the Merge Sort might not be obvious from the first glance. The log(n) factor that comes in is because of the recurrence relation we have mentioned before.
- * Sorting In Place: No in a typical implementation
- * Stable: Yes
- * Parallelizable :yes (Several parallel variants are discussed in the third edition of Cormen, Leiserson, Rivest, and Stein's Introduction to Algorithms.)
+ ### Propriedades:
+ * Complexidade Espacial: O(n)
+ * Complexidade Temporal: O(n*log(n)). A complexidade temporal para o Merge Sort pode não ser óbvia desde o primeiro olhar. O fator log (n) que entra é por causa da relação de recorrência que mencionamos antes.
+ * Classificação no local: não em uma implementação típica
+ * Estável: Sim
+ * Paralelizável: Sim (Várias variantes paralelas são discutidos na terceira edição do Cormen, Leiserson, Rivest, e Introdução de Stein aos algoritmos.)
- ### Visualization:
+ ### Visualização:
* USFCA
* HackerEarth
-
-
- ### Relavant videos on freeCodeCamp YouTube channel
- * Merge Sort algorithm - MyCodeSchool
-
- ### Other Resources:
- * Wikipedia
- * GeeksForGeeks
- * Merge Sort - CS50
-
- ### Implementaion in JS
+
+ ### Implementação em JS
+```js
+const list = [23, 4, 42, 15, 16, 8, 3]
+
+const mergeSort = (list) =>{
+ if(list.length <= 1) return list;
+ const middle = list.length / 2 ;
+ const left = list.slice(0, middle);
+ const right = list.slice(middle, list.length);
+ return merge(mergeSort(left), mergeSort(right));
+}
+
+const merge = (left, right) => {
+ var result = [];
+ while(left.length || right.length) {
+ if(left.length && right.length) {
+ if(left[0] < right[0]) {
+ result.push(left.shift())
+ } else {
+ result.push(right.shift())
+ }
+ } else if(left.length) {
+ result.push(left.shift())
+ } else {
+ result.push(right.shift())
+ }
+ }
+ return result;
+}
+
+console.log(mergeSort(list)) // [ 3, 4, 8, 15, 16, 23, 42 ]
```
-js lista const = \[23, 4, 42, 15, 16, 8, 3\]
-
-const mergeSort = (lista) => { if (list.length <= 1) lista de retorno; const middle = list.length / 2; const left = list.slice (0, middle); const right = list.slice (meio, list.length); mesclagem de retorno (mergeSort (esquerda), mergeSort (direita)); }
-
-const merge = (esquerda, direita) => { var result = \[\]; while (left.length || right.length) { if (left.length && right.length) { if (esquerda \[0\]
+#include
+void merge(int arr[], int l, int m, int r)
+{
+ int i, j, k;
+ int n1 = m - l + 1;
+ int n2 = r - m;
+
+
+ int L[n1], R[n2];
+
+ for (i = 0; i < n1; i++)
+ L[i] = arr[l + i];
+ for (j = 0; j < n2; j++)
+ R[j] = arr[m + 1+ j];
+ i = 0;
+ j = 0;
+ k = l;
+ while (i < n1 && j < n2)
+ {
+ if (L[i] <= R[j])
+ {
+ arr[k] = L[i];
+ i++;
+ }
+ else
+ {
+ arr[k] = R[j];
+ j++;
+ }
+ k++;
+ }
+
+
+ while (i < n1)
{
arr[k] = L[i];
i++;
+ k++;
}
- else
+
+ while (j < n2)
{
arr[k] = R[j];
j++;
+ k++;
}
- k++;
- }
-
-
- while (i < n1)
- {
- arr[k] = L[i];
- i++;
- k++;
- }
-
- while (j < n2)
- {
- arr[k] = R[j];
- j++;
- k++;
- }
+}
+
+void mergeSort(int arr[], int l, int r)
+{
+ if (l < r)
+ {
+ int m = l+(r-l)/2;
+
+
+ mergeSort(arr, l, m);
+ mergeSort(arr, m+1, r);
+
+ merge(arr, l, m, r);
+ }
+}
+void printArray(int A[], int size)
+{
+ int i;
+ for (i=0; i < size; i++)
+ printf("%d ", A[i]);
+ printf("\n");
+}
+int main()
+{
+ int arr[] = {12, 11, 13, 5, 6, 7};
+ int arr_size = sizeof(arr)/sizeof(arr[0]);
+
+ printf("Given array is \n");
+ printArray(arr, arr_size);
+
+ mergeSort(arr, 0, arr_size - 1);
+
+ printf("\nSorted array is \n");
+ printArray(arr, arr_size);
+ return 0;
```
+### Implementação em C++
+
+Vamos considerar o array A = {2,5,7,8,9,12,13}
+e array B = {3,5,6,9,15} e queremos que o array C esteja em ordem crescente também.
+```cpp
+void mergesort(int A[],int size_a,int B[],int size_b,int C[])
+{
+ int token_a,token_b,token_c;
+ for(token_a=0, token_b=0, token_c=0; token_a left(k))
+ k = k+1;
+ j = j+1;
+ end
+ sorted(j) = right(i);
+ sorted(j+1:(j+length(left(k:end)))) = left(k:end);
+ j = j+1;
+ end
+ end
+
+end
+
```
-python temp = None def merge (arr, esquerda, direita): temp global, inversões mid = (esquerda + direita) // 2 para eu na faixa (esquerda, direita + 1): temp \[i\] = arr \[i\]
+### Implementação em Java
+```Java
+class MergeSort
+{
+ void merge(int arr[], int l, int m, int r)
+ {
+ int n1 = m - l + 1;
+ int n2 = r - m;
+ int L[] = new int [n1];
+ int R[] = new int [n2];
+ for (int i=0; iMerge Sort algorithm - MyCodeSchool
- while L <= mid:
- arr[k] = temp[L]
- L += 1
- k += 1
-
- while R <= right:
- arr[k] = temp[R]
- R += 1
- k += 1
-```
-
-def merge\_sort (arr, esquerda, direita): se saiu> = certo: Retorna
-```
-mid = (left + right) // 2
- merge_sort(arr, left, mid)
- merge_sort(arr, mid + 1, right)
- merge(arr, left, right)
-```
-
-arr = \[1,6,3,1,8,4,2,9,3\] temp = \[Nenhum para \_ no intervalo (len (arr))\] merge\_sort (arr, 0, len (arr) - 1) imprimir (arr, inversões) \`\` \`
\ No newline at end of file
+ ### Outros recursos:
+ * Wikipedia
+ * GeeksForGeeks
+ * Merge Sort - CS50