Cleo Aguiar
committed by
Randell Dawson
Randell Dawson
parent
940d3d1667
commit
a9fabc4755
@ -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:
|
||||
* <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>
|
||||
|
||||
|
||||
### Relavant videos on freeCodeCamp YouTube channel
|
||||
* <a href='https://youtu.be/TzeBrDU-JaY'>Merge Sort algorithm - MyCodeSchool</a>
|
||||
|
||||
### Other Resources:
|
||||
* <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>
|
||||
|
||||
### 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\] <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];
|
||||
|
||||
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])
|
||||
### 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;
|
||||
|
||||
|
||||
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<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);
|
||||
mergeSort(arr, m+1, r);
|
||||
|
||||
merge(arr, l, m, r);
|
||||
}
|
||||
```
|
||||
### Exemplo 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);
|
||||
}
|
||||
|
||||
} 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");
|
||||
printArray(arr, arr_size);
|
||||
|
||||
mergeSort(arr, 0, arr_size - 1);
|
||||
|
||||
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
|
||||
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);
|
||||
}
|
||||
}
|
||||
```
|
||||
k, L, R = left, left, mid + 1
|
||||
while L <= mid and R <= right:
|
||||
if temp[L] <= temp[R]:
|
||||
arr[k] = temp[L]
|
||||
L += 1
|
||||
else:
|
||||
arr[k] = temp[R]
|
||||
R += 1
|
||||
k += 1
|
||||
|
||||
### Vídeos relevantes no canal do YouTube freeCodeCamp
|
||||
* <a href='https://youtu.be/TzeBrDU-JaY'>Merge Sort algorithm - MyCodeSchool</a>
|
||||
|
||||
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) \`\` \`
|
||||
### 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>
|
||||
|
||||
Reference in New Issue
Block a user