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