From 2725a15beb9f4e3c2c579bc0462070fa06b7fc97 Mon Sep 17 00:00:00 2001 From: Cleo Aguiar Date: Wed, 7 Aug 2019 21:02:58 -0300 Subject: [PATCH] update translation quick-sort (#36498) added implementation code --- .../sorting-algorithms/quick-sort/index.md | 119 +++++++++++++++++- 1 file changed, 114 insertions(+), 5 deletions(-) diff --git a/guide/portuguese/algorithms/sorting-algorithms/quick-sort/index.md b/guide/portuguese/algorithms/sorting-algorithms/quick-sort/index.md index 827425cf61..fec82e3663 100644 --- a/guide/portuguese/algorithms/sorting-algorithms/quick-sort/index.md +++ b/guide/portuguese/algorithms/sorting-algorithms/quick-sort/index.md @@ -4,7 +4,7 @@ localeTitle: Ordenação rápida --- ## Ordenação rápida -A classificação rápida é um eficiente algoritmo de divisão e conquista de classificação. A complexidade média de tempo de caso de Classificação Rápida é O (nlog (n)), com complexidade de tempo de pior caso sendo O (n ^ 2). +A Ordenação rápida é um eficiente algoritmo de divisão e conquista de classificação. A complexidade média de tempo de caso de ordenação Rápida é O (nlog (n)), com complexidade de tempo de pior caso sendo O (n^2) dependendo da seleção do elemento dinâmico, que divide a matriz atual em duas sub-matrizes. Por exemplo, a complexidade de tempo do Quick Sort é aproximadamente O (nlog (n)) quando a seleção do pivô divide o array original em dois sub-arrays de tamanho quase igual. Por outro lado, se o algoritmo, que seleciona o elemento pivot das matrizes de entrada, gerar consistentemente 2 sub-matrizes com uma grande diferença em termos de tamanhos de matrizes, o algoritmo de ordenação rápida pode alcançar a complexidade de tempo de pior caso de O (n^2). As etapas envolvidas no Quick Sort são: @@ -12,7 +12,9 @@ As etapas envolvidas no Quick Sort são: * Particionamento: classifica o array de tal maneira que todos os elementos menores que o pivô estão à esquerda, e todos os elementos maiores que o pivô estão à direita. * Chame o Quicksort recursivamente, levando em consideração o pivô anterior para subdividir corretamente as matrizes esquerda e direita. (Uma explicação mais detalhada pode ser encontrada nos comentários abaixo) -Uma implementação rápida em JavaScript: +## Exemplo de implementações em vários linguagens + +### Implementação em JavaScript: ```javascript const arr = [6, 2, 5, 3, 8, 7, 1, 4] @@ -75,7 +77,7 @@ const arr = [6, 2, 5, 3, 8, 7, 1, 4] console.log(arr) ``` -Uma implementação de classificação rápida em C +### Implementação em C ```C #include @@ -133,7 +135,112 @@ Uma implementação de classificação rápida em C } ``` -A complexidade espacial da ordenação rápida é O (n). Isso é uma melhoria em relação a outros algoritmos de ordenação de divisão e conquista, que ocupam o espaço O (nlong (n)). A classificação rápida consegue isso alterando a ordem dos elementos dentro da matriz especificada. Compare isso com o algoritmo de [classificação de mesclagem](https://guide.freecodecamp.org/algorithms/sorting-algorithms/merge-sort) que cria 2 matrizes, cada comprimento n / 2, em cada chamada de função. +### Implementação no Python3 +```python +import random + +z=[random.randint(0,100) for i in range(0,20)] + +def quicksort(z): + if(len(z)>1): + piv=int(len(z)/2) + val=z[piv] + lft=[i for i in z if ival] + + res=quicksort(lft)+mid+quicksort(rgt) + return res + else: + return z + +ans1=quicksort(z) +print(ans1) + +``` + +### Implementação no MATLAB +```matlab +a = [9,4,7,3,8,5,1,6,2]; + +sorted = quicksort(a,1,length(a)); + +function [unsorted] = quicksort(unsorted, low, high) + if low < high + [pInd, unsorted] = partition(unsorted, low, high); + unsorted = quicksort(unsorted, low, pInd-1); + unsorted = quicksort(unsorted, pInd+1, high); + end + +end + +function [pInd, unsorted] = partition(unsorted, low, high) + i = low-1; + for j = low:1:high-1 + if unsorted(j) <= unsorted(high) + i = i+1; + unsorted([i,j]) = unsorted([j,i]); + + end + end + unsorted([i+1,high]) = unsorted([high,i+1]); + pInd = i+1; + +end + +``` + +### Implementação em Java + +```java +public class Quicksort { + + static void quickSort(int[] array, int p, int r) { + if (p < r) { + int q = partition(array, p, r); + quickSort(array, p, q - 1); + quickSort(array, q + 1, r); + } + } + + static int partition(int[] array, int p, int r) { + // using the last element as the pivot + int pivot = array[r]; + int i = p - 1; + for (int j = p; j <= r - 1; j++) { + if (array[j] <= pivot) { + i++; + int temp = array[i]; + array[i] = array[j]; + array[j] = temp; + } + } + int temp = array[i + 1]; + array[i + 1] = array[r]; + array[r] = temp; + return i + 1; + } + + public static void main(String[] args) { + int [] array = {2,8,7,1,3,5,6,4}; + quickSort(array, 0, 7); + for (int i : array) + System.out.print(i + " "); + } +} + +``` + +A complexidade espacial da ordenação rápida é `O(n)`. Isso é uma melhoria em relação a outros algoritmos de ordenação de divisão e conquista, que ocupam o espaço `O(nlong(n))`. A Ordenação rápida consegue isso alterando a ordem dos elementos dentro da matriz especificada. Compare isso com o algoritmo de [classificação de mesclagem](https://guide.freecodecamp.org/algorithms/sorting-algorithms/merge-sort) que cria 2 matrizes, cada comprimento `n/2`, em cada chamada de função. +No entanto, existe o problema deste algoritmo de ordenação ser do tempo `O(n*n)` se o pivô é sempre mantido no meio. Isso pode ser superado utilizando um pivô aleatório + +## Complexity + +| Nome | Melhor | Média | Pior | Memória | Estável | Comentários | +| --------------------- | :-------------: | :-----------------: | :-----------------: | :-------: | :-------: | :---------- | +| **Ordenação rápida** | n log(n) | n log(n) | n2 | log(n) | Não | A Ordenação rápida geralmente é feito no local com o espaço da pilha O(log(n)) | + +A complexidade espacial da ordenação rápida é O(n). Isso é uma melhoria em relação a outros algoritmos de ordenação de divisão e conquista, que ocupam espaço O(n log(n)). #### Mais Informações: @@ -143,4 +250,6 @@ A complexidade espacial da ordenação rápida é O (n). Isso é uma melhoria em * [Youtube: Uma explicação visual do Quicksort](https://www.youtube.com/watch?v=MZaf_9IZCrc) -* [Youtube: Gayle Laakmann McDowell (autor de Cracking The Coding Interview) explica os fundamentos do quicksort e mostra algumas implementações](https://www.youtube.com/watch?v=SLauY6PpjW4) \ No newline at end of file +* [Youtube: Gayle Laakmann McDowell (autor de Cracking The Coding Interview) explica os fundamentos do quicksort e mostra algumas implementações](https://www.youtube.com/watch?v=SLauY6PpjW4) + +* [Quick Sort - MyCodeSchool](https://www.youtube.com/watch?v=COk73cpQbFQ)