用8086汇编语言设计一个排序算法（从大到小）演示器，在数组中已有10个未排序的整数，输入数字X（0<=X<=3）。 如果X=0，则原样输出10个未排序的整数，数之间用“，”间隔 如果X=1，将数当做无符号数进行排序，并展示排序过程； 如果X=2，将数当做有符号数进行排序，并展示排序过程； 如果X=3，将数当做移码进行排序，并展示排序过程； 如果X输入非法，则通过输出提示，并退出到DOS系统。

下面给出一个基于冒泡排序算法的8086汇编程序，可以根据输入的数字X进行对应的排序操作，并展示排序过程。

.model small
.stack 100h

.data
arr dw 1234h, 4321h, 5678h, 8765h, 2345h, 3456h, 7890h, 8901h, 4567h, 6789h
n dw 10
msg1 db '请输入数字X（0<=X<=3）：$'
msg2 db '输入非法，请重新运行程序！$'
msg3 db '排序前的数组：$'
msg4 db '排序后的数组（无符号数）：$'
msg5 db '排序后的数组（有符号数）：$'
msg6 db '排序后的数组（移码）：$'
msg7 db ',', '$'

.code
start:
    mov ax, @data
    mov ds, ax

    mov ah, 9
    lea dx, msg1
    int 21h

    ; 读取数字X
    mov ah, 1
    int 21h
    sub al, '0'
    cmp al, 3
    ja invalid
    mov bl, al

    ; 输出排序前的数组
    mov ah, 9
    lea dx, msg3
    int 21h
    mov cx, n
    lea si, arr
    loop1:
        mov ax, [si]
        call print_num
        inc si, 2
        cmp cx, 1
        je endloop1
        mov ah, 9
        lea dx, msg7
        int 21h
        loop loop1
    endloop1:
        mov ah, 13h
        int 10h

    ; 根据数字X进行排序
    mov cx, n
    lea si, arr
    cmp bl, 1
    je sort_unsigned
    cmp bl, 2
    je sort_signed
    cmp bl, 3
    je sort_1s_comp
    jmp exit

sort_unsigned:
    mov bx, cx
    dec bx
    mov dx, 0
    outerloop1:
        mov cx, bx
        mov bx, 0
        innerloop1:
            mov ax, [si]
            cmp ax, [si+2]
            jbe skip1
            xchg ax, [si+2]
            mov [si], ax
            mov bx, si
            skip1:
                add si, 2
                loop innerloop1
        dec cx
        jnz outerloop1
    mov ah, 9
    lea dx, msg4
    int 21h
    mov cx, n
    lea si, arr
    loop2:
        mov ax, [si]
        call print_num
        inc si, 2
        cmp cx, 1
        je endloop2
        mov ah, 9
        lea dx, msg7
        int 21h
        loop loop2
    endloop2:
        mov ah, 13h
        int 10h
    jmp exit

sort_signed:
    mov bx, cx
    dec bx
    mov dx, 0
    outerloop2:
        mov cx, bx
        mov bx, 0
        innerloop2:
            mov ax, [si]
            cwd
            idiv word ptr 32768
            cmp ax, [si+2]
            jbe skip2
            xchg ax, [si+2]
            mov [si], ax
            mov bx, si
            skip2:
                add si, 2
                loop innerloop2
        dec cx
        jnz outerloop2
    mov ah, 9
    lea dx, msg5
    int 21h
    mov cx, n
    lea si, arr
    loop3:
        mov ax, [si]
        call print_num
        inc si, 2
        cmp cx, 1
        je endloop3
        mov ah, 9
        lea dx, msg7
        int 21h
        loop loop3
    endloop3:
        mov ah, 13h
        int 10h
    jmp exit

sort_1s_comp:
    mov bx, cx
    dec bx
    mov dx, 0
    outerloop3:
        mov cx, bx
        mov bx, 0
        innerloop3:
            mov ax, [si]
            neg ax
            cmp ax, [si+2]
            jbe skip3
            neg ax
            xchg ax, [si+2]
            neg ax
            mov [si], ax
            mov bx, si
            skip3:
                add si, 2
                loop innerloop3
        dec cx
        jnz outerloop3
    mov ah, 9
    lea dx, msg6
    int 21h
    mov cx, n
    lea si, arr
    loop4:
        mov ax, [si]
        call print_num
        inc si, 2
        cmp cx, 1
        je endloop4
        mov ah, 9
        lea dx, msg7
        int 21h
        loop loop4
    endloop4:
        mov ah, 13h
        int 10h
    jmp exit

invalid:
    mov ah, 9
    lea dx, msg2
    int 21h
    jmp exit

exit:
    mov ah, 4ch
    int 21h

print_num proc near
    push bx
    push cx
    push dx
    push si

    mov bx, 10
    mov cx, 0
    divloop:
        xor dx, dx
        div bx
        push dx
        inc cx
        or ax, ax
        jnz divloop

    pop ax
    mov dl, '0'
    add dl, al
    mov ah, 2
    int 21h

    pop dx
    cmp cx, 0
    je endloop
    pop ax
    add al, '0'
    mov ah, 2
    int 21h
    dec cx
    jmp poploop
    endloop:

    pop si
    pop dx
    pop cx
    pop bx
    ret
print_num endp

end start

程序中使用了print_num过程来输出数字，其中使用了栈来实现反转数字的操作。

为了展示排序过程，我们在每个排序算法中加入了输出排序前和排序后的数组的代码，并且使用了字符串来进行分隔。