update translation merge-sort (#36486)

added implementation code

guide/portuguese/algorithms/sorting-algorithms/merge-sort/index.md

@@ -38,167 +38,495 @@ MergeSort(arr[], left,  right):
  
  ![Merge Sort Algorithm](https://upload.wikimedia.org/wikipedia/commons/thumb/e/e6/Merge_sort_algorithm_diagram.svg/300px-Merge_sort_algorithm_diagram.svg.png) 
  
- ### Properties: 
+ ### Propriedades: 
- * Space Complexity: O(n) 
+ * Complexidade Espacial: 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. 
+ * 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. 
- * Sorting In Place: No in a typical implementation 
+ * Classificação no local: não em uma implementação típica 
- * Stable: Yes 
+ * Estável: Sim
- * Parallelizable :yes (Several parallel variants are discussed in the third edition of Cormen, Leiserson, Rivest, and Stein's Introduction to Algorithms.) 
+ * 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: 
  * <a href='https://www.cs.usfca.edu/~galles/visualization/ComparisonSort.html'>USFCA</a> 
  * <a href='https://www.hackerearth.com/practice/algorithms/sorting/merge-sort/visualize/'>HackerEarth</a> 
   
+ ### Implementação em JS
+```js
+const list = [23, 4, 42, 15, 16, 8, 3]
 
- ### Relavant videos on freeCodeCamp YouTube channel 
+const mergeSort = (list) =>{
- * <a href='https://youtu.be/TzeBrDU-JaY'>Merge Sort algorithm - MyCodeSchool</a> 
+  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));
+}
 
- ### Other Resources: 
+const merge = (left, right) => {
- * <a href='https://en.wikipedia.org/wiki/Merge_sort' target='_blank' rel='nofollow'>Wikipedia</a> 
+  var result = [];
- * <a href='www.geeksforgeeks.org/merge-sort' target='_blank' rel='nofollow'>GeeksForGeeks</a> 
+  while(left.length || right.length) {
- * <a href='https://youtu.be/sWtYJv_YXbo' target='_blank' rel='nofollow'>Merge Sort - CS50</a> 
+    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;
+}
 
- ### Implementaion in JS 
+console.log(mergeSort(list)) // [ 3, 4, 8, 15, 16, 23, 42 ]
 ```
 
-js lista const = \[23, 4, 42, 15, 16, 8, 3\]
+### Implementação em C 
+```C
+#include<stdlib.h> 
+#include<stdio.h>
+void merge(int arr[], int l, int m, int r) 
+{ 
+    int i, j, k; 
+    int n1 = m - l + 1; 
+    int n2 =  r - m; 
   
-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\] <direita \[0\]) { result.push (left.shift ()) } outro { result.push (right.shift ()) } } else if (left.length) { result.push (left.shift ()) } outro { result.push (right.shift ()) } } resultado de retorno; }
+    int L[n1], R[n2]; 
   
-console.log (mergeSort (list)) // \[3, 4, 8, 15, 16, 23, 42\]
+    for (i = 0; i < n1; i++) 
-```
+        L[i] = arr[l + i]; 
-### Implementation in C 
+    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++; 
+    } 
   
-C
     
-# incluir
+    while (i < n1) 
-
-# incluir
-
-mesclagem vazia (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++; 
+        k++; 
     } 
-    else 
+  
+    while (j < n2) 
     { 
         arr[k] = R[j]; 
         j++; 
+        k++; 
     } 
-    k++; 
+} 
- } 
+  
+void mergeSort(int arr[], int l, int r) 
+{ 
+    if (l < r) 
+    {  
+        int m = l+(r-l)/2; 
   
         
- while (i < n1) 
+        mergeSort(arr, l, m); 
- { 
+        mergeSort(arr, m+1, r); 
-    arr[k] = L[i]; 
-    i++; 
-    k++; 
- } 
   
- while (j < n2) 
+        merge(arr, l, m, r); 
- { 
+    } 
-    arr[k] = R[j]; 
+}
-    j++; 
+void printArray(int A[], int size) 
-    k++; 
+{ 
- } 
+    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<size_a && token_b<size_b; )
+     {
+          if(A[token_a]<=B[token_b])
+               C[token_c++]=A[token_a++];
+          else
+               C[token_c++]=B[token_b++];
+      }
+      
+      if(token_a<size_a)
+      {
+          while(token_a<size_a)
+               C[token_c++]=A[token_a++];
+      }
+      else
+      {
+          while(token_b<size_b)
+               C[token_c++]=B[token_b++];
+      }
+
+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++; 
+    } 
+    
+    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); 
+    } 
+} 
+```
+
+### Implementação em Python
+
+```python
+def merge(left,right,compare):
+	result = [] 
+	i,j = 0,0
+	while (i < len(left) and j < len(right)):
+		if compare(left[i],right[j]):
+			result.append(left[i])
+			i += 1
+		else:
+			result.append(right[j])
+			j += 1
+	while (i < len(left)):
+		result.append(left[i])
+		i += 1
+	while (j < len(right)):
+		result.append(right[j])
+		j += 1
+	return result
+
+def merge_sort(arr, compare = lambda x, y: x < y):
+     #Used lambda function to sort array in both(increasing and decresing) order.
+     #By default it sorts array in increasing order
+	if len(arr) < 2:
+		return arr[:]
+	else:
+		middle = len(arr) // 2
+		left = merge_sort(arr[:middle], compare)
+		right = merge_sort(arr[middle:], compare)
+		return merge(left, right, compare) 
+
+arr = [2,1,4,5,3]
+print(merge_sort(arr))
+```
+
+### Implementação em Java
+```java
+public class mergesort {
+
+	public static int[] mergesort(int[] arr,int lo,int hi) {
+		
+		if(lo==hi) {
+			int[] ba=new int[1];
+			ba[0]=arr[lo];
+			return ba;
+		}
+		
+		int mid=(lo+hi)/2;
+		int arr1[]=mergesort(arr,lo,mid);
+		int arr2[]=mergesort(arr,mid+1,hi);
+		return merge(arr1,arr2);
+	}
+	
+	public static int[] merge(int[] arr1,int[] arr2) {
+		int i=0,j=0,k=0;
+		int n=arr1.length;
+		int m=arr2.length;
+		int[] arr3=new int[m+n];
+		while(i<n && j<m) {
+			if(arr1[i]<arr2[j]) {
+				arr3[k]=arr1[i];
+				i++;
+			}
+			else {
+				arr3[k]=arr2[j];
+				j++;
+			}
+			k++;
+		}
+		
+		while(i<n) {
+			arr3[k]=arr1[i];
+			i++;
+			k++;
+		}
+		
+		while(j<m) {
+			arr3[k]=arr2[j];
+			j++;
+			k++;
+		}
+		
+		return arr3;
+		
+	}
+	
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+		int arr[]= {2,9,8,3,6,4,10,7};
+		int[] so=mergesort(arr,0,arr.length-1);
+		for(int i=0;i<arr.length;i++)
+			System.out.print(so[i]+" ");
+	}
+
 }
 
-void mergeSort (int arr \[\], int l, int r) { if (l <r) {  
-int m = l + (rl) / 2;
 ```
-    mergeSort(arr, l, m); 
+### Exemplo em Java
-    mergeSort(arr, m+1, r); 
+```java
- 
+public class mergesort {
-    merge(arr, l, m, r); 
+  public static int[] mergesort(int[] arr, int lo, int hi) {
- } 
+    if (lo == hi) {
-```
+      int[] ba = new int[1];
-
+      ba[0] = arr[lo];
-} void printArray (int A \[\], tamanho int) { int i; para (i = 0; i <tamanho; 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\]);
+      return ba;
-```
+    }
-printf("Given array is \n"); 
+    int mid = (lo + hi) / 2;
- printArray(arr, arr_size); 
+    int arr1[] = mergesort(arr, lo, mid);
- 
+    int arr2[] = mergesort(arr, mid + 1, hi);
- mergeSort(arr, 0, arr_size - 1); 
+    return merge(arr1, arr2);
- 
- printf("\nSorted array is \n"); 
- printArray(arr, arr_size); 
- return 0; 
-```
-
-```
-### Implementation in C++ 
- 
- Let us consider array A = {2,5,7,8,9,12,13} 
- and array B = {3,5,6,9,15} and we want array C to be in ascending order as well. 
-```
-
-c ++ void mergesort (int A \[\], int tamanho _a, int B \[\], int tamanho_ b, int C \[\]) { token int _, token_ b, token _c; para (token_ a = 0, token _b = 0, token_ c = 0; token _a_ _um && token _b__ __b; ) { if (A \[token _a\] <= B \[token_ b\]) C \[token _c ++\] = A \[token_ um ++\]; outro C \[token _c ++\] = B \[token_ b ++\]; }__
-```
-  if(token_a<size_a) 
-  { 
-      while(token_a<size_a) 
-           C[token_c++]=A[token_a++]; 
   }
-  else 
-  { 
-      while(token_b<size_b) 
-           C[token_c++]=B[token_b++]; 
-  } 
-```
 
+  public static int[] merge(int[] arr1, int[] arr2) {
+    int i = 0, j = 0, k = 0;
+    int n = arr1.length;
+    int m = arr2.length;
+    int[] arr3 = new int[m + n];
+    while (i < n && j < m) {
+      if (arr1[i] < arr2[j]) {
+        arr3[k] = arr1[i];
+        i++;
+      } else {
+        arr3[k] = arr2[j];
+        j++;
+      }
+      k++;
+    }
+    while (i < n) {
+      arr3[k] = arr1[i];
+      i++;
+      k++;
+    }
+    while (j < m) {
+      arr3[k] = arr2[j];
+      j++;
+      k++;
+    }
+    return arr3;
+  }
+
+  public static void main(String[] args) {
+    int arr[] = {2, 9, 8, 3, 6, 4, 10, 7};
+    int[] so = mergesort(arr, 0, arr.length - 1);
+    for (int i = 0; i < arr.length; i++)
+      System.out.print(so[i] + " ");
+  }
 }
 ```
-### Implementation in Python 
+
+### Implementação em MATLAB
+```matlab
+
+a = [9,4,7,3,8,5,1,6,2];
+
+[sorted] = mergeSort(a);
+
+function [sorted] = mergeSort(unsorted)
+    len = length(unsorted);
+    if len == 1
+        sorted = unsorted;
+        return;
+    end
+    mid = ceil((len)/2);
+    left = mergeSort(unsorted(1:mid));
+    right = mergeSort(unsorted(mid+1:end));
+    
+    sorted = mergeLR(left, right);
+       
+end
+
+function [sorted] = mergeLR(left, right)
+    sorted = [left right];                              % add two splited array together
+    j = 1;                                              % index for 'sorted'
+    k = 1;                                              % index for 'left'
+    for i = 1:1:length(right)
+        % going through every element of the 'right'
+        if right(i) < left(k)
+            sorted(j) = right(i);                       % move the 'right' element before 
+            sorted(j+1:(j+length(left(k:end)))) = left(k:end);      % shift the left elemts 
+            j = j+1;
+        else
+            while (k <= length(left)) && (right(i) > 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
-k, L, R = left, left, mid + 1 
+class MergeSort 
- while L <= mid and R <= right: 
+{
-    if temp[L] <= temp[R]: 
+    void merge(int arr[], int l, int m, int r) 
-        arr[k] = temp[L] 
+    {
-        L += 1 
+        int n1 = m - l + 1; 
-    else: 
+        int n2 = r - m; 
-        arr[k] = temp[R] 
+        int L[] = new int [n1]; 
-        R += 1 
+        int R[] = new int [n2];
-    k += 1 
+        for (int i=0; i<n1; ++i) 
- 
+            L[i] = arr[l + i]; 
- while L <= mid: 
+        for (int j=0; j<n2; ++j) 
-    arr[k] = temp[L] 
+            R[j] = arr[m + 1+ j]; 
-    L += 1 
+        int i = 0, j = 0; 
-    k += 1 
+        int k = l; 
- 
+        while (i < n1 && j < n2) 
- while R <= right: 
+        { 
-    arr[k] = temp[R] 
+            if (L[i] <= R[j]) 
-    R += 1 
+            { 
-    k += 1 
+                arr[k] = L[i]; 
+                i++; 
+            } 
+            else
+            { 
+                arr[k] = R[j]; 
+                j++; 
+            } 
+            k++; 
+        } 
+        while (i < n1) 
+        { 
+            arr[k] = L[i]; 
+            i++; 
+            k++; 
+        } 
+        while (j < n2) 
+        { 
+            arr[k] = R[j]; 
+            j++; 
+            k++; 
+        } 
+    } 
+    void sort(int arr[], int l, int r) 
+    { 
+        if (l < r) 
+        {
+            int m = (l+r)/2;
+            sort(arr, l, m); 
+            sort(arr , m+1, r); 
+            merge(arr, l, m, r); 
+        } 
+    } 
+    static void printArray(int arr[]) 
+    { 
+        int n = arr.length; 
+        for (int i=0; i<n; ++i) 
+            System.out.print(arr[i] + " "); 
+        System.out.println(); 
+    }
+    public static void main(String args[]) 
+    { 
+        int arr[] = {12, 11, 13, 5, 6, 7}; 
+        System.out.println("Given Array"); 
+        printArray(arr); 
+        MergeSort ob = new MergeSort(); 
+        ob.sort(arr, 0, arr.length-1);
+        System.out.println("\n The Sorted array is : "); 
+        printArray(arr); 
+    } 
+}
 ```
 
-def merge\_sort (arr, esquerda, direita): se saiu> = certo: Retorna
+ ### Vídeos relevantes no canal do YouTube freeCodeCamp
-```
+ * <a href='https://youtu.be/TzeBrDU-JaY'>Merge Sort algorithm - MyCodeSchool</a>
-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) \`\` \`
+ ### Outros recursos:
+ * <a href='https://en.wikipedia.org/wiki/Merge_sort' target='_blank' rel='nofollow'>Wikipedia</a>
+ * <a href='www.geeksforgeeks.org/merge-sort' target='_blank' rel='nofollow'>GeeksForGeeks</a>
+ * <a href='https://youtu.be/sWtYJv_YXbo' target='_blank' rel='nofollow'>Merge Sort - CS50</a>