[ASM]Algoritmo de Ordenacion Quicksort

[ny0x]

Bueno aqui les dejo una traduccion a ensamblador del algoritmo de QuickSort me costo algo de trabajo y estuve un buen depurando pero por fin salio.
Lo malo es que solo funciona con numeros de 32 bits positivos pero se puede arreglar para que funcionen con bytes y words (ahora lo de negativos no se intente cambiar jl y jg por jb y ja pero me los pone como mayores que cualquier positivo)

Si de casualidad alguien no entiende el codigo que me diga y le pongo comentarios  

Código (asm) [Seleccionar] Expandir


format pe console
include '\fasm\include\win32ax.inc'
entry start
.data
vector          dd      32,9,11,5,99,3,1,2,5,12,100,4365
formato         db      '%i %i %i %i %i %i %i %i %i %i %i %i',13,10,0
.code
start:
       call Dump
       push 11
       push 0
       push vector
       call quicksort
       call Dump

ret

quicksort:
        push ebp
        mov ebp,esp
        push esi
        push ebx
        push ecx
        push edx
        mov ebx,dword[ebp + 12]
        mov ecx,dword[ebp + 16]
        cdq
        mov eax, ebx
        add eax, ecx
        push ecx
        mov ecx,2
        div ecx
        pop ecx
        xchg edx,eax
        mov esi, [ebp + 8]
        mov edx,dword[esi + edx * 4]
        qs@L1:
               qs@L1@L1:
                       cmp dword[esi + ebx * 4],edx
                       jge qs@L1@L1@out
                       inc ebx
                       jmp qs@L1@L1
               qs@L1@L1@out:
               qs@L1@L2:
                       cmp dword[esi + ecx * 4],edx
                       jle qs@L1@L2@out
                       dec ecx
                       jmp qs@L1@L2
               qs@L1@L2@out:
               qs@L1@IF1:
                       cmp ebx, ecx
                       jg qs@L1@IF1@out
                       mov eax, dword[esi + ebx * 4]
                       xchg eax, dword[esi + ecx * 4]
                       mov dword[esi + ebx * 4], eax
                       inc ebx
                       dec ecx
               qs@L1@IF1@out:
               cmp ebx,ecx
               jle qs@L1
        qs@L1@out:
        qs@IF1:
               cmp dword[ebp + 12],ecx
               jge qs@IF1@out
               push ecx
               push dword[ebp + 12]
               push esi
               call quicksort
        qs@IF1@out:
        qs@IF2:
               cmp ebx, dword[ebp + 16]
               jge qs@IF2@out
               push dword[ebp + 16]
               push ebx
               push esi
               call quicksort
        qs@IF2@out:
        pop edx
        pop ecx
        pop ebx
        pop esi
        pop ebp
retn 12

Dump:
       pushad
       mov edi,vector
       push dword[edi + 11 * 4]
       push dword[edi + 10 *4 ]
       push dword[edi + 9 * 4]
       push dword[edi + 8 * 4]
       push dword[edi + 7 * 4]
       push dword[edi + 6 * 4]
       push dword[edi + 5 * 4]
       push dword[edi + 4 * 4]
       push dword[edi + 3 * 4]
       push dword[edi + 2 * 4]
       push dword[edi + 1 * 4]
       push dword[edi]
       push formato
       call [printf]
       add esp,52
       popad
ret
section '.idata' import data readable
library msvc,'msvcrt.dll'
import msvc,printf,'printf'


los parametros se pasan por la pila
y son asi
quicksort(int *vector, int izq, int der)

[h0oke]

Exelente trabajo x0ʎu se nota que estas progresando bastante.
Ya tendré mi tiempito para dedicarme a asm.
S2!

[Arkangel_0x7C5]

gran trabajo de traducción amigo.

saludos Arkangel

[YST]

Muy buen code , para que sea compatible con byte y word se podria usar cbw y cwd solo es una idea para alguien que lo quiera usar.

Por si alguien no conoce de que trata el algoritmo
http://es.wikipedia.org/wiki/Quicksort

[ny0x]

gracias  
tarde mucho depurando pero por lo menos quedo mas o menos decente  

P.D si no quieren que les cause un error cuando tienen un numero negativo cambien los saltos  jl y jg por jb y ja, lo unico malo es que los negativos los ordenara como mayores  

Yst si se que se puede y tambien se puede adaptar para que ordene qwords 

[YST]

Por que el gracias con cara triste ???

Lo que me gustaria ver es el algoritmo RC4 en ASM , talves lo haga yo

[Amerikano|Cls]

Muy buen trabajo este, felicitaciones!!! 

[Yurix]

Bravo  , según he leído en el foro este algoritmo es el mas rápido , felicidades poco a poco vamos ampliando el repertorio y compartiendo , felicidades , te invito a que lo publiques en la wikipedia , si lo deseas lo puedo hacer yo.

Saludos

[YST]

Basado en el Ordenamiento por Selección

hice un codigo para ordenar bytes

Este metodo tambien sirve para hacer un orden alfabetico ya que los caracteres ascii estan en orden alfabetico

Código (ASM) [Seleccionar] Expandir


include 'win32ax.inc'

.data
cc db '774422990',0
.code
start:
invoke lstrlen,cc
stdcall Ordenar,cc,eax
invoke MessageBox,0,cc,0,0
invoke ExitProcess,0

proc Ordenar,cNumer,cCantidad
pushad
pushf
mov edi,[cCantidad]
mov ebx,[cNumer]
dec ebx
inc edi
.bucle:
dec edi
inc ebx
stdcall Menor,ebx,edi
mov cl,byte[ebx]
mov byte[ebx],al
mov byte[edx],cl
cmp edi,1
jne .bucle
popf
popad
ret
endp
;Función que retorna el byte menor en al y su posicion en edx
proc Menor,cNumer,cCantidad
push ecx
mov eax,[cNumer]
mov edx,eax
mov ch,byte[eax]
dec eax
.bucle:
dec [cCantidad]
inc eax
.if byte[eax] < ch
mov ch,byte[eax]
mov edx,eax
.endif
cmp [cCantidad] ,0
jne .bucle
mov eax, [cNumer]
mov al,ch
pop ecx
ret
endp

.end start                                                            

[ny0x]

bien ya tenemos dos algoritmos de ordenacion 

Yurix publicalo si quieres pero no creo que se gane nada con ponerlo en wikipedia