tri en langage assembleur sur spim Fermé

Question

Bonjour,

salut tout le monde, j'ai à faire un projet qui consiste a implémenter en SPIM 3 algorithmes classiques de tri écrits en langage d'assemblage MIPS (tri de tableau d'entiers). svp si quelqu'un peut m'aider je serait tres reconnaissante. c'est un projet noté.

minos · Accepted Answer

2.	Tri par sélection 

.data

arrayofinteger: .word 12
message1:  .asciiz "donnez la taille du tableau   :
"
message2:  .asciiz "donnez l'élément "
message3:  .asciiz " le tableau trié : 
"


.text
 .globl main

main:
       la $a0,message1
       syscall
       li $v0,5
       syscall    
       move $t0,$v0            # $t0 ? nbre d'éléments
       li $t1,0  
       la $t2,arrayofinteger       #$t2? adresse du tableau des entiers
       li $t4,4    

boucle1:         #saisie des éléments
       bge $t1,$t0,boucle2
       li $v0,4
       la $a0,message2
       syscall
       li $v0,1
       addi $a0,$t1,1
       syscall
       li $v0,5
       syscall
       mul $t3,$t1,$t4
       add $t3,$t3,$t2
       sw $v0,0($t3)
       addi $t1,$t1,1
       j boucle1
boucle2:
        bge $t1,$t0,tri
        mul $t3,$t1,$t4
        add $t3,$t3,$t2
        lw $a0,0($t3);
        li $v0,1
        syscall
        addi $t1,$t1,1
        j boucle2         

tri:    move $a0,$t2
        move $a1,$t0
        jal triselection    #appel de la procédure qui effectuera le tri

   #affichage des éléments triés
       li $v0,4
       la $a0,message3
       syscall
       li $t1,0
       li $t4,4
boucle3:     #affichage de tous les éléments triés
        bge $t1,$t0,exit_tri
        mul $t3,$t1,$t4
        add $t3,$t3,$t2
        lw $a0,0($t3);
        li $v0,1
        syscall
        addi $t1,$t1,1
        j boucle3

triselection:

      addi $sp,$sp,-44
       sw $ra,0($sp)
       sw $t0,4($sp)
       sw $t1,8($sp)
       sw $t2,12($sp)
       sw $t3,16($sp)
       sw $t4,20($sp)
       sw $t5,24($sp)
       sw $t6,28($sp)
       sw $t7,32($sp)
       sw $t8,36($sp)
       sw $t9,40($sp)
       move $t0,$a0       #$t0?adresse du arrayofinteger
       move $t1,$a1       #$t1?nombre des éléments
       li $t2,0           # j? 0
       addi $t1,$t1,-1
testfor1:
       bge $t2,$t1,exit1
       move $t3,$t2       #$t3? j
       li $t4,4
       mul $t4,$t4,$t2
       add $t4,$t0,$t4 
       lw $t5,0($t4)      #$t5? arrayofinteger[j]
       addi $t6,$t2,1     #k ? j+1
    testfor2:
       bgt $t6,$t1,exit2
       li $t7,4
       mul $t7,$t6,$t7
       add $t7,$t0,$t7 
       lw $t8,0($t7)      #$t8? arrayofinteger[k]
       bge $t8,$t5,incrementation
       move $t3,$t6       #$t3? j
       move $t5,$t8       #$t5? arrayofinteger[k]    
   incrementation :
       addi $t6,$t6,1
       j testfor2
    exit2:
       li $t7,4
       mul $t3,$t3,$t7
       add $t3,$t3,$t0
       lw $t9,0($t4)     #$t9? arrayofinteger[j]
       sw $t9,0($t3)     #arrayofinteger[$t3]? arrayofinteger[j]
       sw $t5,0($t4)     #arrayofinteger[j]? $t5
       addi $t2,$t2,1
       j testfor1
       
exit1: 
       lw $ra,0($sp)
       lw $t0,4($sp)
       lw $t1,8($sp)
       lw $t2,12($sp)
       lw $t3,16($sp)
       lw $t4,20($sp)
       lw $t5,24($sp)
       lw $t6,28($sp)
       lw $t7,32($sp)
       lw $t8,36($sp)
       lw $t9,40($sp)
       addi $sp,$sp,44
      jr $ra           


exit_tri: 
 li $v0,10
 syscall

Tri en langage assembleur sur spim

1 réponse

Discussions similaires