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)

gran trabajo de traducción amigo.

saludos Arkangel

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 

Muy buen trabajo este, felicitaciones!!! 

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

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