gaspersic/freeCodeCamp
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

update translation merge-sort (#36486)

Browse Source 
added implementation code
This commit is contained in:
Cleo Aguiar
2019-08-07 21:02:25 -03:00
committed by Randell Dawson
parent 940d3d1667
commit a9fabc4755
1 changed files with 466 additions and 138 deletions
Download Patch File Download Diff File Expand all files Collapse all files

474
guide/portuguese/algorithms/sorting-algorithms/merge-sort/index.md
View File

@ -38,48 +38,61 @@ 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) ![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.cs.usfca.edu/~galles/visualization/ComparisonSort.html'>USFCA</a>
* <a href='https://www.hackerearth.com/practice/algorithms/sorting/merge-sort/visualize/'>HackerEarth</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; }
console.log (mergeSort (list)) // \[3, 4, 8, 15, 16, 23, 42\]
```
### Implementation in C
```
C
# incluir
# 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]; int L[n1], R[n2];
for (i = 0; i < n1; i++) for (i = 0; i < n1; i++)
@ -118,22 +131,33 @@ int L[n1], R[n2];
j++; j++;
k++; k++;
} }
```
} }
void mergeSort (int arr \[\], int l, int r) { if (l <r) { void mergeSort(int arr[], int l, int r)
int m = l + (rl) / 2; {
``` if (l < r)
{
int m = l+(r-l)/2;
mergeSort(arr, l, m); mergeSort(arr, l, m);
mergeSort(arr, m+1, r); mergeSort(arr, m+1, r);
merge(arr, l, m, 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]);
} 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\]);
```
printf("Given array is \n"); printf("Given array is \n");
printArray(arr, arr_size); printArray(arr, arr_size);
@ -144,15 +168,22 @@ printf("Given array is \n");
return 0; return 0;
``` ```
``` ### Implementação em C++
### Implementation in C++
Let us consider array A = {2,5,7,8,9,12,13} Vamos considerar o 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. 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++];
}
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) if(token_a<size_a)
{ {
while(token_a<size_a) while(token_a<size_a)
@ -163,42 +194,339 @@ c ++ void mergesort (int A \[\], int tamanho _a, int B \[\], int tamanho_ b, int
while(token_b<size_b) while(token_b<size_b)
C[token_c++]=B[token_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);
}
} }
``` ```
### Implementation in Python
```
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 Python
```
k, L, R = left, left, mid + 1 ```python
while L <= mid and R <= right: def merge(left,right,compare):
if temp[L] <= temp[R]: result = []
arr[k] = temp[L] i,j = 0,0
L += 1 while (i < len(left) and j < len(right)):
if compare(left[i],right[j]):
result.append(left[i])
i += 1
else: else:
arr[k] = temp[R] result.append(right[j])
R += 1 j += 1
k += 1 while (i < len(left)):
result.append(left[i])
i += 1
while (j < len(right)):
result.append(right[j])
j += 1
return result
while L <= mid: def merge_sort(arr, compare = lambda x, y: x < y):
arr[k] = temp[L] #Used lambda function to sort array in both(increasing and decresing) order.
L += 1 #By default it sorts array in increasing order
k += 1 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)
while R <= right: arr = [2,1,4,5,3]
arr[k] = temp[R] print(merge_sort(arr))
R += 1
k += 1
``` ```
def merge\_sort (arr, esquerda, direita): se saiu> = certo: Retorna ### 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]+" ");
}
}
``` ```
mid = (left + right) // 2 ### Exemplo em Java
merge_sort(arr, left, mid) ```java
merge_sort(arr, mid + 1, right) public class mergesort {
merge(arr, left, right) 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) {
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] + " ");
}
}
``` ```
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) \`\` \` ### 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
```
### 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; i<n1; ++i)
L[i] = arr[l + i];
for (int j=0; j<n2; ++j)
R[j] = arr[m + 1+ j];
int i = 0, j = 0;
int 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 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);
}
}
```
### Vídeos relevantes no canal do YouTube freeCodeCamp
* <a href='https://youtu.be/TzeBrDU-JaY'>Merge Sort algorithm - MyCodeSchool</a>
### 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>