push [lo] [hi]
call quicksort
;Exit
quicksort:                  ;void quicksort (int[] a, int lo, int hi)
    mov eax,[esp+8]         ;{
    mov edx,[esp+4]         ;//  lo is the lower index, hi is the upper index
    lea ecx,[eax+edx]       ;//  of the region of array a that is to be sorted
    shr ecx,3               ;    int i=lo, j=hi, h;
    shl ecx,2
    mov ecx,[a+ecx]         ;    int x=a[(lo+hi)/2];
  .qc1:                     ;
    cmp [a+eax],ecx         ;    //  partition
    jnc .qc2                ;    do
    add eax,4
    jmp .qc1                ;    {
  .qc2:                     ;        while (a[i]<x) i++;
    cmp ecx,[a+edx]         ;        while (a[j]>x) j--;
    jnc .qc3                ;        if (i<=j)
    sub edx,4               ;        {
    jmp .qc2                ;            h=a[i]; a[i]=a[j]; a[j]=h;
  .qc3:                     ;            i++; j--;
    cmp edx,eax             ;        }
    jc  .qc4                ;    } while (i<=j);
    push [a+eax] [a+edx]    ;
    pop  [a+eax] [a+edx]    ;    //  recursion
    add eax,4               ;    if (lo<j) quicksort(a, lo, j);
    sub edx,4               ;    if (i<hi) quicksort(a, i, hi);
    cmp edx,eax             ;}
    jnc .qc1
  .qc4:
    cmp  [esp+8],edx
    jnc  .qc5
    push dword [esp+8]
    push edx
    call quicksort
    pop  edx
    pop  dword [esp+12]
  .qc5:
    cmp  eax,[esp+4]
    jnc  .qc6
    push eax
    push dword [esp+8]
    call quicksort
    pop  dword [esp+12]
    pop  eax
  .qc6:
ret
align 4
a  dd 3,1,4,1,5,9,2,6,5,3,5,8,9,7,9,3 ;16
lo dd 0
hi dd 15*4   
    

bubblesort:
         lea     ebx,[edi+ecx*4]
         mov     eax,[edi]
.cmploop:sub     ebx,4
         cmp     eax,[ebx]
         jle     .again
         xchg    eax,[ebx]
.again:  cmp     ebx,edi
         jnz     .cmploop
stosd
loop bubblesort
ret 
    

org 100h

arraysize=10

;mov edi,a
mov ecx,arraysize
;call bubblesort
;call seebubblesort

mov edi,a2
call bubblesort64 ; dd index, dd pointer

mov cx,arraysize*2
mov si,a2
call writea

int 20h;
;You end up with {1,1,2,3,3,3,4,5,5,5,6,7,8,9,9,9} in a

writea: ; si=dword string cx=elements
dec cx
.loop:
lodsd
mov ah,$e
add al,'0'
int 10h
mov al,','
int 10h
loop .loop
lodsd
mov ah,$e
add al,'0'
int 10h
bendline:
mov ax,$e0d
int 10h
mov ax,$e0a
int 10h
;ret
ret


;
; bubble sort
; input: edi = pointer to array, ecx = number of indexes
; output: edi = pointer to sorted array
; destroys:  eax, edx, eflags
;
seebubblesort:
pusha
mov cx,arraysize
mov si,a
call writea
popa
         lea     ebx,[edi+ecx*4]
     mov     eax,[edi]
.cmploop:sub   ebx,4
       cmp     eax,[ebx]
   jae     .again
      xchg    eax,[ebx]
.again:  cmp   ebx,edi
     jnz     .cmploop
stosd
loop seebubblesort
ret

bubblesort:
       lea     ebx,[edi+ecx*4]
     mov     eax,[edi]
.cmploop:sub   ebx,4
       cmp     eax,[ebx]
   jle     .again
      xchg    eax,[ebx]
.again:  cmp   ebx,edi
     jnz     .cmploop
stosd
loop bubblesort
ret

bubblesort64: ; dd index, dd pointer
pusha
mov cx,arraysize*2
mov si,a2
call writea
popa

  lea     ebx,[edi+ecx*8]
     mov     eax,[edi]
.cmploop:sub   ebx,8
       cmp     eax,[ebx]
   jle     .again
      xchg    eax,[ebx]
   push    dword [ebx+4] dword [edi+4]
         pop     dword [ebx+4] dword [edi+4]
.again:  cmp         ebx,edi
     jnz     .cmploop
    stosd
       add     edi,4
       loop    bubblesort64
ret


a  dd 9,8,7,6,5,4,3,2,1,0,9,8,7,6,5,4,3,2,1,0 ;20
a2  dd 9,0,8,1,7,2,6,3,5,4,4,5,3,6,2,7,1,8,0,9, 9,0,8,1,7,2,6,3,5,4,4,5,3,6,2,7,1,8,0,9 ;20