在数组中查找最小值（Intel8086）

Question

I'd like to write a simple program to find the minimum value in an array . I'm using Intel 8086 architecture (if I'm right?). The problem is that I am totally new to Assembly language and well, I just cannot figure out what am I doing wrong in my code, I'm stuck.

At the end (before exiting) my ax register does not contain my result.
I'm afraid it doesn't even place it there (I check registers' values with Turbo Debugger tool).

.MODEL TINY

Data SEGMENT
                        arr_len     EQU 5
                        arr         DB 07h, 02h, 03h, 10h, 12h
                        minimum     DB 255
Data ENDS

Code SEGMENT
                        ORG 100h
                        ASSUME CS:Code, DS:Data, SS:Code
Start:
                        mov ax, SEG Data
                        mov ds, ax  ;load data to ds reg    
                        mov cx, arr_len ;arr_length to counter
                        mov bx, OFFSET arr ;load first elem.
Search: 
                        inc bx
                        cmp bl, [minimum] ;compare loaded elem with min
                        jb Swap ;if bl<minimum
Swap:
                        mov minimum, bl
                        loop Search         

                        mov al, minimum ;result here?
                        mov ax, 4C00h
                        int 21h

Code ENDS
END Start

Could anyone give me advices what is wrong here? Thanks in advance.

Answer 1

• The tiny model doesn't need setting DS explicitly. (CS=DS=ES=SS)
• Since BX points at your array the first time, you should not immediately increment it! Do inc before looping only.
• You didn't really compare an array element but rather the low byte of the address by which you iterate the array.
• There's no sense in putting any result in AL if directly afterwards you exit by putting 4C00h in AX. Viewing AL using a debugger could work though.

Here's a version that can work:

Search: 
    mov al, [bx]
    cmp al, [minimum] ;compare loaded elem with min
    jnb NoSwap        ;if al>=minimum
    mov [minimum], al ;New minimum
NoSwap:
    inc bx
    loop Search

Answer 2

Like Fifoernik's answer explained, your conditional branch jumps to the same place whether it's taken or not, because the branch target is the next insn.

---

Here's how to do it without keeping your minimum in memory as you accumulate it, because that's horrible.

This version accumulates minimum in al , never storing it to memory. I also used string ops for fun. You'll get smaller code size, but maybe slower code than loading with mov . Using si as a source pointer is a good convention to help humans keep track of things, even when not using string ops. Don't make the code worse just for that, of course, but I recommend it when you have the choice.

I also avoid loop because it's slow and wasn't gaining us much of anything . Unless you're going hard-core optimizing for code-size over speed, don't use loop .

.MODEL TINY
Data SEGMENT
    arr         DB 07h, 02h, 03h, 10h, 12h
    arr_len     EQU $-arr                   ; let the assembler calculate the size to avoid mistakes
Data ENDS

Code SEGMENT
    ORG 100h
    ASSUME CS:Code, DS:Data, SS:Code
unsigned_min:
    ;; segment setup not needed with tiny model, according to Fifoernik
    ; assume arr_len >= 2
    mov    si, OFFSET arr       ; src pointer = &first element
    lea    di, [si + arr_len]   ; end pointer.
    ;; mov di, arr_len + OFFSET arr ; also works, since input pointer is static
    ;; or use arr_len + OFFSET arr as an immediate operand for the loop condition, if you don't care about keeping the hard-coded input address out of the loop itself.

    cld                         ; clear the direction flag so string insns count upwards.  Omit if the ABI guarantees this state already
    lodsb                       ; al = min so far = first element, and advance si to point to the second element


;; on entry: AL = 1st element (min).  SI = pointer to 2nd element.  DI = end-pointer
Search:
    cmpsb                       ; compare [si] with current min (al), and ++si
    jae   .no_new_min

    mov    al, [si-1]           ; conditionally skipped.  You could use `cmov` instead of the branch on a CPU supporting 686 insns
.no_new_min
    cmp    si, di               ; loop while si < end
    jb    Search

    ; min is in AL

    mov ah, 4Ch            ; exit with AL as exit status
    int 21h

If you can't assume arr_len >= 2 , then initialize min to 255 or the first element, and enter the loop with it pointing to the first element, instead of 2nd. Or use an extra cmp si,di / jb outside the loop.