到目前为止，我有这个，但它打印出来的所有4个。它没有排序。
# Quicksort.asm
.data
array: .word 4, 9, 12, -5, 2, 54, 8 , 1
line: .asciiz " "
.text
main:
addi $sp, $sp, -4 # Push the stack pointer down to hold one value
sw $ra, 0 ($sp) # Store the return address on the stack
la $a0, array # Array into a0
addi $a1, $zero, 0 # Left most element (p)
addi $a2, $zero, 7 # Right most element (r)
jal quicksort
addi $t0, $zero, 0 # Counter loop
addi $t1, $zero, 8 # where the loop ends
la $t7, array # loads base address of array into t7
topprintloop:
beq $t0, $t1, endprintloop
sll $t3, $t0, 2 # calculates j * 4
addi $t3, $t7, 0 # Calculates the address of array[j]
lw $t4, 0($t3) # load value at array[j]
addi $v0, $zero, 1 # sets v0 to 1 for syscall
addi $a0, $t4, 0 # load int to print into a0
syscall # prints it
addi $v0, $zero, 4 # sets v0 to 4 for syscall
la $a0, line # loads string to print into a0
syscall # prints it
addi $t0, $t0, 1 # increment counter by 1
j topprintloop # jumps to topprintloop
endprintloop:
lw $ra, 0 ($sp) # Restore the return address from the stack
addi $sp, $sp, 4 # Pop the stack
jr $ra
quicksort:
addi $sp, $sp, -20 # Store it to the stack
sw $ra, 0 ($sp)
sw $s0, 4 ($sp)
sw $s1, 8 ($sp)
sw $s2, 12 ($sp)
sw $s3, 16 ($sp)
addi $s0, $a0, 0 # store into s0 array pointer
addi $s1, $a1, 0 # store into s1 left most element (p)
addi $s2, $a2, 0 # store into s2 right most element (r)
# store into s3 q
blt $s1, $s2, prep # jumps and links to prep if p < r
j returnQuicksort # jumps to returnQuicksort when finished
prep:
addi $a0, $s0, 0 # store into s0 array pointer
addi $a1, $s1, 0 # store into s1 left most element (p)
addi $a2, $s2, 0 # store into s2 right most element (r)
jal partition
addi $s3, $v0, 0 # stores the partition value of v0 and puts it into q
# First recursive call
addi $a0, $s0, 0 # store into a0 new left subarray
addi $a1, $s1, 0 # [p]
addi $a2, $s3, -1 # [q-1]
jal quicksort
# Second recursive call
addi $a0, $s0, 0 # store into a0 new right subarray
addi $a1, $s3, 1 # [q+1]
addi $a2, $s2, 0 # [r]
jal quicksort
returnQuicksort:
lw $ra, 0 ($sp) # pop the stack
lw $s0, 4 ($sp)
lw $s1, 8 ($sp)
lw $s2, 12 ($sp)
lw $s3, 16 ($sp)
addi $sp, $sp, 20
jr $ra
partition:
addi $sp, $sp, -28 # Push stack pointer
sw $ra, 0 ($sp)
sw $s0, 4 ($sp)
sw $s1, 8 ($sp)
sw $s2, 12 ($sp)
sw $s3, 16 ($sp)
sw $s4, 20 ($sp)
sw $s5, 24 ($sp)
addi $s0, $a0, 0 # Array pointer
addi $s1, $a1, 0 # P value
addi $s2, $a2, 0 # R value
sll $t0, $s2, 2 # * 4 into t0
add $t1, $t0, $s0
lw $s3, 0($t1) # Pivot value
addi $s4, $s1, -1 # value i
addi $s5, $s1, 0 # value j
beginloop:
bge $s5, $s2, endloop # j < r
sll $t0, $s5, 2 # * 4 into t0
add $t1, $t0, $s0
lw $s3, 0($t1) # Pivot value
sll $t2, $s5, 2
add $t2, $s0, $t2
lw $t2, 0($t2)
ble $t2, $s3, doloop
j loop
doloop:
sll $t0, $s5, 2 # calculates j * 4
addi $t0, $s0, 0 # Calculates the address of array[j]
lw $t1, 0($t0) # load value at array[j]
ble $t1, $s3, partitionswap # branch if array[j] <= pivot
j loop # skip partition swap if condition fails and go to loop
partitionswap:
addi $s4, $s4, 1 #increment i
addi $a0, $s0, 0 # load array into a0
addi $a1, $s4, 0 # load i into a1
addi $a2, $s5, 0 # load j into a2
jal swap # we swap
j loop
loop:
addi $s5, $s5, 1 # increments j (j++)
j beginloop
endloop:
# call swap
addi $t0, $s4, 1 # i+1
addi $a0, $s0, 0
addi $a1, $t0, 0
addi $a2, $s2, 0
jal swap
addi $t0, $s4, 1
addi $v0, $t0, 0
lw $ra, 0 ($sp)
lw $s0, 4 ($sp)
lw $s1, 8 ($sp)
lw $s2, 12 ($sp)
lw $s3, 16 ($sp)
lw $s4, 20 ($sp)
lw $s5, 24 ($sp)
addi $sp, $sp, 28 # Push stack pointer
jr $ra
swap:
addi $sp, $sp, -28 # Push the stack pointer down to hold seven values
sw $ra, 0 ($sp) # Store the return address and s registers on the stack
sw $s0, 4 ($sp)
sw $s1, 8 ($sp)
sw $s2, 12($sp)
sw $s3, 16($sp)
sw $s4, 20($sp)
sw $s5, 24($sp)
# Done with protecting registers. Now for the real work:
sll $s0, $a1, 2 # from * 4 into $s0
sll $s1, $a2, 2 # to * 4 into $s1
add $s2, $a0, $s0 # Address of array[from] into $s2
add $s3, $a0, $s1 # Address of array[ to] int9 $s3
lw $s4, 0($s2) # Value of array[from] into $s4
lw $s5, 0($s3) # Value of array[to] into $s5
sw $s4, 0($s3) # Value from $s4 into array[to]
sw $s5, 0($s2) # Value from $s5 into array[from]
# Done with the work. No return value.
lw $ra, 0 ($sp) # Restore the $ra and $s registers from the stack
lw $s0, 4 ($sp)
lw $s1, 8 ($sp)
lw $s2, 12($sp)
lw $s3, 16($sp)
lw $s4, 20($sp)
lw $s5, 24($sp)
addi $sp, $sp, 28 # Pop the stack pointer
jr $ra