How to sort an array using stack in assembly - arrays

Question

I want to sort an array while using the stack:
so first things first I pushed it all into the stack.
then I'm locating the minimum element in the stack, swapping it with the top element popping it out and move it back to the array.
but something isn't right and about halfway there it got messed up (DI is one index below than what it should really be)
data segment
a db 5h,12h,6h,4h,9h
len equ $-a
loop_counter db len
min_index dw 0
min db ?
ends
stack segment
dw 128 dup(0)
ends
code segment ;TODO: Locate min in stack xchg it with top element copy to array and pop it :|
start:
mov ax, data
mov ds, ax
mov bx,0
mov cx,0
mov cl,loop_counter
push_arr_to_stack:
mov al,a[bx]
push ax
inc bx
loop push_arr_to_stack
mov bx,len-1
mov ax,0
mov cl,loop_counter
mov bp,sp
mov ax,[bp]
mov bx,[bp]
mov di,0
mov dx,0
mov si,2
mov di_check,len-loop_counter
find_min_to_arr:
cmp bx,ax
jb new_min
mov bx,[bp+si]
add si,2
loop find_min_to_arr
mov min,al
xchg a[di],al
jmp pop_min
new_min:
mov ax,bx
mov bx,[bp+si]
mov min_index,si
sub min_index,2
add si,2
dec cx
jmp find_min_to_arr
pop_min:
mov dx,[bp]
xchg di,min_index
mov [bp+di],dx
xchg di,min_index
pop dx
mov dx,0
inc di
mov si,0
cmp di,len
je b
dec loop_counter
mov cl,loop_counter
jmp find_min_to_arr
b:
mov ax, 4c00h ; exit to operating system.
int 21h
ends
end start

Answer 1

first I pushed it all into the stack.
This part is fine although for speed reasons you should forget about loop .. and replace it with dec cx followed by jnz ..
then I'm locating the minimum element in the stack, swapping it with the top element popping it out and move it back to the array.
Here your code gets very complicated and it contains many errors. Also the code does not perform true swapping between the located minimum and the element at the top of the stack.
I tried amending your code but as is often the case, it is beyond repair. Below is my rewrite that you should study, not just copy!
I have defined the loop_counter a word variable because that's easier. Additionally I kept it in the DX register that was sitting there doing nothing...
Pushing it all into the stack
mov bx, dx
push_arr_to_stack:
mov al, a[bx-1]
push ax
dec bx
jnz push_arr_to_stack
I push the array in reverse so the stack has the elements in the same order as the original array. This is not necessary for the task, but it is simpler and it leaves the BX register at zero for use below.
Locating the minimum in the stack
Again:
mov bp, sp
xor si, si
mov al, [bp+si] ; Chosen minimum
mov di, si ; Remember its position
mov cx, dx
dec cx ; N elements = N-1 compares
jz .c
.a: add si, 2
cmp al, [bp+si]
jbe .b
mov al, [bp+si] ; New minimum
mov di, si ; Remember its position
.b: dec cx
jnz .a
Swapping it with the top element
.c: xchg al, [bp]
mov [bp+di], al
Popping it out and moving it back to the array
pop ax
mov a[bx], al
inc bx
dec dx
jnz Again
The important thing here is that the above exactly does what the task description said.