Mtodo de

ordenamiento y
bsqueda Quicksort

Definicin

-El mtodo de ordenamiento rpido o Quicksort es un mtodo

recursivo que se basa en la estrategia divide y vencers, de esta
manera toma una gran cantidad de informacin, y la divide en pequeos
grupos que sean ms fciles de ordenar.

-el ordenamiento inicia escogiendo un elemento del arreglo,

comnmente llamado pivote, el cual es elegido de manera estratgica
para hacer ms simple el arreglo.

-este mtodo es llamado recursivo, pues, luego de dividir el arreglo en 2

subconjuntos divide a estos en conjuntos an ms pequeos (en otras
palabras la funcin ordenar es aplicada dentro de s misma).

 Funcionamiento

El funcionamiento del Quicksort es el siguiente:

-Se calcula un ndice a la mitad del vector a ordenar.
-Se comparan los elementos de la izquierda contra ese elemento medio
hasta encontrar un elemento mayor al de la mitad.
-Se comparan los elementos de la derecha contra el mismo elemento
medio citado arriba hasta encontrar un elemento menor al de la mitad.
-Cuando tenemos un mayor a la izquierda y un menor a la derecha, los
intercambiamos entre s.
-Volvemos a mirar los de la izquierda restante contra el de la mitad bajo el
mismo criterio anterior, igual hacemos con los de la derecha y volvemos a
intercambiar.
-Esto se repite en un ciclo hasta que el ndice por izquierda supere o sea
igual al ndice por derecha.
-Saliendo de este ciclo el llamado se hace de nuevo recursivo, primero por
izquierda considerando un subsector entre el inicio del vector y el ndice
por derecha.
-Luego se hace un llamado recursivo por derecha considerando un
subsector desde el ndice por izquierda y el lmite del vector por derecha.

-Como se puede suponer, la eficiencia del algoritmo depende de la

posicin en la que termine el pivote elegido.

 Comparacin de tiempos con otros

mtodos de ordenamiento.-

Complejidad
computacional

-En el mejor caso, el pivote termina en el centro de la lista, dividindola en

dos sablistas de igual tamao. En este caso, el orden de complejidad del
algoritmo es O(nlog n).
-En el peor caso, el pivote termina en un extremo de la lista. El orden de
complejidad del algoritmo es entonces de 0(n). El peor caso depender de
la implementacin del algoritmo, aunque habitualmente ocurre en listas
que se encuentran ordenadas, o casi ordenadas.
-En el caso promedio, el orden es O(nlog n).cuando el pivote no esta
exactamente al medio de la lista.

Pseudocdigo

Inicio
Funcion qsort(arr, ultimo:entero)
Definir i = izquierda ,j = derecha,temp como enteros
Definir central o pivote= A[(izquierda,derecha) div 2] como entero

Mientras(i<=j)

mientras arr[i]<central o pivote

i=i+1
mientras arr[j]< central o pivote

j=j-1

fin mientras
fin mientras

si (i<=j)
temp=arr[i]

arr[i] = arr[j]

arr[j] = temp

j=j-1
fin si

fin Mientras

si izq < j

qsort(arr,izq,j)

fin si

si i< derecha

qsort(arr,i,der)

fin si

fin funcion qsort

Inicio

Leer Esto es quicksort

Leer La lista es : 6,69,-33,7,23,5,0,100

Leer La lista se ha ordenado

Leer arreglo[10]={ {88,6,69,-33,98,7,23,5,0,100}

Qsort(arreglo,0,9)

para i=1 hasta i=10

i=i+1

Leer arreglo[i]

Fin Para

FIN

Codigo en c++

#include<iostream>

using namespace std;

void Quicksort(int arr,int izq,int der)

int i= izq,j=der,temp;

int p=arr[(izq+der)/2];//define quien sera el pivote//

while(i<=j)

while (arr[i]<p)i++; //avanza posicion de izq a dere

while(arr[j]>p)j--; //retrocede

if(i<=j)
{

temp=arr[i];

arr[i]=arr[j]; // para cambiar de lugar

arr[j]=temp;

i++,j--;

if (izq<j)

Quicksort(arr,izq,j);

if(i<der)

Quicksort(arr,i,der);

// llama funciones para las dos mitades//

int main()

cout<<"Metodo quicksort";

cout<<"esto es la lista";

cout<<" 6,69,-33,7,23,5,0,100"<<endl;

cout<<" la lista de abajo se ha ordenado:\n\n";

int arreglo[10]={88,6,69,-33,98,7,23,5,0,100};

Quicksort(arreglo,0,9);

for(int i=0;i<10;i++)

cout<<arreglo[i]<<""<<endl;

system("pause");

return 0;