用SPIM模拟器实现MIPS冒泡排序

# 计算机

# 冒泡排序.s 排序算法

# 太原科技大学计算机学院的学生伤不起呀

.text

main:

la $s0, arrayBubble

la $a0, zuozhe # print message about this text li $v0, 4

syscall

la $a0, countmsg # address of string to print li $v0, 4 # syscall 4 = print_string syscall # make the syscall

## the next block requests user to inter the count of numbers to sort,

## if inputNumbers <= 0,need to reinter

err:

li $v0, 5 # syscall 5 = read_int

syscall

move $s1, $v0 # move read_int(count) to $s1

slt $t0, $zero, $s1 # check count,if $s1 > 0 $zero = 1

bne $t0, $zero, inputfor1 # go to inputfor1 if $s1 > 0

la $a0, errormsg # address of error warning errormsg

li $v0, 4 # syscall 4 = print_string syscall

j err # go to err to repeat-input count

##get numbers one by one

inputfor1:

la $a0, msg1 # address of string to print li $v0, 4

syscall

move $a0, $s1 # output count to console li $v0, 1 # syscall 1 = print_int

syscall

la $a0, msg2 # address of string to print li $v0, 4

syscall

move $t0, $zero # set $t0 to 0,$t0 will used to control input count

inputdata:

##Register used:

# $t0 -used to hold currentCount and sortedNumbers of input numbers

# $v0 -syscall parameter and return value

li $v0, 5 # input number to $v0

syscall

sll $t1, $t0, 2 # reg $t1 = currentCount * 4 add $t2, $s0, $t1 # reg $t2 = $s0 + (currentCount * 4)

# reg $t2 has the address of arrayBubble[currentCount]

sw $v0, 0($t2) # arrayBubble[currentCount] = reg $v0

addi $t0, $t0, 1 # user has input currentCount+1 numbers

slt $t1, $t0, $s1 # $t1 = 1 if currentCount+1 < count

bne $t1, $zero, inputdata # go to inputdata if currentCount+1 < count

move $a0, $s0 # $a0 = $s0,$a1 = $s1 as argument transfered to bubbleSort

move $a1, $s1 # if currentCount+1 =

count

jal sort # go to Label sort for bubbleSort(get the address of

# next instruction

la $a0, bounder # output bounder(a group of #s)

li $v0, 4

syscall

la $a0, sortedNumbers # output string(int) of sorted numbers

li $v0, 4

syscall

move $t0, $zero # set $t0 to 0,$t0 will used to control output count

##output sortedNumbers by two space interval outputdata:

sll $t1, $t0, 2 # reg $t1 = currentCount * 4 add $t2, $s0, $t1 # reg $t2 = $s0 + (currentCount * 4)

lw $a0, 0($t2) # output the content in address specified by $a0

li $v0, 1

syscall

la $a0, space # out put two space

li $v0, 4

syscall

addi $t0, $t0, 1 # reg $t0 = $t0 + 1 prepared for outputting next number

slt $t1, $t0, $s1 # check : all contents have been outputted

bne $t1, $zero, outputdata # go to output if numbers aren't all output

la $a0, bounder #output bounder(a group of #s)

li $v0, 4

syscall

j exit # end of bubbleSort

####################Saving

register##########################

sort:

addi $sp,$sp,-20 #make room on stack for 5 register sw $ra,16($sp) #save $ra on stack

sw $s3,12($sp) #save $s3 on the stack

sw $s2,8($sp) #save $s2 on the stack

sw $s1,4($sp) #save $s1 on the stack

sw $s0,0($sp) #save $s0 on the stack

move $s2,$a0 #copy parameter $a0 into $s2 (save $a0)

move $s3,$a1 #copy parameter $a1 into $s3 (save $a1)

##Fuction name: sort ; fuction, invoked by main,invokes the swap fuction

# void sort(int v[],int n)

# {

# int i,j;

# for( i = 0; i < n; i+=1){

# for(j = i - 1; j >= 0 && v[j] > v[j+1]; j -= 1){ # swap(v,j);

# }

# }

# }

###########Outer loop (the sort fuction contains outloop and innerloop)########

move $s0,$zero #i = 0

for1tst:

slt $t0,$s0,$s3 #reg $t0 = 0 if $s0 >= $s3 (i >= n)

beq $t0,$zero,exit1 #go to exit1 if $s0 >= $a1 (i ###########Inner

loop############################################# addi $s1,$s0,-1 # j = i - 1

for2tst:

slti $t0,$s1,0 # reg $to = 1 if $s1 < 0 (j < 0) bne $t0,$zero,exit2 # go to exit2 if $s1 < 0 (j < 0) sll $t1,$s1,2 # reg $t1 = j * 4

add $t2,$s2,$t1 # reg $t2 = v + (j * 4)

lw $t3,0($t2) # reg $t3 = v[j]

lw $t4,4($t2) # reg $t4 = v[j + 1]

slt $t0,$t4,$t3 # reg $t0 = 0 if $t4 >= $t3

beq $t0,$zero,exit2 # go to exit2 if $t4 >= $t3

##########Pass parameters and call#############################

move $a0,$s2 # first parameter of swap is v(old $a0)

move $a1,$s1 # second parameter of swap is j #############swap(v[],k)############################ #############

sw $t4,0($t2) # v[j]=reg $t4

sw $t3,4($t2) # v[j +1] = reg $t3

##############Inner

loop######################################## addi $s1,$s1,-1 # j -=1

j for2tst # jump to test of inner loop

###############Outer

loop#########################################

exit2:

addi $s0,$s0,1 # i += 1

j for1tst # jump to test of outer loop

exit1: # the sort function doesn't work after

##restoring registers

lw $s0,0($sp) # restore $s0 from stack

lw $s1,4($sp) # restore $s1 from stack

lw $s2,8($sp) # restore $s2 from stack

lw $s3,12($sp) # restore $s3 from stack

lw $ra,16($sp) # restore $ra from stack

addi $sp,$sp,20 # restore stack pointer

##procedure return

jr $ra #return to calling routine

###########End of procedure#########################################

exit:

li $v0,10 # syscall 10 = exit

syscall # make syscall

.data

arrayBubble :

countmsg : .asciiz "输入你要排序的个数 : "

errormsg : .asciiz "你要输入的数应该大于0 ："

zuozhe : .asciiz " # 计算机092002 \n # 王佳宾2011/12/12 \n # 学号：200920010220 \n # 冒泡排序.s 排序算法 \n" msg1 : .asciiz "你要输入的正数的总数是： "

msg2 : .asciiz " \n请依次输入数字按enter键确定 : \n"

space : .asciiz " "

bounder : .asciiz "\n=================================================== =====================================================\ n"

sortedNumbers : .asciiz "由小到大的顺序依次是："

#end of冒泡排序.s

运行结果如下：