sorte d'insertion dans l'Assemblée

Question

Je suis codage à une sorte d'insertion (dans l'assemblage) en fonction de ce code de haut niveau:

void insertionSort(int data[ ], int arraySize) { 
     int insert; 
     int moveItem; 
     for(int next=1; next<arraySize; next++) { 
        insert=data[next]; //store the value in the current element 
        moveItem=next; //initialize location to place element 

        while((moveItem>0)&&(data[moveItem-1]>insert)) { 
           //shift element one slot to the right 
           data[moveItem]=data[moveItem-1]; 
           moveItem--; 
        } //end while 

        data[moveItem]=insert; 
     } //end for 
} //end insertionSort 

Il y a exactement 20 nombres aléatoires dans un tableau appelé myArray. Je ne peux pas utiliser une des dérivées de décision qui viennent dans la bibliothèque fournie avec notre livre. Donc, fondamentalement movs, cmps, boucles et sauts Voici ce que j'ai. Je l'ai fait trier le premier de 20 nombres aléatoires plus tôt, mais je me suis confus à la mort et n'ai aucune idée de ce que je fais plus. Il se bloque lorsqu'il arrive à la méthode de tri d'insertion. Aidez-moi, s'il vous plaît.

TITLE Insertion Sort (main.asm) 
INCLUDE Irvine32.inc 
.data 

elems = 20 

myArray sdword elems dup(0) 
str1 byte "Press enter" ,0 
str2 byte "The array now is ",0 
next sdword 1 
start sdword ? 

.code 
main PROC 
    call Clrscr 
    call CreateRandom 
    call Display 
    call InsertionSort 
    call Display 
    exit 
main ENDP 

CreateRandom PROC 
;;;;Creates 20 random numbers and populates myArray;;;;; 
    call Randomize 
    mov ecx, 20 
    mov edx, OFFSET myArray 

L1:      
    call Random32     ;create random number 
    mov [edx], eax     ; move random number to the appropriate spot in the array 
    add edx, 4      ; increase the address of what it is pointing to 
    loop L1 
    mov edx, OFFSET str1   ; "press enter to continue" 
    call WriteString 
    call ReadInt 
    call Crlf 
    ret 
CreateRandom ENDP 

Display PROC 
;;;; Displays current form of the array myArray;;;;; 
    mov edx, OFFSET str2    ; "The array now is:" 
    call WriteString     ; write string 
    call Crlf 
    mov esi, OFFSET myArray    ; offset of the array 
    mov ecx, 20       ; index of the loop 
L2: 
    mov eax, [esi]      ; move array at that point to eax 
    call WriteDec      ; print out the array as a decimal 
    call Crlf       ; next line 
    add esi, 4       ; next element in the array 
    loop L2 
    call Crlf 
    ret 
Display ENDP 

InsertionSort PROC 
mov ecx, 19 
mov edx, OFFSET myArray 
mov ebx, OFFSET myArray   ; eax=next 
add ebx, 4      ;moves up the array to second element comparable to next 

outterloop: 
    mov esi, [ebx]     ; esi=data[next] 
    mov eax, ebx    ;movelterm=ebx 
    L1: 
     mov edx, [eax-4]   ;move the number that is greater into edx 
     mov [eax], edx    ;move the number into that 2nd element of the 
     sub eax, 4 
     mov esi, [eax] 
     cmp eax, [edx] 
     JNG endinner      ; if the address is not greater than the first address, skip to the end 
     mov edx, [eax-4] 
     cmp edx, esi      ; if the address is greater, than it already sorted, skip to end 
     JG endinner 
     loop L1 
    endinner: 
     mov [eax], esi ; move first to the second to finish the sort 
     add ebx, 4 ;move to the next element of the array 
    inc next ;counting outside loop 
     cmp ecx, next 
     JNE outterloop ;return to top of for loop 

ret 
InsertionSort ENDP 

END main 

Answer 1

Je n'ai pas examiné votre code en détail, mais je remarque que InsertionSort semble utiliser edx à deux fins différentes à la fois: en tant que pointeur dans le tableau, et de tenir l'une des valeurs de la tableau. Cela va certainement casser même si rien d'autre ne va pas. Donc, au début de InsertionSort, vous dites mov edx, OFFSET myArray - c'est un pointeur dans le tableau. Ensuite, quelques lignes plus tard, mov edx, [eax-4] - oups, non, c'est une valeur du tableau. Et quelques lignes plus tard encore, cmp eax, [edx] - oh, non, maintenant c'est un pointeur dans le tableau à nouveau.

Peut-être que cette dernière instruction devrait être cmp edx, [eax] ou quelque chose? Parce que eax semble être un pointeur dans le tableau ici.