Comment écrire la condition d'arrêt dans un tri rapide dans l'assemblage

Question

J'essaie de mettre en œuvre un tri rapide dans l'assemblage. Je ne peux pas implémenter l'instruction return lorsque la condition d'arrêt est vraie, comme je peux le faire en C# ou dans toute autre langue haute. L'aide sera appréciée!

Voici mon code:

INCLUDE Irvine32.inc 
    Len EQU 8 
.data 
    Numbers byte 5,6,4,7,11,2,9,1 
    Sorted byte Len dup(?) 
    Index_Pivot dword ? 
    Element_Pivot byte ? 
    Greater byte Len dup(-1) 
    Less byte Len dup(-1) 
    Temp dword ? 
    Temp2 dword ? 
.code 
Generate_Random PROC 
    Mov eax,ebx 
    CALL randomrange 
    ret 
Generate_Random ENDP 
;----------------------------- 

Quick_Sort PROC 
    CMP ebx,1 
     JLE Next 
    CALL Generate_Random 
    MOV Index_Pivot,eax 
    ADD esi,eax 
    MOV Temp2,eax 
    MOV al,[esi] 
    MOV Element_Pivot,al 
    MOV byte ptr[esi],' ' 
    SUB esi,Temp2 
    ;------------------------- 
    MOV ecx,ebx 
    JMP Do_calc 
    Continue:: 

    MOV Temp,edx 

    MOV esi,OFFSET Less 
    MOV ebx,Temp 
    CALL Quick_Sort 

    Next: 
    ret 
Quick_Sort ENDP 
;------------------------------------- 
Do_calc: 
     MOV ebx,0 
     MOV edx,0 
     ;MOV ecx,Len 
     L: 
      MOV al,Element_Pivot 
      CMP byte ptr[esi],' ' 
       JE Next 
      CMP [esi],al 
       JG Move_Greater 
       MOV al,[esi] 
       MOV Less[edx],al 
       INC edx ; for less array 
       JMP Next 
       Move_Greater: 
        MOV al,[esi] 
        MOV Greater[ebx],al 
        INC ebx ; for greater array 
      Next: 
      INC esi 
     LOOP L 
    jmp Continue 


;----------------- 
main PROC 
    MOV esi,OFFSET Numbers 
    MOV ebx,Len 
    CALL Quick_Sort 

    MOV edi,OFFSET Sorted 

    MOV edi,OFFSET Sorted 
    MOV ecx,LENGTHOF Sorted 
    lo: 
     mov eax,0 
     mov al,[edi] 
     call writeint 
     INC edi 
    LOOP lo 
    CALL crlf 



    exit 
main ENDP 

END main 

Answer 1

Votre code a déjà une condition d'arrêt. Pour renvoyer une valeur ou un pointeur vers une liste, vous devez simplement placer la valeur ou le pointeur sur une liste dans eax et retourner.

En réponse à la mise en œuvre de l'OP inhabituelle aC# tri rapide, voici par exemple aC# d'un seul schéma de partition de Hoare fonction tri rapide:

 static public void Quicksort(int [] a, int lo, int hi) 
     { 
      if (lo >= hi) 
       return; 
      int p = a[(lo + hi)/2]; 
      int i = lo, j = hi; 
      i--;      // partition 
      j++; 
      while (true) 
      { 
       while (a[++i] < p) ; 
       while (a[--j] > p) ; 
       if (i >= j) 
        break; 
       int t = a[i]; 
       a[i] = a[j]; 
       a[j] = t; 
      } 
      Quicksort(a, lo, j);  // recurse 
      Quicksort(a, j + 1, hi); 
     }