对数组排序，C到MIPS程序集

我将C代码转换为MIPS程序集来对给定数组进行排序，但代码并不是真正的排序。下面是C代码：

    int partition(int v[], int a, int b) {
        int pivot, lower, upper, temp;
        pivot = v[a];
        lower = a + 1;
        upper = b;
        do {
            while (v[lower] <= pivot && lower <= upper) lower = lower + 1;
            while (v[upper] > pivot && lower <= upper) upper = upper - 1;
            if (lower <= upper) {
                temp = v[lower];
                v[lower] = v[upper];
                v[upper] = temp;
                lower = lower + 1;
                upper = upper - 1;
            }
        } while (lower <= upper);
        temp = v[upper];
        v[upper] = v[a];
        v[a] = temp;
        return upper;
   }

int分区（intv[]，inta，intb）{
内枢轴，下部，上部，温度；
枢轴=v[a]；
下限=a+1；
上限=b；
做{
虽然（v[lower]分区本身不能完全排序，但它是快速排序的构建块。显示了快速排序如何调用
Partition（）
然后递归到左半部分和右半部分。如果您的实现中存在一些实际错误，请包含更多细节，如
.word
数组中的示例输入，以及实际发生的情况与应该发生的情况，以生成一个。首先，您返回的是从未设置过的
$t1
。分区本身并没有完全排序，它是快速排序的构造块。显示快速排序如何调用
partition（）
然后递归到左半部分和右半部分。如果您的实现中存在一些实际的错误，请包含更多细节，例如
.word
数组中的示例输入，以及实际发生的情况与应该发生的情况，以生成一个。例如，您返回的是从未设置过的
$t1
。
.data
 vek:   .word 4, 5, 2, 2, 1, 6, 7, 9, 5, 10
 size:  .word 10
 NL:    .asciiz "\n"
 str:   .asciiz "nummer: "


    .text
    .globl main 

main:
    
    subu $sp, $sp, 16
    la $a0, vek
    jal skriv  #goto skriv
    move $t1, $v0
    
    #move $a0, $t1
    #syscall 
    
    subu $sp, $sp, 32
    la $a0, vek
    move $a1, $zero
    addi $a2, $zero, 10
    jal quicksort  #goto quicksort
    
    
    
    
    addu $sp, $sp, 16
    addi $v0, $zero, 10  #exit
    syscall
    
    .globl partition

partition:

    subu $sp, $sp, 48
    sw $ra, 36($sp)
    sw $s0, 32($sp)
    sw $s1, 28($sp)
    sw $s2, 24($sp)
    sw $s3, 20($sp)
    sw $s4, 16($sp)
    sw $s5, 12($sp)
    sw $s6, 8($sp)
    sw $s7, 4($sp)
    
    move $s0, $a0  #basadresser till array
    move $s1, $a1  #spara a i s1
    move $s2, $a2  #spara b i a2
    
    sll $t0, $s1, 2  #t0 = a*4
    lw $s3, vek($t0)  #s3 = vek[a] = pivot
    addi $s4, $s1, 1  #lower = a + 1

    
    
do: 
    
while1:
    
    sll $t0, $s4, 2  #t0 = lower * 4
    lw $s6, vek($t0)  #t1 = vek[lower]
    
    ble $s6, $s3, n1  #if (vek[low] <= pivot) goto n1
    j while2

n1:

    ble $s4, $s2, n2  #if(lower <= upper) goto n2
    j while2
n2:

    addi $s4, $s4, 1  #low=low+1
    j while1

while2:

    sll $t2, $s2, 2  #t2 = upper * 4
    lw $s7, vek($t2)  #t3 = vek[upper]

    bgt $s7, $s3, n3  #if (vek[upp] > pivot ) goto n3
    j if

n3:

    ble $s4, $s2, n4  #if (lower <= pper) goto n4
    j if
n4: 

    addi $s2,$s2, -1  #upp = upp - 1
    j while2
if: 

    bgt $s4, $s2, while  #if (lower <= upper) goto while
    addi $t4, $zero, 0
    
    move $t4, $s6    #s6 = vek[low]
    move $s6, $s7    #s7 = vek[up]
    move $s7, $t4  
    
    sll $t5, $s4, 2   #t5 = low * 4
    sw $s6, vek($t5)   #t6 = vek[low]
    
    sll $t6, $s2, 2  #t7 = upp * 4
    sw $s7, vek($t6)   #t8 = vek[upp]
    
    addi $sp, $sp, 1   #low = low + 1
    addi $s2, $s2, -1   #upp = upp -1
    
while:

    ble $s4, $s2, finish  #if( lower <= upper ) goto finish
    
finish:

    move $t7, $s7
    move $s7, $s3
    move $s3, $t7
    
    sll $t8, $s1, 2    #t8 = a * 4
    sw $s3, vek($t8)  #t8 = vek[a]
    
    
    
    
    sll $t9, $s2, 2  #t9 = upp * 4
    sw $s7, vek($t9)  #s7 = vek[upp]
    
    add $v0, $zero, $s2  #save return value for upper
    lw $ra, 36($sp)
    lw $s0, 32($sp)
    lw $s1, 28($sp)
    lw $s2, 24($sp)
    lw $s3, 20($sp)
    lw $s4, 16($sp)
    lw $s5, 12($sp)
    lw $s6, 8($sp)
    lw $s7, 4($sp)
    
    
    addu $sp, $sp, 48
    
    li $v0, 1
    move $a0, $t8
    syscall
    
    li $v0, 1
    move $a0, $s2
    syscall
    
    
    #to exit
    move $v0, $t1
    jr $ra
    
    #quicksort

quicksort:

    subu $sp, $sp, 32
    
    
    sw $ra, 28($sp)
    sw $s1, 12($sp)
    sw $s2, 8($sp)
    sw $a0, 24($sp)
    sw $a1, 20($sp)
    sw $a2, 16($sp)
    lw $s1, 20($sp)
    lw $s2, 16($sp)
    
    
    bge $s1, $s2, q1
    
    lw $a0, 24($sp)  #a0 = v
    lw $a1, 20($sp)  #a1 = a
    lw $a2, 16($sp)  #s2 = b
    
    jal partition
    move $s0, $v0  
    lw $a0, 24($sp)  #a0 = v
    lw $a1, 20($sp)  #a1 = 0
    subu $a2, $s0, 1 #a2 = k - 1
    
    jal quicksort
    lw $a0, 24($sp)  #a0 = v
    addu $a1, $s0, 1  #a1 = k + 1
    
    lw $a2, 16($sp)  #a2 = b
    jal quicksort
    
    
 q1:

    lw $ra, 28($sp)
    lw $s1, 12($sp)
    lw $s2, 8($sp)
    lw $a0, 24($sp)
    lw $a1, 20($sp)
    lw $a2, 16($sp)
    
    
    lw $ra, 28($sp)
    addu $sp, $sp, 32  #delete the stack 
     
    jr $ra