MIPS, Получить местоположение двоичного поиска и линейного поиска,

Question

Я пишу программу в MIPS, чтобы получить местоположение цели из возрастающего массива (1-10), используя как линейный, так и двоичный поиск. Прямо сейчас мне удается завершить двоичный алгоритм с правильным выводом, но для линейного ряда некоторые целые числа в массиве приводят к неправильному выводу.

Мой вывод прямо сейчас:

//Let's say the target to find = 2

1     //from binary search
-1    //from linear search, result -1 when can't find target

С другой стороны, как мне сохранить количество сравнений каждого алгоритма? Я знаю, что линейный случай - это O (n), в основном, сколько раз запускается l oop. Но насчет бинарного поиска я не уверен.

Пожалуйста, помогите мне.

.data
array: .word 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
length: .word 10
newline: .asciiz " \n"

.text
main:


  la $a0, array                # Load array into $a0
  li $a1, 0                    # Load 0 into a1
  lw $a2, length               # Load length into $a2
  li $a3, 4            # Load item to search for into $a1

  jal binarySearch  
  jal linear


  move $a0, $v0             # Move $v0 into $a0
  li $v0, 1                  #print location of binary search
  syscall                      #print


  la $a0, newline
  li $v0,4      #newline
  syscall


  move $a0, $v1
  li $v0,1          #print location of target by linear search
  syscall

  la $a0, newline
  li $v0,4          #new line
  syscall


  li $v0, 10
  syscall


  #length of the array: $a2


####################################
#          Binary Search           #
####################################
# Input:                           #
# $a0, the array of words          #
# $a1, left index                  #
# $a2, right index                 #
# $a3, item to search for          #
####################################
# Output:                          #
# $v0, index of item (-1 if failed)#
####################################
# Used Registers:                  #
# $t0, Midpoint                    #
# $t1, used in math                #
####################################

binarySearch:

  addi $sp, $sp, -4            # Lower stack pointer
  sw $ra, 0($sp)               # Store return address
  blt $a2, $a1, binaryFailed   # If r < l then we failed
 # addi $t7, $t7, 1
  add $t0, $a1, $0             # Move left into t0
  sub $t1, $a2, $a1            # Right - Left
  srl $t1, $t1, 1              # (Right - Left) / 2
  add $t0, $t1, $t0            # left + (right - left) / 2 (MID)
  sll $t1, $t0, 2              # Convert index into word format
  add $t1, $t1, $a0            # Add offset into array
  lw $t1, 0($t1)               # Load array element into memory
  beq $t1, $a3, binaryFound    # The element was found
  bgt $t1, $a3, binaryGreater  # The element is greater than the pointer
  addi $a1, $t0, 1             # Set left to mid+1

  j binarySearch             # Search with new variable
  j binaryEnd

binaryFound:
  add $v0, $t0, $0             # Move mid answer into memory
  #move $s7, $t7

  j binaryEnd                  # End

binaryGreater:
  addi $a2, $t0, -1            # Set right to mid-1
  jal binarySearch             # Search with new right
  j binaryEnd

binaryFailed:
  li $v0, -1                   # Load failed value
  j binaryEnd                  # Load end

binaryEnd:
  lw $ra, 0($sp)               # Load the return
  addi $sp, $sp, 4             # Raise stack poiner
  jr $ra                       # Return


####################################
#        End Binary Search         #
####################################

###################################
#.       Linear Search            #
###################################

linear:
    li $s4, 0       #index i = 0

    j linearLoop

    linearLoop:
        bge $s4, $a2, linearFailed  #if $t0 > target, it jumps out of loop
        lw $t1, 0($a0)          #load the array into t1
        beq $t1, $a3, linearFound   #if array[element] = target, found target
        addi $a0, $a0, 4        #add 4 to the array size
        addi $s4, $s4, 1        #add one to the index

        j linearLoop        #SOS THIS IS NO FUN !!!!!#

    linearFound:
        move $v1, $s4       #move $t0 into $v1
        j exitLoop

    linearFailed:
        li $v1, -1
        j exitLoop

    exitLoop:
        jr $ra

#############################
       # END LINEAR SEARCH #
############################