汇编冒泡排序

最新推荐文章于 2022-11-26 14:41:10 发布
最新推荐文章于 2022-11-26 14:41:10 发布
阅读量2.1w 收藏 97
点赞数 18
分类专栏： 汇编 文章标签： 汇编 冒泡排序 dos
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_20480611/article/details/51167363
版权

学了一段时间汇编，想搞点事情来玩玩，于是整出一个冒泡排序的小程序。

程序功能：

将给定字节数组中的元素排序，并将结果输出到DOS。

功能拆分：

1、排序
最简单最容易想的就是冒泡排序，只有两重循环，而且里外关系明确，所以我们就选它了。

2、输出
DOS有很多中断子程序，其中21号中断的编号为9的功能就可以打印字符串到DOS。

3、转换
排序和输出解决了，中间还有一个很重要的过程：将数字转成字符串。这个需要我们自己手写，原理也很简单，循环对10取余就可以了。

功能实现：

1、冒泡排序
首先我们在数据段申请一块区域存放数组和元素个数：

DATA SEGMENT
        BUF DB 12, 32, -2, 4, 0     ; NUMBER ARRAY BUFFER
        CNT DB $-BUF               ; COUNT FOR BUFFER
DATA ENDS

过程和冒泡排序一样，在内层循环比较内外层的两个数，我们把外层循环的数组下标放在 SI 中，内层的下标放在 DI 中。显然有 DI = SI + 1

每次循环的操作如下：

AX = DS[SI]
DX = DS[DI]
IF (AX > DX):
    SWAP (AX, DX)
    DS[SI] = AX
    DS[DI] = DX

完整的代码如下：

ASSUME CS:CODE,DS:DATA

DATA SEGMENT
        BUF DB 12, 32, -2, 4, 0     ; NUMBER ARRAY BUFFER
        CNT DB $-BUF               ; COUNT FOR BUFFER
DATA ENDS

CODE SEGMENT
START:  MOV AX, DATA
        MOV DS, AX                  ; DATA SEGMENT
        MOV SI, OFFSET BUF          ; BUFFER INDEX
        MOV CL, CNT                 ; LOOP COUNT
        DEC CL
        MOV CH, 0
OUTER:                              ; OUTER LOOP
        MOV AL, [SI]                ; BUF[SI]
        PUSH CX
        MOV DI, SI                  ; BUFFER INDEX
INNER:                              ; INNER LOOP
        INC DI                      ; DI = SI + 1
        MOV DL, [DI]                ; BUF[DI]
        CMP AL, DL                  ; IF (BUF[SI] > BUF[DI])
        JLE CONT                    ; 
        XCHG AX, DX                 ; SWAP (BUF[SI], BUF[DI])
        MOV [SI], AL
        MOV [DI], DL
CONT:   LOOP INNER                  ; CONTINUE 
        POP CX
        INC SI
        LOOP OUTER

        MOV AH, 4CH
        INT 21H
CODE ENDS
END START

我们在 DOSBOX 中测试：
dosbox
可以看到排序前后的结果在内存中。

2、打印字符串
这个很简单，之前说过，调用 DOS 中断子程序就可以了：
字符串偏移地址保存在 DX 中，字符串以 ‘$’ 结尾

DATA SEGMENT
        BUF DB 'WELCOME TO THE DOS!', 13, 10, '$'
DATA ENDS

CODE SEGMENT
    ASSUME CS:CODE,DS:DATA
START:  MOV AX, DATA
        MOV DS, AX
        MOV AH, 09H
        MOV DX, OFFSET BUF
        INT 21H
        MOV AH, 4CH
        INT 21H
CODE ENDS
    END START

运行截图：
dosbox

注意这里有一个换行(0x0d 0x0a)。

3、整数转为字符串
待转化的整数存放在AX 中，字符串存放在DS[DI] 中。
首先AX 对 10 取余，入栈。
然后出栈，转移到BUF 中。
这里要注意如果是负数，必须给出判断条件，并将缓冲区第一个位置设置’-‘。
完整代码如下：

DATA SEGMENT
        BUF DB 16 DUP(0), 13, 10, '$'
DATA ENDS

CODE SEGMENT
    ASSUME CS:CODE,DS:DATA
START:  MOV AX, DATA
        MOV DS, AX
        MOV DI, OFFSET BUF
        XOR AX, AX
        MOV AL, -23
        MOV BX, 10
        MOV CX, 0
        CMP AX, 127             
        JLE MODLP
        NEG AL
        MOV BYTE PTR [DI], '-'  
        INC DI                  
MODLP:  XOR DX, DX
        DIV BX
        ADD DX, 30H
        PUSH DX
        INC CX
        CMP AX, 0
        JG MODLP
STOLP:  POP DX
        MOV [DI], DL
        INC DI
        LOOP STOLP

        MOV DX, OFFSET BUF
        MOV AH, 09H
        INT 21H
        MOV AH, 4CH
        INT 21H

CODE ENDS 
    END START

运行截图：
itos.asm

负数可以正常显示，这里我们利用到上面的字符串输出函数。

函数封装：

我们实现了每个子程序，下面就要将他们合并，我们可以把每个子程序的核心功能部分提取成函数，然后利用这些函数完成数组的排序及输出：
完整代码：

; BUBBLESORT BY WUST_HMK
; 2016-04-16

ASSUME CS:CODE,DS:DATA
DATA SEGMENT
        BUF DB 16 DUP(0), 13, 10, '$'  ; BUFFER TO STORE STRING
        LOL DB 'WELCOME TO THE BUBBLESORT PROGRAM!', 13, 10, '$'
        STR1 DB 'BEFORE SORT:', 13, 10, '$'
        STR2 DB 'AFTER SORT:', 13, 10, '$'
        ARR DB 12, -34, -2, 4, 0        ; NUMBER ARRAY BUFFER, CHANGE IT!!!
        CNT DB $-ARR                   ; COUNT FOR BUFFER
DATA ENDS

CODE SEGMENT
START:  MOV AX, DATA
        MOV DS, AX                  ; DATA SEGMENT
        MOV SI, OFFSET ARR          ; ARRAY INDEX
        MOV DI, OFFSET BUF          ; BUFFER INDEX
        MOV CL, CNT                 ; ELEMENTS COUNT
        MOV CH, 0

        MOV DX, OFFSET LOL          ; PRINT WELCOME
        MOV AH, 09H
        INT 21H

        MOV DX, OFFSET STR1         ; BEFORE SORT 
        MOV AH, 09H
        INT 21H

        MOV SI, OFFSET ARR          ; ARRAY INDEX
        MOV DI, OFFSET BUF          ; BUFFER INDEX
        MOV CL, CNT                 ; ELEMENTS COUNT
        MOV CH, 0
        CALL PRINTARR               ; PRINT ARRAY

        MOV SI, OFFSET ARR          ; ARRAY INDEX
        MOV DI, OFFSET BUF          ; BUFFER INDEX
        MOV CL, CNT                 ; ELEMENTS COUNT
        MOV CH, 0       
        CALL BUBBLESORT             ; BUBBLE SORT

        MOV DX, OFFSET STR2         ; AFTER SORT
        MOV AH, 09H
        INT 21H

        MOV SI, OFFSET ARR          ; ARRAY INDEX
        MOV DI, OFFSET BUF          ; BUFFER INDEX
        MOV CL, CNT                 ; ELEMENTS COUNT
        MOV CH, 0
        CALL PRINTARR               ; PRINT ARRAY

        MOV AH, 4CH
        INT 21H                     ; RETURN TO DOS

;
; FUNCTION NAME: BUBBLESORT
; PARAMETERS:    DS: BASE OF BUFFER
;                SI: OFFSET 
;                CX: NUMBERS COUNT - 1
;
BUBBLESORT PROC NEAR
        PUSH AX
        PUSH BX
        PUSH CX
        PUSH DX
        PUSH SI
        PUSH DI

        DEC CX                      ; LOOP COUNT = ELEMENTS COUNT - 1
OUTER:                              ; OUTER LOOP
        MOV AL, [SI]                ; BUF[SI]
        PUSH CX
        MOV DI, SI                  ; BUFFER INDEX
INNER:                              ; INNER LOOP
        INC DI                      ; DI = SI + 1
        MOV DL, [DI]                ; BUF[DI]
        CMP AL, DL                  ; IF (BUF[SI] > BUF[DI])
        JLE CONT                    ; 
        XCHG AX, DX                 ; SWAP (BUF[SI], BUF[DI])
        MOV [SI], AL
        MOV [DI], DL
CONT:   LOOP INNER                  ; CONTINUE 
        POP CX
        INC SI
        LOOP OUTER

        POP DI
        POP SI
        POP DX
        POP CX
        POP BX
        POP AX
        RET
BUBBLESORT ENDP

;
; FUNCTION NAME: PRINTARR
; ARRAY IN DS[SI], BUFFER IN DS[DI], COUNT CX
PRINTARR PROC NEAR
        PUSH SI
        PUSH DI

        MOV DX, DI
ITERAT: MOV AL, [SI]        ; AL = DS[SI]
        MOV AH, 0
        INC SI
        CALL NTOC           ; CONVERT AX TO STRING 
        MOV AH, 09H
        INT 21H             ; PRINT STRING TO DOS
        CALL CLRBUF         ; CLEAR STRING BUFFER
        LOOP ITERAT

        POP DI
        POP SI
        RET
PRINTARR ENDP

; CONVERT NUMBER TO STRING
; AX TO DS[DI]
NTOC    PROC NEAR
        PUSH BX
        PUSH CX
        PUSH DX
        PUSH DI

        MOV BX, 10              ; DECIMAL BASE
        MOV CX, 0
        CMP AX, 127             ; IF AX > 127 THEN AX = -AX
        JLE MODLP
        NEG AL
        MOV BYTE PTR [DI], '-'  ; NEGTIVE NUMBER SIGN
        INC DI                  
MODLP:  XOR DX, DX
        DIV BX                  ; AX = AX / BX; DX = AX % BX
        ADD DX, 30H             ; DX += 30H, CONVERT DX TO ASCII
        PUSH DX
        INC CX
        CMP AX, 0
        JG MODLP
        MOV AX, CX              ; RETURN AX: LENGTH OF NUMBER
STOLP:  POP DX
        MOV [DI], DL            ; SAVE NUMBER TO STRING BUFFER
        INC DI
        LOOP STOLP

        POP DI
        POP DX
        POP CX
        POP BX
        RET
NTOC    ENDP


; CLEAR DS[DI], COUNT FOR CX (RESERVED)
CLRBUF  PROC NEAR
        PUSH CX
        PUSH DI

        MOV CX, 16                  ; BUFFER LENGTH
BUFCLS: MOV BYTE PTR [DI], 0
        INC DI
        LOOP BUFCLS

        POP DI
        POP CX
        RET
CLRBUF  ENDP
CODE ENDS
    END START

程序有点乱，将就着看看吧。
执行结果：
bubblesort.asm

还是可以的。

总结体会：

第一次独立写一个完整的汇编小程序，期间遇到了很多问题， 有时候程序逻辑没问题，在DOSBOX debug 下可以跑，但是直接运行就挂。然后改了若干遍才发现汇编也会出现变量初始化的问题。
另外汇编程序设计的规范我并不熟悉，所以寄存器的使用很杂乱，还望各位指正。

epsilon1
关注
  • 18
    点赞
  • 踩
  • 97
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
汇编冒泡排序实验报告.docx
03-19
汇编冒泡排序实验报告.docx
汇编语言（五）之冒泡排序程序及其改进方法
XYshaonianhaofang的博客
12-03 2285
汇编语言：冒泡排序及其改进方法 题目 在数据区存放一组数据，要求采用冒泡排序对该数据区中的数据按递增关系排列。 设计思想 1.内层循环 从第一个数开始，依次把相邻的两个数进行比较，即第n个数和第n+1个数进行比较，如果第s[n]<s[n+1]，则n++继续比较；如果s[n]>s[n+1]，交换s[n]和s[n+1]。直到最后剩下的数字全部比较完毕，其实就是取出这些数字里面最大的放在最后...
汇编语言中间接寻址（间接操作数）与变址寻址（变址操作数）的区别
wa_junye的博客
04-24 3679
间接寻址 间接寻址就是使用寄存器作为指针，控制该寄存器的值来寻到数组中的元素，如： array byte 10h,20h,30h; 定义数组 mov esi, offset array; 取数组首地址 inc esi; esi指向数组第2个元素（下标为[1]） 上面的esi作为数组的指针，控制esi来寻到数组中的元素。 变址寻址 通过在原地址上增加一个寄存器、或者在原地址的基础上加上常数等方...
汇编语言编译环境的提供及冒泡排序的汇编语言改进
weixin_41983075的博客
04-13 513
汇编语言 我们都知道汇编语言是比较老的语言，那么从这样一种“古老”的语言使用中，很容易感受到语言的基本逻辑和思想，对语言有一个很基本的了解，本篇文章主要提供给对汇编语言有需求或兴趣的朋友们。 首先，我们要提供一个汇编的环境。在现在的笔记本电脑上应该如何提供呢？这里说一种利用DOSBox软件以及相关程序的方法。 下面是编译环境。 （1） DOSBOX软件（2） 编辑器ED...
汇编语言过程
顺其自然~专栏
12-29 4574
如果大家已经学过了高级编程语言，那么就会知道将程序分割为子过程（subroutine）是多么有用。一个复杂的问题常常要分解为相互独立的任务，这样才易于被理解、实现以及有效地测试。在汇编语言中，通常用术语过程（procedure）来指代子程序。在其他语言中，子程序也被称为方法或函数。就面向对象编程而言，单个类中的函数或方法大致相当于封装在一个汇编语言模块中的过程和数据集合。汇编语言出现的时间远早于面向对象编程，因此它不具备面向对象编程中的形式化结构。汇编程序员必须在程序中实现自己的形式化结构。
微机汇编常见基础知识点汇总
qq_43564001的博客
05-14 803
准备工作 打开指定文件 d: ; 转到d盘 cd \asm ; 进入asm文件夹 编辑和调试程序文件 见：https://blog.csdn.net/YuzuruHanyu/article/details/80287419?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522160268320919725222443196%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&a
汇编基础(五)
IT1995的博客
10-16 4726
汇编基础
x86汇编_间接操作数是遍历数组的理想工具_笔记_12
Silent_Hunter的博客
03-19 384
.data arrayB byte 10h, 20h, 30h, 40h .code mov esi, offset arrayb mov al, [esi] ;al=10h inc esi ;因为arrayB的每个元素只占1字节，所以地址加1即可遍历数组。 mov al, [esi] ;al=20h inc esi mov al, [esi] ;al=30h inc esi mov al, [esi] ;al=40h -------------------------------------...
汇编语言 | 数组相关应用
m0_64449404的博客
11-26 1211
对以下数组 10,267,9,0,68,-516,3,85, 0FCH ,101,-32。4）查找数组中最小元素，绝对值最大元素，排序数组。要求菜单提示选择，调试查看运行结果。1）计算数组中正数累加结果保存到变量 result。3）计算数组中零，正，负数，奇，偶数元素个数分别保存。2）计算数组到负数为止的非负数累加结果保存到变量。
汇编 冒泡排序
12-07
这是一个运行出来，非常正规的汇编语言实验中的冒泡排序。真的很正确
易语言汇编冒泡排序
07-21
易语言汇编冒泡排序源码,汇编冒泡排序,冒泡排序,冒泡排序_汇编
win32汇编语言实现冒泡排序
12-12
win32汇编语言实现冒泡排序,全部的代码插入在文档的最下面。
dos汇编练习(2)——冒泡法排序完整版
Wayne的CSDN博客
11-30 1132
8086的汇编和51单片机的汇编差距还是有点的，最明显的区别就是更难。 经典冒泡法排序的算法思想还是一致贯通的，可参考51单片机汇编_冒泡法排序 huiche macro ;回车宏 mov ah,02h ;02h对应回车ASCII码 mov dl,0ah int 21h mov dl,0dh ;是将DL中的ASCII码显示到屏幕 int 21h endm data segment var db 51h,63h,45h,84h,03h varlen = $ - var str1 db "
汇编排序知识之冒泡排序
热门推荐
杨秀璋的专栏
05-04 1万+
这里简单介绍汇编中是如何进行冒泡排序的,首先先回顾C语言中的冒泡排序知识及算法，再讲解汇编实现的过程，更好的巩固和联系了编程的思想。 一.C语言——冒泡排序 冒泡排序的基本概念: 依次比较相邻的两个数，将小数放在前面，大数放在后面。每完成一遍查找都会找到一个最大数,直至排序结束. 由上表可见每轮排序都能确定一个最大数,直至排序结束,它相对应的C语言代码如下：其中j参数设置为N-i-1 二.汇编——冒泡排序
冒泡排序
看风景的博客
11-28 237
package lsn1.sjjg.cct.cn.lsn1; import org.junit.Test; /** * 冒泡排序 * 适合所有排序数量小于8的排序 * Created by linyaokui on 17/11/28. */ public class BubblingSort { @Test public void test(){ i
汇编——实现冒泡排序+讲解
筱羊冰冰
01-06 9390
题目描述&代码 有一个首地址为A的N字数组，编写程序采用冒泡排序使该数组中的数按照从大到小的次序整序。 数据存储在A的数组中（即内存中），我们需要利用冒泡排序实现从大到小排序。 ;description data SEGMENT USE16 a dw 8,16,41,22,50 n equ ($-a)/2 data ENDS ;description stack SEGMENT USE16 dw 32 dup(?) stack ENDS ;description
用汇编实现冒泡排序
qq_38235017的博客
05-11 2229
对应的C语言代码如下： int number[6]={12,3,2,5,6,7}; for(int i=0;i<6;i++) { for(int j=0;j<6;j++) { if(a[i]<a[j]) { int temp=a[i]; a[i]=a[j]; ...
8086汇编冒泡排序
最新发布
12-25
8086汇编语言实现冒泡排序的代码如下所示： ```assembly DATAS SEGMENT a dw 19,15,13,14,18,62,14,42,35,68 DATAS ENDS STACKS SEGMENT dw 10 dup(0) STACKS ENDS CODES SEGMENT ASSUME CS:CODES,DS:DATAS,SS:STACKS START: mov ax,DATAS mov ds,ax mov cx,10 dec cx ; 为了设置n-1 loop1: push cx mov bx,0 loop2: mov ax,a[bx] cmp ax,a[bx+2] ; 两数比较，小于等于的不变，大于则交换位置 jle continue xchg ax,a[bx+2] mov a[bx],ax continue: add bx,2 ; 因为是字，所以加2实现进行下一个 loop loop2 pop cx loop loop1 MOV AH,4CH INT 21H CODES ENDS END START ``` 这段汇编代码实现了对数组a中的10个元素进行冒泡排序。在每一轮循环中，比较相邻的两个元素，如果前一个元素大于后一个元素，则交换它们的位置。经过多轮循环后，最大的元素会被交换到数组的末尾。最后，数组中的元素就按照从小到大的顺序排列好了。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值