Monica Alexandra Chavez Llancay
Company_adminFernando Gabriel
gracias!
Efraín Hernández García
Gracias Monica me ahorraste mucho tiempo!
Monica Alexandra Chavez Llancay
Company_adminFernando Gabriel
gracias!
Efraín Hernández García
Gracias Monica me ahorraste mucho tiempo!
Código en C
#include <stdio.h> int partition(int arr[], int low, int high) { int i = low - 1; int pivot = arr[high]; int temp; for(int j = low; j < high; j++) { if(arr[j] <= pivot) { i = i + 1; temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } } temp = arr[i + 1]; arr[i + 1] = arr[high]; arr[high] = temp; return (i + 1); } void quickSort(int arr[], int low, int high) { if(low < high) { int pi = partition(arr, low, high); quickSort(arr, low, pi - 1); quickSort(arr, pi + 1, high); } } int main() { int arr[] = {1992, 1990, 10, 5, 6, 100, 0, 1, -10}; int n = sizeof(arr) / sizeof(int); quickSort(arr, 0, n - 1); for(int i = 0; i < n; i++) printf("%d ", arr[i]); return 0; }
Michael Ballesteros
Leisy Karina Algarra Fernandez
Nicolas Esteban Prieto Sarmiento
Miguel Ángel Baquero Tello
Efrain Pineda Jaimes
Romel Ocampo Hernandez
https://www.youtube.com/watch?v=kFeXwkgnQ9U
me parecio mas claro todo con este video :)
Luis Eduardo Quiroga Esparza
Por qué en la particion ponemos el pivote como el valor de high "pivot=arr[high]" en vez de poner el numero de en medio?
Claudia Johana Herrera Torres
Company_adminRicardo Celis
Profesorexcelente implementación! un main limpio y todas las funciones aparte, Gran trabajo Clao!
Claudia Johana Herrera Torres
Company_adminMuchas gracias 😄 este es el resultado de estudiar con los mejores profesores, con Platzi he logrado aprender muchas cosas en muy poco tiempo.
Hernán Giraldo
Luis Davaria
Andres David Peña Velandia
Mauricio Rodriguez Romero
Hola Amig@s
Cual es la mejor forma de hacer la prueba de escritorio?
Mil gracias
Diego Antonio Gomez Diaz
Adolfo Arreaga
Excelente trabajo!
Jackeline Maria Hernandez Maurera
Jesús Petrona Castro
Emmanuel Guerra Sánchez
Carlos Isaac Rosales Castellanos
Sebastian Castañeda Garcia
Lo mejor para poder entender el código es comentarlo linea a linea, como si depuraras, si a alguien se le hizo difícil entenderlo. Se los dejo comentado :D
#necesitamos dividir nuestro data set #necesitamos el punto pivotal #recursivamente ordenar cada mitad de mi array def partition(arr, low, high): #creamos la particion del array i = (low-1) # i va a tomar el valor del indice mas bajo low-1 pivot = arr[high] #valor medio de los datos, que separa los datos altos y bajos | dividimos el data set for j in range(low,high): #recorrer todo el rango de indices de low a high if arr[j] <= pivot: #de un lado se ponen todos los valores menores al pivot i = i+1 arr[i], arr[j] = arr[j], arr[i] arr[i+1], arr[high] = arr[high], arr[i+1] #de otro lado se ponen los valores mayores al pivot return (i+1) def quickSort(arr, low, high): #creamos la funcion del quick sort if low < high: pi = partition(arr, low, high) #llamamos a la funcion partition quickSort(arr, low, pi-1) #recursivamente usamos quicksort del low a la mitad(pi-1) quickSort(arr, pi+1, high) #recursivamente usamos quicksort en la otra mitad del (pi+1) al high arr = [1991, 1990, 10, 5, 6, 0, 1, -10] n = len (arr) #len nos da el tamaño del arreglo n=8 quickSort(arr, 0, n-1) #ejecutamos quickSort (arr, 0, 7) print("Array Ordenado:") #imprimimos el arreglo for i in range (n): print("%d" %arr[i]),
really hard to get it. Did it at the end but, as and advice, You sohuld give bit more info about how ir works, befor jumping into the code that fast. Thanks any way, helped me to understand couple of things related with variables and arrays.
code in java:
import java.util.Arrays; import java.util.Scanner; public class QuickSort { public static void main(String[] args) { Scanner in = new Scanner(System.in); System.out.println("Please instert the size of your array: "); int n = in.nextInt(); int[] arr = new int[n]; for (int i=0; i < n; i++){ System.out.println("Please insert the value No. " + i); arr[i]=in.nextInt(); } quickSort(arr, 0, arr.length-1); System.out.println("El array ordenado es: "+ Arrays.toString(arr)); } static int particionar(int[] arr, int low, int high ){ int i = low -1; int pivot = arr[high]; int tempVal; for(int j = low; j < high; j++){ if(arr[j] <= pivot){ i=i+1; //arr[i], arr[j] = arr[j], arr[i]; int temp = arr[i]; arr[i]=arr[j]; arr[j]=temp; } } tempVal = arr[i+1]; arr[i+1] = arr[high]; arr[high] = tempVal; return (i+1); } static void quickSort(int[] arr, int low, int high){ if(low < high){ int pi = particionar(arr, low, high); quickSort(arr, low, pi-1); quickSort(arr, pi+1, high); } } }```
solución JS :D
implemente una función que cambia de posición
function particion(arr,low,high){ function changePosition(arr,n1,n2){ //intercambian posiciones let temp = arr[n1]; arr[n1] = arr[n2]; arr[n2] = temp; } let i=low-1; let pivot=arr[high]; for(let j = low;j < high;j++){ if(arr[j] <= pivot){ i = i+1; changePosition(arr,j ,i); } } changePosition(arr,high,i + 1) return i+1 } function quickSort(arr,low,high){ if(low < high){ var pi = particion(arr,low,high); quickSort(arr,low,pi-1); quickSort(arr,pi+1,high); } } let arr = [7,1,3,4,1]; let n = arr.length; quickSort(arr,0,n-1); console.table(arr); //Node.js
Aquí les comparto mi aporte con Java Script:
function partition(arr, low, high) { var i = (low - 1); var pivot = arr[high]; var temp; for (let j = low; j < high; j++) { if (arr[j] <= pivot) { i++; temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } } temp = arr[i + 1]; arr[i + 1] = arr[high]; arr[high] = temp; return (i + 1); } function quickSort(arr, low, high) { if (low < high) { pi = partition(arr, low, high); quickSort(arr, low, pi -1); quickSort(arr, pi + 1, high); } } var arr = [1992, 1990, 10, 5, 6, 100, 0, 1, -10]; var n = arr.length; quickSort(arr, 0, n - 1); console.log("Array ordenado:"); arr.forEach(element => { console.log(element); });
En JavaScript
const quickSort = array => { let left = []; let right = []; let pivot = array[0]; //caso base if (array.length < 1) { return []; } // Division for (let i = 1; i < array.length; i++) { if (array[i] < pivot) { left.push(array[i]); }else { right.push(array[i]); } } return [].concat(quickSort(left), pivot, quickSort(right)); } let vector = Array.from({length: 100}, () => Math.floor(Math.random() * 200)); console.log(`El array generado es: ${vector}`); let vectorOrdenado = quickSort(vector); console.log(`El array ordenado queda: ${vectorOrdenado}`);```
Implementacion de quickSort con C
#include<stdio.h> int print_array(int arr[], int n) { int i; for(i=0; i < n; i++) printf("%d ,", arr[i]); printf("\n Fin del ordenamiento"); } void cambiar_posicion(int *n1, int *n2) //Funcion para cambiar la posicion de los elementos desordenados { int temp =*n1;//Variable temporal que almacena un dato mientras hacemos el cambio *n1 = *n2; *n2 = temp; } int particion (int arr[], int low, int high) //Funcion para particionar el array { int i = (low - 1); //Indice del elemento mas pequeño int pivot = arr[high]; //Pivot for (int j = low; j <= high- 1; j++) { if (arr[j] <= pivot) //Si el elemento actual es menor o igual a pivote { i++; cambiar_posicion(&arr[i], &arr[j]); } } cambiar_posicion(&arr[i + 1], &arr[high]); return (i + 1); } void quickSort(int arr[], int low, int high) //Funcion de ordenamiento { if (low < high) { int pi = particion(arr, low, high); //pi es el indice de particionamiento quickSort(arr, low, pi - 1); //Organiza los elementos antes de la particion quickSort(arr, pi + 1, high); //Organiza los elementos de despues de la particion } } void printArray(int arr[], int n) //Funcion para imprimir el array { int i; for (i=0; i < n; i++) printf("%d ", arr[i]); printf("\n Fin del ordenamiento"); } int main(int argc, char const *argv[]) //Funcion principal { int arr[] = {1992, 1990, 10, 5, 6, 100, 0, 1, -10}; int n = sizeof(arr)/sizeof(arr[0]); //sizeof es una funcion que da el tamaño de bites de lo que necesitemos quickSort(arr, 0, n-1); printf("El array ordenado: \n"); printArray(arr, n); printf("\n"); return 0; }
Hola, comparto mi implementación en javascript(typescript):
const partition = (arr: number[], low: number, hi: number) => { const pivot = arr[low]; let i = low; let j = hi; while (i < j) { do { i++; } while (arr[i] <= pivot); do { j--; } while (arr[j] > pivot); if (i < j) { swap(arr, i, j); } } swap(arr, low, j); return j; } const swap = (arr, i: number, j: number) => { [arr[i], arr[j]] = [arr[j], arr[i]]; } const quickSort = (arr: number[], low: number, hi: number) => { if (low < hi) { let j = partition(arr, low, hi); quickSort(arr, low, j); quickSort(arr, j+1, hi); } return arr; }
QuickSort con JavasCript :D
const c = console.log const particion = (arrayInteger, lower, higher) =>{ let i, pivot, accountA, accountB i = ( lower - 1 ) pivot = arrayInteger[higher] for (let j = lower; j < higher; j++) { if (arrayInteger[j] <= pivot){ i = i + 1 accountA = arrayInteger[i] arrayInteger[i] = arrayInteger[j] arrayInteger[j] = accountA } } accountB = arrayInteger[i+1] arrayInteger[i+1] = arrayInteger[higher] arrayInteger[higher] = accountB return (i+1) } const quickSort = (arrayInteger, lower, higher) => { let pi if (lower < higher){ pi = particion(arrayInteger, lower, higher) quickSort(arrayInteger, lower, pi-1) quickSort(arrayInteger, pi+1, higher) } } const arr = [1998, 1990, 10, 5, 6, 0, 1, -10, 3] const n = arr.length quickSort(arr, 0 , n-1) c("Arreglo Ordenado: ") arr.forEach(element => { c(`${element}`) })
En Python, QuickSort sin complicarse tanto como el profe:
def ordenar(not_ordened_list): if len(not_ordened_list) == 0: return [] elif len(not_ordened_list) ==1: return not_ordened_list left = [] right = [] equals = [] pivote = not_ordened_list[0] for n in not_ordened_list[1:]: if pivote > n: left.append(n) elif pivote < n: right.append(n) elif pivote == n: equals.append(n) return ordenar(left) + [pivote] + equals + ordenar(right) def run(): not_ordened_list = [ 3, 94, 86, 82, 90, 10, 87, 36, 61, 8, 17, 15, 22, 10, 23, 78, 25, 2, 30, 45, 98, 43, 98, 59, 53, 57, 2, 64, 1, 41, 32, 58, 19, 99, 60, 74, 48, 80, 44, 25, 68, 1, 89, 77, 60, 25, 99, 30, 76, 32, 57, 82, 52, 44, 72, 87, 34, 87, 65, 30, 54, 6, 31, 33, 44, 44, 42, 82, 90, 17, 9, 98, 28, 86, 69, 3, 17, 8, 45, 98, 12, 47, 95, 43, 72, 39, 41, 82, 74, 56, 65, 79, 50, 26, 67, 100, 24, 67, 38, 57] print('LISTA NO ORDENADA') print(not_ordened_list) ordened_list = ordenar(not_ordened_list) print('\nLISTA ORDENADA') print(ordened_list) if __name__ == '__main__': run()```
¡Hola! Les comparto la implementación con C# con ordenamiento asc y desc:
Código fuente
using System; namespace QuickSort { public class QuickSort { public void Sort(ref int[] target, int order = 1) { Sort(ref target, order, 0, target.Length - 1); } private void Sort(ref int[] target, int order, int min, int max) { if (min < max) { int pi = Partition(ref target, order, min, max); Sort(ref target, order, min, pi - 1); Sort(ref target, order, pi + 1, max); } } private int Partition(ref int[] target, int order, int min, int max) { bool right = true, asc = order == 1; int pi = min, index = max, piv, prevIndex; while (pi != index) { if ((right != asc && target[pi] < target[index]) || (right == asc && target[pi] > target[index])) { prevIndex = index; piv = target[pi]; target[pi] = target[index]; target[index] = piv; index = pi; pi = prevIndex; right = !right; } else { if (right) index--; else index++; } } return pi; } } }
Mi aporte en php
<?php #necesitamos dividir nuestro dataset #necesitamos un punto pivoltal #recursivamente ordenar cada mitad de mi array class quickSortClass{ public $arr = array(); public $n; public function main(){ $this->arr = [1992, 1990, 10, 5, 6, 100, 0, 1, -10]; $this->n = count($this->arr); $this->quickSort(0, $this->n-1); echo("Arrar Ordenado: "); foreach($this->arr as $item){ echo($item.', '); } } public function particion($low, $high){ $i =$low-1; $pivot = $this->arr[$high]; for($j=$low; $j<$high; $j++){ if($this->arr[$j]<= $pivot){ $i = $i+1; $aux = $this->arr[$i]; $this->arr[$i] = $this->arr[$j]; $this->arr[$j] = $aux; } } $aux = $this->arr[$i+1]; $this->arr[$i+1] = $this->arr[$high]; $this->arr[$high] = $aux; return ($i+1); } function quickSort($low, $high){ if($low < $high){ $pi = $this->particion($low, $high); $this->quickSort($low, $pi-1); $this->quickSort($pi+1, $high); }; } } $obj = new quickSortClass(); $obj->main();
Mi aporte en javascript
function quickSort(array,origin,limit){ if(array.length > 1){ var pivote = array[limit]; var i = origin, j = limit; while(i <= j){ while(i <= limit && array[i] < pivote){ i++; } while(j >=0 && array[j] > pivote){ j--; } if(i <= j){ change(array,i,j) i++; j--; } } if(j > origin){ quickSort(array,origin,j); } if(i < limit){ quickSort(array,i,limit); } } } function change(data,starPosition,finalPosition){ var tempValue = data[finalPosition]; data[finalPosition] = data[starPosition]; data[starPosition] = tempValue; } var vector = [-6688,5904,4735,-2940,8830,9976,-3674,4222,-1446,6187, -3181,-8882,5487,-6939,-7885,3786,-6234,-1062,-4553,-5709,8459,5008,3352,6586,537,-7610,3261, 8246,-2105,5107,7957,-7886,-2925,-2541,-7449,9521,5073,-239,-8054,-4379,-8323,-6485,-4828, -5294,-2720,595]; quickSort(vector,0,vector.length-1); console.log(vector);
Kotlin:
/* * Necesitamos dividir nuestro dataset * Necesitamos un punto pivotal * Recursivamente ordenar cada mitad de mi array * */ fun main(args: Array<String>) { val list = mutableListOf(1992, 1990, 10, 5, 6, 100, 0, 1, -10) quickSort(list, 0, list.size - 1) println("Ordenado: ") list.map { print("$it ") } } fun particion(v: MutableList<Int>, low: Int, high: Int) : Int{ var i = (low-1) val pivot = v[high] for (j in low until high){ if(v[j] <= pivot){ i++ val temp = v[i] v[i] = v[j] v[j] = temp } } val aux = v[i+1] v[i+1] = v[high] v[high] = aux return (i+1) } fun quickSort(v: MutableList<Int>, low: Int, high: Int){ if(low < high){ val partitionIndex = particion(v, low, high) quickSort(v, low, partitionIndex-1) quickSort(v, partitionIndex +1, high) } }
Buenas a todos, aquí está el código en C, con unas funciones extra para facilitar el trabajo, cuales son swap para realizar el intercambio entre valores de variables y print para imprimir el array resultante.
#include <stdio.h> void swap(int *n1, int *n2) { int temp = *n1; *n1 = *n2; *n2 = temp; } void print(int S[], int n) { int i; for (i = 0; i < n; i++) printf("%d, ", S[i]); printf("\n"); } int partition(int arr[], int low, int high) { int j; int i = low - 1; int pivot = arr[high]; for( j = low; j < high; j++) { if (arr[j] <= pivot) { i++; swap(&arr[i], &arr[j]); } } swap(&arr[i+1], &arr[high]); return (i+1); } void quickSort(int arr[], int low, int high) { int pi; if (low < high) { pi = partition(arr, low, high); quickSort(arr, low, pi-1); quickSort(arr, pi+1, high); } } int main(int argc, char const *argv[]) { int arr[] = {1992, 1990, 10, 5, 6, 100, 0, 1, -1}; int sizeOf = sizeof(arr) / sizeof(arr[0]); quickSort(arr, 0, sizeOf-1); print(arr, sizeOf); return 0; }
En Java :)
package sorting; import java.util.Random; public class QuickSort { static void sort(int arr[], int start, int end) { if(start >= end) { return; } int index = partition(arr, start, end); sort(arr, start, index - 1); sort(arr, index + 1, end); } static int partition(int arr[], int start, int end) { int pivotIndex = start; int pivotValue = arr[end]; for(int i = start; i < end; i++) { if(arr[i] < pivotValue) { swap(arr, i, pivotIndex); pivotIndex++; } } swap(arr, pivotIndex, end); return pivotIndex; } static void swap(int arr[], int a, int b) { int temp = arr[a]; arr[a] = arr[b]; arr[b] = temp; } public static void main(String[] args) { int array[]; Random generator = new Random(); int lenght = 100; array = new int[lenght]; for(int i = 0; i < lenght; i++) { array[i] = generator.nextInt(1000); } sort(array, 0, 99); for(int i = 0; i < lenght; i++) { System.out.println(array[i]); } } }