Foro de elhacker.net

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   ;)

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)

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

gran trabajo de traducción amigo.

saludos Arkangel

Muy buen code , para que sea compatible con byte y word se podria usar cbw y cwd :P 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

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  :xD

Por que el gracias con cara triste ???

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

Muy buen trabajo este, felicitaciones!!!  ;-) ;-)

Bravo  :o , 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

Basado en el Ordenamiento por Selección (http://c.conclase.net/orden/seleccion.html)

hice un codigo para ordenar bytes :P

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

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                                                            

bien ya tenemos dos algoritmos de ordenacion  :)

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