如何用汇编语言实现排序

用汇编语言实现排序，滑陆橡通常使用冒泡法。将数据段DATA开始的16个数排序，前小后大，程序示例如下：

DATAS SEGMENT

DATA DB 74,68,58,66,69,254,186,6,10,98,34,90,128,222,33,0

COUNT DB 10H

DATAS ENDS

CODES SEGMENT

ASSUME CS:CODES,DS:DATAS,ES:DATAS

START:

MOV AX,DATAS

MOV DS,AX

MOV ES,AX

MOV BL,1 用BL来检验是否排序完成，减少循环次数

LOOP1:

CMP BL,0

JE CMPEND 若相等则跳转

XOR BL,BL 将BL清零

MOV CL,COUNT COUNT用于外层的计数

DEC CL CL减一，CL用于内层的计数

PUSH CX将CX压入信旁堆栈

LEA DI,DATA将数据段首地址赋值给悉岁DI

LOOP2:

MOV AL,[DI]

CMP AL,[DI+1] 将前一个数与后一个数比较

JLE LOOP3 若前一个数小于或等于后一个数，则跳转到LOOP3

XCHG [DI+1],AL前者大于后者，则交换两数

MOV [DI],AL 如果前一个数字大于后一个数字，则交换

MOV BL,1

LOOP3:

INC DI指针加一

LOOP LOOP2循环L00P2，直到CX==0成立

POP CX将CX从堆栈中d出

MOV COUNT,CL 改变外层计数器的值

JMP LOOP1

CMPEND:

MOV AH,4CH 带返回码结束功能

INT 21H返回系统

CODES ENDS

END START

        CODE  SEGMENT

              ASSUME    CS:CODE

              ORG       100H

      START:  JMP       BEGIN

        ARR1  DB        3AH,80H,0BH,55H,0FFH

         NUM  EQU       $-ARR1

      BEGIN:  PUSH      CS

              POP       DS

              PUSH      CS

              POP       ES

              LEA       SI,ARR1

              MOV       CX,NUM

              CALL      SORTBYTE

              LEA       SI,ARR1

              MOV       CX,NUM

         @0:

              LODSB

              CBW

              CALL      DISPAXS

              LOOP      @0

              MOV       AH,4CH

              INT       21H

 

===============================================

 字节数组排序（有符号数冒泡排序）

    SORTBYTE  PROC      NEAR

       数组长度置入cx，数组首地址置入 si

              PUSH      AX

              PUSH      CX

              PUSH      DX

              PUSH      SI

              PUSH      DI

              PUSHF

              PUSH      CX

              POP       DX

              DEC       裤好DX

   @SORTBL1:

              MOV       CX,DX

              MOV       DI,SI

   @SORTBL2:

              MOV       AL,[DI+1]

              CMP       AL,[DI]

              JL        @SORTBNEXT   从大到小（无符号换成 JB）

              XCHG      AL,[DI]

              MOV       [DI+1],AL

 @SORTBNEXT:

              INC       DI

              LOOP      @SORTBL2

              DEC       DX

              JNZ       @SORTBL1

              POPF

              POP       DI

              POP       SI

              POP       DX

              POP       CX

              POP       AX

              RET

    SORTBYTE  ENDP

===============================================

  将要显示的有符号数置于 ax 中

     DISPAXS  PROC      NEAR

              PUSH      AX

              PUSH      BX

              PUSH      CX

              PUSH      DX

              PUSH      SI

              PUSH      DI

              PUSH      BP

              PUSH      DS

              PUSH      ES

              PUSHF

              PUSH      CS

              POP       DS

              PUSH      CS

              POP       ES

              MOV       CX,6

              LEA       DI,DISPAXSS

   @DISPAXS:

              MOV       BYTE PTR [DI],32

              INC       DI

           游配   LOOP      @DISPAXS

              PUSH      AX

              MOV       DL,32

              MOV       AH,2

              INT       21H

              POP       AX

              MOV       BYTE PTR NZS,0

              MOV       BYTE PTR SIGNS,0

              CMP       AX,0

              JGE       @DISPAXS0

              MOV       BYTE PTR SIGNS,1

              NEG       AX

  @DISPAXS0:

              PUSH      AX

              LEA       SI,DIVARRS

              LEA       DI,DISPAXSS

              INC       DI

              MOV       CX,5

  @DISPAXS1:

              POP       AX

              MOV       DX,0

              MOV       BX,[SI]

              DIV       BX

              PUSH      DX

              CMP       AL,0

              JNE       @DISPAXS2

              CMP       BYTE PTR NZS,1

              JE        @DISPAXS2

              CMP       CX,1

              JE        @DISPAXS2

              MOV       DL,20H

              JMP       @DISPAXS3

  @DISPAXS2:

              ADD       AL,30H

              MOV       DL,AL

              MOV       BYTE PTR NZS,1

  @DISPAXS3:

              MOV       BYTE PTR[DI],DL

              INC       SI

              INC       SI

              INC       DI

              LOOP      @DISPAXS1

              POP       DX

              CMP       BYTE PTR SIGNS,1

              JNE       @DISPAXS6

              LEA       SI,DISPAXSS

              ADD       SI,5

  @DISPAXS4:

              CMP       BYTE PTR [SI],32

              JE        @DISPAXS5

              DEC       SI

              JMP       @DISPAXS4

  @DISPAXS5:

              MOV       BYTE PTR [SI],'-'

  @DISPAXS6:

              LEA       DX,DISPAXSS

              MOV       AH,9

              INT       21H

              POPF

              POP       ES

              POP       DS

              POP       BP

              POP       DI

              POP       SI

              POP       DX

             神纯指 POP       CX

              POP       BX

              POP       AX

              RET

     DIVARRS  DW        10000,1000,100,10,1

         NZS  DB        0

       SIGNS  DB        0

    DISPAXSS  DB        32,32,32,32,32,32,'$'

     DISPAXS  ENDP

================================== 

        CODE  ENDS

              END       START

以下是输入20个以下的字符，用冒泡法按指胡从小到大排列输出的程序，希望对你用扰纯所帮助：

data segment

da1 db 20,?,20 dup (0)

data ends

stack segment stack

dw 20 dup (0)

stack ends

code segment

assume cs:code,ds:data,ss:stack

start:

mov ax,data

mov ds,ax

lea dx,da1

mov ah,0ah

int 21h

lea bx,da1+1

mov cl,[bx] ；保存唯李拦字符个数

inc bx ；ds:bx指向第一个字符

mov ch,1

goon1:

cmp ch,cl

jnb over1

mov dl,1

mov si,0

goon2:

mov al,cl

sub al,ch

cmp dl,al

ja over2

mov al,[bx+si]

cmp al,[bx+si+1]

jna over3

mov al,[bx+si]

xchg al,[bx+si+1]

mov [bx+si],al

over3:

inc dl

inc si

jmp goon2

over2:

inc ch

jmp goon1

over1:

mov dx,bx

mov ch,0

add bx,cx

mov al,'$'

mov [bx],al 把结束标志变为$

mov ah,9

int 21h

mov ax,4c00h

int 21h

code ends

end start

---