汇编语言实现冒泡排序(一)
汇编--BubbleSort(冒泡排序)
一、实验目的1. 掌握循环程序的设计方法；2. 了解循环结构在程序中的重要作用起泡排序程序。
二、实验原理及基本技术路线图（方框原理图）循环结构分DO_WHILE和DO_UNTIL两种，无论使用哪种循环结构，循环程序一般应包括以下几部分：①循环初始化。
它包括设置循环次数的初始值、地址指针的初始设置等。
②循环体。
这是循环工作的主体，包括要重复执行的操作，以及循环的修改部分。
修改部分包括地址指针的修改、循环控制条件的修改等。
③循环控制部分。
它是控制循环的关键，判断循环条件满足与否。
特别要注意循环入口和循环次数的正确设置、地址指针及循环控制条件的修改等。
否则会得不到期望的结果。
以下为冒泡算法的流程图：三、所用仪器、材料（设备名称、型号、规格等）1. 操作系统平台：Windows Server 20032. 汇编环境：Microsoft MASM 5.03. 文本编辑器：记事本四、实验方法、步骤1. 将MASM5.0的文件置于C:\assembly\目录下；2. 将masm.exe和link.exe所在目录（C:\assembly\MASM5）添加到Path环境变量中；3.在C:\assembly\下新建一个bubble.asm文件，打开bubble.asm，输入汇编程序代码；4. 运行一个命令行窗口，将当前目录切换到C:\assembly\，然后输入命令：masm bubble.asm [Enter]，来汇编程序，根据汇编结果查看程序代码是否有语法错误，如有，则更正保存后重新汇编，直至没有错误为止，此时会生成bubble.obj文件；5. 输入命令：link bubble.obj [Enter]，观察输出结果，如果没有错误，则生成bubble.exe；6. 输入命令：debug bubble.exe [Enter]，调试程序，并记录运行过程；7. 完成实验报告。
五、实验过程原始记录(数据、图表、计算等)1. 将C:\assembly\MASM5目录添加到Path环境变量中：2. 新建名为bubble.asm的文件，输入汇编程序代码：程序源码：STACKSG SEGMENT STACK 'S'DW 64 DUP('ST')STACKSG ENDSDATA SEGMENTARY DW 5,7,1,4,3,6,9,8,2 ;数组,流程图中为ACT EQU ($-ARY)/2 ;元素个数DATA ENDSCODE SEGMENTASSUME CS:CODE, DS:DATA, SS:STACKSG MAIN PROC FARMOV AX,DATAMOV DS,AXMOV DI,CT-1 ;初始化外循环次数LOP1: MOV CX,DI ;置内循环次数MOV BX,0 ;置地址指针LOP2: MOV AX,ARY[BX]CMP AX,ARY[BX+2] ;两数比较JGE CONT ;次序正确转XCHG AX,ARY[BX+2] ;次序不正确互换位置MOV ARY[BX],AXCONT: ADD BX,2 ;修改地址指针LOOP LOP2 ;内循环控制DEC DI ;修改外循环次数JNZ LOP1 ;外循环控制MOV AX,4C00HINT 21HMAIN ENDPCODE ENDSEND MAIN3. 汇编源程序：4. 连接生成可执行文件：5.调试程序：（1）初始化外循环次数(DI)=0008H（2）置内循环次数和地址指针（3）第一趟第一次比较，因为5＜7，故互换位置，进行下一次比较（5）修改地址指针，继续内循环（6）第一趟第二次比较，因为5＞1，故直接更改地址指针，进行下一次比较（7）第一趟第三次比较，因为1＜4，故互换位置，进行下一次比较（8）第一趟第四次比较，因为1＜3，故互换位置，进行下一次比较（9）第一趟第五次比较，因为1＜6，故互换位置，进行下一次比较（10）第一趟第六次比较，因为1＜9，故互换位置，进行下一次比较（11）第一趟第七次比较，因为1＜8，故互换位置，进行下一次比较（12）第一趟第八次比较，因为1＜2，故互换位置（13）第一趟循环结束，最小数1被交换至数组的最后位置（14）第二趟循环结束，次小数2被交换至数组的倒数第二个位置（15）第三趟循环结束，数字3归位（16）第四趟循环结束，数字4归位（17）第五趟循环结束，数字5归位（19）第七趟循环结束，数字7归位（20）第八趟循环结束，数字8归位（22）排序结束，程序退出六、实验结果、分析和结论（误差分析与数据处理、成果总结等。
汇编语言冒泡排序
汇编语⾔冒泡排序终于可以看懂很简单很简单的汇编语⾔代码了，很有成就感^^下⾯是⼀冒泡排序的汇编语⾔代码。
先对代码简要说明⼀下：像“NEXT0:”，以字符串加冒号构成的是⼀个标签，翻译成汇编指令时会⽤偏移地址替代。
原数据放在SOURCE代表的内存单元中，排序后的数据放在RESULT代表的内容单元中。
在冒泡算法中，有两层循环，其中，寄存器BX控制外层循环，CX控制内层循环。
N EQU 4STAC SEGMENT STACKDB 128 DUP (?)STAC ENDSDATA SEGMENTSOURCE DW 7003h,7002h,7008h,7001hRESULT DW N DUP(0)DATA ENDSCODE SEGMENTASSUME CS:CODE, DS:DATA, SS:STACSTART PROC FARPUSH DSXOR AX,AXPUSH AXMOV AX,DATAMOV DS,AXLEA SI,SOURCELEA DI,RESULTMOV CX,NNEXT0: MOV AX,[SI]MOV [DI],AXADD SI,2ADD DI,2LOOP NEXT0CLDMOV BX,N-1MAL1: LEA SI,RESULTMOV CX,BXNEXT: LODSWCMP [SI],AXJAE CONTXCHG [SI],AXMOV [SI-2],AXCONT: LOOP NEXTDEC BXJNZ MAL1RETSTART ENDPCODE ENDSEND START这段代码经过link后⽣成的汇编指令如下：14C1:0000 1E PUSH DS14C1:0001 33C0 XOR AX,AX14C1:000350 PUSH AX14C1:0004 B8C014 MOV AX,14C014C1:0007 8ED8 MOV DS,AX14C1:0009 8D360000 LEA SI,[0000]14C1:000D 8D3E0800 LEA DI,[0008]14C1:0011 B90400 MOV CX,000414C1:0014 8B04 MOV AX,[SI]14C1:00168905 MOV [DI],AX14C1:0018 83C602 ADD SI,+0214C1:001B 83C702 ADD DI,+0214C1:001E E2F4 LOOP 001414C1:0020 FC CLD14C1:0021 BB0300 MOV BX,000314C1:0024 8D360800 LEA SI,[0008]14C1:0028 8BCB MOV CX,BX14C1:002A AD LODSW14C1:002B 3904 CMP [SI],AX14C1:002D 7305 JNB 003414C1:002F 8704 XCHG AX,[SI]14C1:0031 8944FE MOV [SI-02],AX 14C1:0034 E2F4 LOOP 002A14C1:0036 4B DEC BX14C1:0037 75EB JNZ 002414C1:0039 CB RETF14C1:003A 0000 ADD [BX+SI],AL 14C1:003C 0000 ADD [BX+SI],AL 14C1:003E 0000 ADD [BX+SI],AL。
ARMC语言调用汇编函数实现冒泡排序
ARMC语⾔调⽤汇编函数实现冒泡排序使⽤冒泡排序将指定数组排序后输出排序函数使⽤汇编语⾔编写，C语⾔调⽤汇编语⾔在控制台显⽰排序前后的结果⼀、问题分析本程序的关键是如何使⽤汇编语⾔实现冒泡排序算法。
可以仿照C语⾔的代码流程，分步骤写出汇编的代码。
⾸先要写出最内层的代码部分，也就是数据交换的汇编代码，数据交换可以使⽤str数据装载指令实现。
之后要考虑内层循环的代码，可以通过cmp指令控制循环次数。
最后是编写最外层的循环代码，也是使⽤cmp指令，来控制整个排序的次数。
⼆、代码编写2.1 C语⾔代码#include <stdio.h>extern void sort(char* num, int count);int main(){char number[10] = {'a', 'c', 'b', 'e', 'd', 'f', 'h', 'g', 'j', 'i'};printf("Before: %s\n", number);sort(number, 10);printf("After: %s\n", number);return 0;}C语⾔中⽐较重要的是，⾸先要声明外部函数sort，也就是由汇编代码实现的函数。
其代码流程为：初始化1个10字节的char类型的数组在控制台输出初始化的数据调⽤汇编函数进⾏排序显⽰排序后的结果2.2 汇编代码area sort, code, readonlyglobal sortstartmov r2, #-1 ; r2->i, i=-1sub r8, r1, #1 ; r1->countloopcmp r2, r8 ; 控制外层循环bge stopadd r2,r2, #1 ; i=i+1mov r3, #-1 ; r3=j, j=-1loop0add r3, r3, #1 ; j=j+1add r4, r3, #1 ; r4=j+1sub r7, r8, r2 ; 控制内层循环cmp r3, r7bge loopldrb r5, [r0, r3] ; r5=a[j]ldrb r6, [r0, r4] ; r6=a[j+1]cmp r5, r6 ; ⽐较 a[j] 和 a[j+1]blt loop0swapstrb r5, [r0, r4] ; 交换 a[j] 和 a[j+1]strb r6, [r0, r3]b loop0stopend汇编语⾔代码是仿照的C语⾔的冒泡排序流程实现的，其⼤致流程为：⾸先初始化R2，R2⽤来控制外层循环的次数。
史上最牛最完整的汇编语言冒泡排序程序
;题目：编制一个完整的汇编语言程序，从键盘上读入若干个（可以超过十个）十进制数（正数），排序后在屏幕上输出。
;采用冒泡法排序，综合运用子程序和宏汇编，使程序模块化。
;程序代码M_DIRECT MACRO STRING ;定义一个宏，调用09 号DoS功能在屏幕上显示一个字符串MoV DX,oFFSETAH,O921H STRINGMoVINTENDMDATA SEGMENTDIR1 DB 'count of numbers tosort:$ ' ;提示输入要排序的数据的个数DIR2 DB 'please input sorting numbers:$ '; 提示输入要排序的数据DIR3 DB 'sorting result:$ ' ;在屏幕上提示排好续的数据DIR4 DB '*************************$ 'DIR5 DB 'please choose u(up)ord(down):$ 'DIR6 DB 'input error$ 'CoUNT=1OOWTEMP DW ?ARRAY DW CoUNT DUP(?) ;用来保存输入的数据CRLF DB 13,1O, '$ ' ;实现回车换行的功能,13→ODH,回车；10→OAH,换行LENDW;保存实际输入的数据的个数DATA ENDSCoDE SEGMENTMAIN PRoC FARASSUME CS:CoDE,DS:DATASTART:PUSH DSSUBAX,AXPUSH ;置AX 为OAXMOVAX,DATA ;将数据段的地址送到DX 中MOV DS,AXREAD: M_DIRECT DIR1 ; 宏调用，在屏幕上提示输入要输入的数据的个数CALLP_GETNEW ；调用子程序P-GETNEW输入要输入的数据的个数MOV CX,AXMOV LEN,AXLEA BX,ARRAYMOVAH,09; 调用09 号功能，实现回车换行LEA DX,CRLFINT21H ;屏幕提示输入要排序的数据M_DIRECT DIR2GETNUMBER: CALL P_GETNEW ; 输入数据并保存到ARRA 丫中MOV [BX],AXADD BX ,2LOOP GETNUMBERCX,LENSORT:; 排序程序部分MOV DEC CXMOV AH,09HLEA DX,CRLFINT21HM_DIRECT DIR5COMPARE:MOV AH,01HINT21HCMP AL,'U' ;判断是升序排序还是降序排序JZJMP;排序完后跳转到输出程序部分UP；输入的字符是U 或U 跳转到升序排序程序CMP AL, 'u'JZUPCMP'D'；输入的字符是D 或d 跳转到降叙排序程序JZ DOWNCMPAL, 'd'JZDOWNUP:DI,CX; 升序排序程序MOVBX,0 LOOP1:MOVAX,ARRAY[BX]CMPAX,ARRAY[BX+2]JNGECONTINUE1XCHG AX,ARRAY[BX+2]MOVARRAY[BX],AXCONTINUE1: ADDBX,2LOOP LOOP1MOVCX,DILOOPUPJMPOUTPUT; 排序完后跳转到输出程序部分DOWN:DI,CX;降序排序程序MOVBX,0 LOOP2:MOVAX,ARRAY[BX]CMPAX,ARRAY[BX+2]JGECONTINUE2XCHG AX,ARRAY[BX+2]MOVARRAY[BX],AXAL,MOVMOVCONTINUE2:ADDBX,2LOOP LOOP2 MOV CX,DILOOP DOWNOUTPUTOUTPUT: MOV AH,09 ;回车换行LEA DX,CRLFINT 21HM_DIRECT DIR3CX,LENMOV;为输出程序设置好入口参数MOV BX,OFFSET ARRAYWRITE: MOV AX,[BX] 输出排好序的数据WTEMP,AXMOV;将入口参数存放到共享变量中CALL P_OUTPUTADD MOV DL,20H 开MOVINTLOOPBX,2; 显示空格，将两个输出的数据分AH,02H21HWRITEAH,09 AH,09MOVLEA DX,CRLFINT 21HM_DIRECTMOVLEA DX,CRLFINT 21HLOOP READRET;隔离两次输入排序输出的作用DIR4;实现循环输入数据并排序输出MAIN ENDP;从键盘上输入一个数据的子程序P_GETNEW PROCPUSH BX ; 出口参数：AX=补码表示的二进制数PUSH DXXORBX,BX ；BX 保存结果XORCX,CX;CX 为正负标志， 0为正， -1 为负MOVAH,1；输入一个字符INT21HCMPAL, '+'； 是“ +”，继续输入字符JZREAD1CMPAL, '-'； 是“—，设置 -1 标志JNZREAD2MOVCX,-1READ1:MOV AH,1； 继续输入字符INT21HREAD2:CMPAL, '0'；不是 0~9 之间的字符，则输入数据结束JBREAD3CMPAL, '9'JAREAD3SUBAL,30H；是 0~9之间的字符，则转换为二进制数;利用移位指令，实现数值乘10: BX^BX*10SHLBX,1MOVDX,BXSHLBX,1SHLBX,1ADDBX,DXMOVAH,0ADDBX,AX； 已输入数值乘 10 后，与新输入的数值相加JMPREAD1； 继续输入字符READ3:CMP CX,0 ； 是负数，进行求补JZ READ4NEGBXREAD4:MOVAX,BX ； 设置出口参数POP DX;说明：负数用“-”引导，数据范围是 +32767~-32768PUSH CXPOP CXPOP BXRETP_GETNEW ENDP;子程序返回;用冒泡法排序的子程序（从大到小）;P_SORT PROC;RET;子程序返回;P_SORT ENDP;数据输出子程序P_OUTPUT PROCWTEMPWRITE1:值）WRITE2: 推退出标志WRITE3:PUSH AX ;入口参数：共享变量PUSH BXPUSH DXMOV AX,WTEMP ;取出显示的数据TEST AX,AX ;判断数据是零、正书还是负数JNZ WRITE1MOV DL, '0' ;是‘ 0'，显示‘ 0'后退出MOV AH,2INT 21HJMP WRITE5WRITE2 ; 是负数，显示“ -”MOV BX,AX ;AX 数据暂存于BXMOV DL, '-'MOV AH,2INT 21HMOV AX,BXNEG AX ;数据求补（绝对BX,10PUSH BX ;10 压入堆栈，做为AX,0 ;数据（商）为零，转向显示JZ WRITE4SUB DX,DX ;扩展被除数DX.AX JNSMOVCMP∏码后高位压入堆栈WRITE4: 弹出堆栈出WRITE5:DIVADDPUSHJMPPOP DXCMPJEMOVINTJMPPOP DXPOPPOPBXDL,30HDXWRITE3DL,10WRITE5AH,2 21HWRITE4MOVP_OUTPUTMOVINTRETENDPBXAXDL,20HAH,02H21HCODE ENDSEND START; 数据除以10;余数（0~9）转换为ASC;数据各位先低位;数据各位先高位后低位;是结束标志10，则退;进行显示;子程序返回。
汇编语言实现冒泡排序(一).
; 用汇编语言实现实现冒泡排序,并将排序后的数输出DATAS SEGMENTA dw 100,344,3435,43433,3438,343,134,80,8,1000,65535,54,45 N =$-A ; 计算数字所占的字节数DATAS ENDSCODES SEGMENTASSUME CS:CODES,DS:DATASSTART :MOV AX,DATASMOV DS,AXMOV SI,0 ;SI 遍历数字 ; 前一个数的地址MOV CX,N/2-1 ; 设置循环次数, M(M=N/2个数需要,循环 M-1次 CALL BUBBLE ; 调用 BUBBLE 将原来的数排序; 输出排序后的数MOV CX,N/2 ; 循环 M 次输出排序后的 M 个数MOV SI,0 ;SI 遍历排序后的数MOV DI,0 ; 用 DI 记录数字的位数MOV BP,N+5 ;BP 用于遍历存储的转化后的字符的位置SHOW: PUSH CX ; 循环次数入栈MOV DX,0 ; 由于将要进行 16位除需要置高 16位为 0MOV AX,[SI] ; 低 16位为排序后的数CALL DTOC ; 调用 DTOC 将十进制数转换为字符串CALL SHOW_STR ; 调用 SHOW_STR将一个数转化得到的字符串输出 ADD SI,2 ; 下一个数POP CX ; 循环次数出栈栈LOOP SHOWMOV AH,4CHINT 21H; 冒泡排序BUBBLE PROCL1: PUSH CX ; 将循环次数入栈LEA SI,A ;SI 遍历 DATAS 数据段的数字L2: MOV AX,A[SI] ; 将前一个数存于 AXCMP AX,A[SI+2] ; 比较前后两个数JBE NEXT ; 如果前一个数小于或等于后一个数则继续本轮的比较 XCHG AX,A[SI+2] ; 否则,交换前后两个数的位置MOV A[SI],AXNEXT:ADD SI,2 ; 下一个数LOOP L2 ; 注意内层循环的次数已经确定了POP CX ; 将循环次数出栈LOOP L1 ; 下一轮比较RETBUBBLE ENDP; 将十进制数转换为字符串并储存起来DTOC PROCS:MOV CX,10 ; 将除数 10,放入 CX 中CALL DIVDW ; 调用 DIVDW 程序ADD CL,30H ; 把数字转换为 ASCII 码,这样就能显示了MOV DS:[BP],CL ; 把 ASCII 码放到内存中INC DI ; 用 DI 记录循环的次数PUSH AX ; 将低 16位入栈ADD AX,DX ; 将高位与低位相加,接着判断是否已经除尽JZ BACK ; 除尽后返回调用处POP AX ; 将低 16位出栈DEC BP ; 逆序存放转化后的字符,便于主程序调用 SHOW_STR JMP S BACK:POP AX ; 为了得到正确的 IP 值,需要出栈一次RETDTOC ENDP; 子程序定义开始 , 功能是分离被除数的各个位的数字; 公式:X/N=int(H/N*65536+[rem(H/N*65536+L]/NDIVDW PROCPUSH AX ; 低 16位入栈MOV AX,DX ; 将高 16位写入 AX,MOV DX,0 ; 将高 16位置零DIV CX ; 将新的数除 10,MOV BX,AX ; 将商 int(H/N转移到 BX ,默认余数 rem(H/N在 DX POP AX ; 将低 16位出栈,DIV CX ; 将 [rem(H/N*65536+L]除 10, 默认余数在 DXMOV CX,DX ; 将余数转移到 CXMOV DX,BX ; 将商 int(H/N转移到 dx, 相当于 int(H/N*65536RET ; 子程序定义结束DIVDW ENDP; 实现字符串的输出SHOW_STR PROCS2:MOV AH,2 ; 输出数字转化后的字符串MOV DL,DS:[BP]INT 21HINC BP ; 顺序输出DEC DI ; 数字的位数减一JZ OK ; 字符串输出完了就结束JMP S2 ; 否则继续输出OK:MOV AH,2 ; 输出空格MOV DL,0INT 21HRETSHOW_STR ENDPCODES ENDSEND START; 实现冒泡排序,并将排序后的数输出DATAS SEGMENTA dw 100,344,3435,43433,3438,343,134,80,8,1000,65535,54,45 N=$-A ; 计算数字所占的字节数DATAS ENDSCODES SEGMENTASSUME CS:CODES,DS:DATASSTART :MOV AX,DATASMOV DS,AXMOV SI,0 ;SI 遍历数字 ; 前一个数的地址MOV CX,N/2-1 ; 设置循环次数, M(M=N/2个数需要,循环 M-1次 CALL BUBBLE ; 调用 BUBBLE 将原来的数排序; 输出排序后的数MOV CX,N/2 ; 循环 M 次输出排序后的 M 个数MOV SI,0 ;SI 遍历排序后的数MOV DI,0 ; 用 DI 记录数字的位数MOV BP,N+5 ; 用于遍历存储的转化后的字符的位置SHOW: PUSH CX ; 循环次数入栈MOV DX,0 ; 由于将要进行 16位除需要置高 16位为 0MOV AX,[SI] ; 低 16位为排序后的数CALL DTOC ; 调用 DTOC 将十进制数转换为字符串CALL SHOW_STR ; 调用 SHOW_STR将一个数转化得到的字符串输出 ADD SI,2 ; 下一个数POP CX ; 循环次数出栈栈LOOP SHOWMOV AH,4CHINT 21HBUBBLE PROCL1: PUSH CX ; 将循环次数入栈LEA SI,A ;SI 遍历 DATAS 数据段的数字L2: MOV AX,A[SI] ; 将前一个数存于 AXCMP AX,A[SI+2] ; 比较前后两个数JBE NEXT ; 如果前一个数小于或等于后一个数则继续本轮的比较XCHG AX,A[SI+2] ; 否则,交换前后两个数的位置MOV A[SI],AXNEXT:ADD SI,2 ; 下一个数LOOP L2 ; 注意内层循环的次数已经确定了POP CX ; 将循环次数出栈LOOP L1 ; 下一轮比较RETBUBBLE ENDP; 将十进制数转换为字符串并储存起来DTOC PROCS:MOV CX,10 ; 将除数 10,放入 CX 中CALL DIVDW ; 调用 DIVDW 程序ADD CL,30H ; 把数字转换为 ASCII 码,这样就能显示了MOV DS:[BP],CL ; 把 ASCII 码放到内存中INC DI ; 用 DI 记录循环的次数PUSH AX ; 将低 16位入栈ADD AX,DX ; 将高位与低位相加,接着判断是否已经除尽 JZ BACK ; 除尽后返回调用处POP AX ; 将低 16位出栈DEC BP ; 逆序存放转化后的字符,便于主程序调用 SHOW_STR JMP SBACK:POP AX ; 为了得到正确的 IP 值,需要出栈一次RETDTOC ENDP; 子程序定义开始 , 功能是分离被除数的各个位的数字; 公式:X/N=int(H/N*65536+[rem(H/N*65536+L]/NDIVDW PROCPUSH AX ; 低 16位入栈MOV AX,DX ; 将高 16位写入 AX,MOV DX,0 ; 将高 16位置零DIV CX ; 将新的数除 10,MOV BX,AX ; 将商 int(H/N转移到 BX ,默认余数 rem(H/N在 DX POP AX ; 将低 16位出栈,DIV CX ; 将 [rem(H/N*65536+L]除 10, 默认余数在 DX MOV CX,DX ; 将余数转移到 CXMOV DX,BX ; 将商 int(H/N转移到 dx, 相当于 int(H/N*65536 RET ; 子程序定义结束DIVDW ENDP; 实现字符串的输出SHOW_STR PROCS2:MOV AH,2 ; 输出数字转化后的字符串MOV DL,DS:[BP]INT 21HINC BP ; 顺序输出DEC DI ; 数字的位数减一JZ OK ; 字符串输出完了就结束 JMP S2 ; 否则继续输出 OK:MOV AH,2 ; 输出空格MOV DL,0INT 21HRETSHOW_STR ENDPCODES ENDSEND START。
汇编语言-冒泡排序(绝对给力)
DATAS SEGMENTBUF DW 20 DUP(0);此处输入数据段代码N DB 010dMES2 DB'Please input ten numbers(number less than 100):','$' MES3 DB'The digital after sorted:','$'a dw 0DATAS ENDSSTACKS SEGMENTSTACK DW 200 DUP(0);此处输入堆栈段代码STACKS ENDSCODES SEGMENT;此处为代码段ASSUME CS:CODES,DS:DATAS,SS:STACKSSTART:MOV AX,DATASMOV DS,AXmov ax,stacksmov ss,axmov sp,200lea dx,mes2;显示输入请用户输入数组mov ah,09int 21hcall crlxor ax,axmov ax,010dmov n,alxor cx,cxmov cl,almov bx,0input1:call decibinpush dxcall crlpop dxmov buf[bx],dxadd bx,02hloop input1;*********************冒泡排序xor cx,cxmov cl,ndec clLOOP1:mov dx,cxmov bx,0LOOP2:mov ax,buf[bx]cmp ax,buf[bx+2]jge loop3xchg ax,buf[bx+2]mov buf[bx],axLOOP3:add bx,2dec cxjne loop2mov cx,dxloop loop1lea dx,mes3mov ah,9int 21hcall crlmov cl,nmov si,0OUTPUT1:mov ax,buf[si]call bindexmov dl,2chmov ah,02hint 21hadd si,02hdec cljnz output1mov ah,4chint 21hBINDEX PROC NEAR;2->10输出push aPX:mov bx,10dxor dx,dxdiv bxadd dx,30hpush dxcmp ax,0jnz pxSHOW:pop dxcmp dx,ajz exitmov ah,02hint 21hjmp showexit:retBINDEX ENDPDECIBIN PROC NEAR;进制之间的转换mov dx,0push cxnewchar:mov ah,01hint 21hsub al,30hjl exit1cmp al,9djg exit1cbwxchg ax,dxmov cl,10dmul clxchg ax,dxadd dx,axjmp newcharexit1:pop cxretDECIBIN ENDPCRL PROC NEAR;*********换行回车函数mov dl,0dhmov ah,02hint 21hmov dl,0ahmov ah,02hint 21hretCRL endpCODES ENDSEND START。
汇编：汇编语言实现冒泡排序（loop指令实现）
15 CODES SEGMENT
16 ASSUME CS:CODES, DS:DATAS
17 START:
18
mov AX,DATAS
;待排序的内容的段地址
19
mov DS,AX
20
21
mov bx,offset buffer ;待排序的内容的偏移地址
22
mov si,0 ;外层循环起始下标0
23
xor cx,cx
网络错误503请刷新页面重试持续报错请尝试更换浏览器或网络环境
汇编：汇编语言实现冒泡排序（ loop指令实现）
1 ;===============================
2 ;循环程序设计
3 ;loop指令实现
4 ;冒泡排序
5 ;for(int i=0;i<N;i++){
6 ; for(int h=0;j<N-1-i>;j++){
35 next1:
36
inc di
37
loop flag2
38
pop cx
;内层循环完毕时 出栈
39 next2:
40
inc si
41
loop flag142Βιβλιοθήκη 43 exit:44
mov ah,4ch
45
int 21H
46 CODES ends
47 end START
48 ;=====================
24
mov cl,10 ;设置外层循环次数
25
26 flag1:
27
mov di,0 ;内层循环起始地址下标0
28
push cx
汇编语言实现整数冒泡排序
第三次实验报告1.实现正整数的冒泡排序，要求有输入与输出。
实验源程序;LT413.ASM.model small.stack.datacount = 10array dw count dup(0)wtemp dw ?flg db 0.code.startupmovcx,countmovbx,offset arrayagaini: call readmov [bx],axincbxincbxcalldpcrlfiloopagaini;;movcx,countdec cxoutlp:mov flg,0movdx,cxmovbx,offset arrayinlp: mov ax,[bx]cmp ax,[bx+2]jna nextxchg ax,[bx+2]mov flg,1mov [bx],axnext: incbxincbxjnzinlpcmp flg,0jzfxwloopoutlp;;fxw:movcx,countmovbx,offset array againo: mov ax,[bx]movwtemp,axcall writeincbxincbxcalldpcrlfoloopagaino.exit 0read procpushbxpush cxpush dxxorbx,bxxorcx,cxmov ah,1int 21hcmp al,'+'jz read1cmp al,'-'jnz read2mov cx,-1read1: mov ah,1int 21hread2: cmp al,'0'jb read3cmp al,'9'ja read3sub al,30hshl bx,1movdx,bxshl bx,1addbx,dx;mov ah,0addbx,axjmp read1read3: cmp cx,0jz read4negbxread4: movax,bxpop dxpop cxpopbxretread endp dpcrlfi procpush axpush dxmov ah,2mov dl,0dhint 21hmov ah,2mov dl,0ahint 21hpop dxpop axretdpcrlfi endpwrite procpush axpushbxpush dxmovax,wtemptestax,axjnz write1mov dl,'0'mov ah,2int 21hjmp write5 write1: jns write2 movbx,axmov dl,'-'mov ah,2int 21hmovax,bxneg axwrite2: mov bx,10pushbxwrite3: cmp ax,0jz write4subdx,dxdivbxadd dl,30hpush dxjmp write3write4: pop dxcmp dl,10je write5mov ah,2int 21hjmp write4write5: pop dxpopbxpop axretwrite endpdpcrlfo procpush axpush dxmov ah,2mov dl,0dhint 21hmov ah,2mov dl,0ahint 21hpop dxpop axretdpcrlfo endpend实验结果：2.编制一个子程序把一个16位二进制数用十六进制的形式在屏幕上显示出来，分别运用如下三种参数传递方式，并用一个主程序验证它（1）采用AX寄存器传递这个16位的二进制数（2）采用wordTEMP变量传递这个16为二进制数（3）采用堆栈方法传递这个16位二进制数实验源程序：.model small.stack.datastring1db 'Mean1 use register :','$'string2db 'Mean2 use variable :','$'string3db 'Mean3 use stack :','$'string4db 0dh,0ah,'$'mydatadw 1992hwordTEMPdw ?.code.startup;AX方式movdx,offset string1;mov ah,9;int 21h;movax,wordptrmydata;call chan1;;变量方式push axmovdx,offset string4;mov ah,09h;int 21h;movdx,offset string2;mov ah,09h;int 21h;pop axmov word ptrwordTEMP,ax;call chan2;;栈方式push axmovdx,offset string4;mov ah,09h;int 21h;movdx,offset string3;mov ah,09h;int 21h;pop axpush ax;call chan3;pop ax;.exit 0chan1 procpush ax;pushbx;movbl,al;moval,ah;callALdisp;moval,bl;callALdisp;popbx;pop ax;retchan1 endpchan2 proc;wordTEMP传递push ax;pushbx;movbl,al;moval,ah;callALdisp;moval,bl;callALdisp;pop ax;retchan2 endpchan3 proc;栈传递pushbp;movbp,sp;push ax;pushbx;mov ax,[bp+4];movbl,al;moval,ah;callALdisp;moval,bl;callALdisp;popbx;pop ax;popbp;retchan3 endpALdisp procpush axpush cxpush dxpush axmovdl,almov cl,4shrdl,clor dl,30hcmp dl,39hjbe aldisp1add dl,7aldisp1: mov ah,2 int 21hpop dxand dl,0fhor dl,30hcmp dl,39hjbe aldisp2add dl,7aldisp2: mov ah,2 int 21hpop cxpop axretALdisp endpend实验结果：。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
;用汇编语言实现实现冒泡排序，并将排序后的数输出
DATAS SEGMENT
A dw 100,344,3435,43433,3438,343,134,80,8,1000,65535,54,45
N=$-A ;计算数字所占的字节数
DATAS ENDS
CODES SEGMENT
ASSUME CS:CODES,DS:DATAS
START:MOV AX,DATAS
MOV DS,AX
MOV SI,0 ;SI遍历数字;前一个数的地址
MOV CX,N/2-1 ;设置循环次数，M(M=N/2)个数需要，循环M-1次
CALL BUBBLE ;调用BUBBLE将原来的数排序
;输出排序后的数
MOV CX,N/2 ;循环M次输出排序后的M个数
MOV SI,0 ;SI遍历排序后的数
MOV DI,0 ;用DI记录数字的位数
MOV BP,N+5 ;BP用于遍历存储的转化后的字符的位置
SHOW: PUSH CX ;循环次数入栈
MOV DX,0 ;由于将要进行16位除需要置高16位为0
MOV AX,[SI] ;低16位为排序后的数
CALL DTOC ;调用DTOC将十进制数转换为字符串
CALL SHOW_STR ;调用SHOW_STR将一个数转化得到的字符串输出ADD SI,2 ;下一个数
POP CX ;循环次数出栈栈
LOOP SHOW
MOV AH,4CH
INT 21H
;冒泡排序
BUBBLE PROC
L1: PUSH CX ;将循环次数入栈
LEA SI,A ;SI遍历DATAS数据段的数字
L2: MOV AX,A[SI] ;将前一个数存于AX
CMP AX,A[SI+2] ;比较前后两个数
JBE NEXT ;如果前一个数小于或等于后一个数则继续本轮的比较XCHG AX,A[SI+2] ;否则，交换前后两个数的位置
MOV A[SI],AX
NEXT:ADD SI,2 ;下一个数
LOOP L2 ;注意内层循环的次数已经确定了
POP CX ;将循环次数出栈
LOOP L1 ;下一轮比较
RET
BUBBLE ENDP
;将十进制数转换为字符串并储存起来
DTOC PROC
S:MOV CX,10 ;将除数10，放入CX中
CALL DIVDW ;调用DIVDW程序
ADD CL,30H ;把数字转换为ASCII码，这样就能显示了
MOV DS:[BP],CL ;把ASCII码放到内存中
INC DI ;用DI记录循环的次数
PUSH AX ;将低16位入栈
ADD AX,DX ;将高位与低位相加，接着判断是否已经除尽
JZ BACK ;除尽后返回调用处
POP AX ;将低16位出栈
DEC BP ;逆序存放转化后的字符，便于主程序调用SHOW_STR JMP S
BACK:POP AX ;为了得到正确的IP值，需要出栈一次
RET
DTOC ENDP
;子程序定义开始,功能是分离被除数的各个位的数字
;公式：X/N=int(H/N)*65536+[rem(H/N)*65536+L]/N
DIVDW PROC
PUSH AX ;低16位入栈
MOV AX,DX ;将高16位写入AX,
MOV DX,0 ;将高16位置零
DIV CX ;将新的数除10,
MOV BX,AX ;将商int(H/N)转移到BX，默认余数rem(H/N)在DX
POP AX ;将低16位出栈，
DIV CX ;将[rem(H/N)*65536+L]除10,默认余数在DX
MOV CX,DX ;将余数转移到CX
MOV DX,BX ;将商int(H/N)转移到dx,相当于int(H/N)*65536
RET ;子程序定义结束
DIVDW ENDP
;实现字符串的输出
SHOW_STR PROC
S2:MOV AH,2 ;输出数字转化后的字符串
MOV DL,DS:[BP]
INT 21H
INC BP ;顺序输出
DEC DI ;数字的位数减一
JZ OK ;字符串输出完了就结束
JMP S2 ;否则继续输出
OK:MOV AH,2 ;输出空格
MOV DL,0
INT 21H
RET
SHOW_STR ENDP
CODES ENDS
END START
;实现冒泡排序，并将排序后的数输出
DATAS SEGMENT
A dw 100,344,3435,43433,3438,343,134,80,8,1000,65535,54,45
N=$-A ;计算数字所占的字节数
DATAS ENDS
CODES SEGMENT
ASSUME CS:CODES,DS:DATAS
START:MOV AX,DATAS
MOV DS,AX
MOV SI,0 ;SI遍历数字;前一个数的地址
MOV CX,N/2-1 ;设置循环次数，M(M=N/2)个数需要，循环M-1次 CALL BUBBLE ;调用BUBBLE将原来的数排序
;输出排序后的数
MOV CX,N/2 ;循环M次输出排序后的M个数
MOV SI,0 ;SI遍历排序后的数
MOV DI,0 ;用DI记录数字的位数
MOV BP,N+5 ;用于遍历存储的转化后的字符的位置
SHOW: PUSH CX ;循环次数入栈
MOV DX,0 ;由于将要进行16位除需要置高16位为0
MOV AX,[SI] ;低16位为排序后的数
CALL DTOC ;调用DTOC将十进制数转换为字符串
CALL SHOW_STR ;调用SHOW_STR将一个数转化得到的字符串输出ADD SI,2 ;下一个数
POP CX ;循环次数出栈栈
LOOP SHOW
MOV AH,4CH
INT 21H
BUBBLE PROC
L1: PUSH CX ;将循环次数入栈
LEA SI,A ;SI遍历DATAS数据段的数字
L2: MOV AX,A[SI] ;将前一个数存于AX
CMP AX,A[SI+2] ;比较前后两个数
JBE NEXT ;如果前一个数小于或等于后一个数则继续本轮的比较XCHG AX,A[SI+2] ;否则，交换前后两个数的位置
MOV A[SI],AX
NEXT:ADD SI,2 ;下一个数
LOOP L2 ;注意内层循环的次数已经确定了
POP CX ;将循环次数出栈
LOOP L1 ;下一轮比较
RET
BUBBLE ENDP
;将十进制数转换为字符串并储存起来
DTOC PROC
S:MOV CX,10 ;将除数10，放入CX中
CALL DIVDW ;调用DIVDW程序
ADD CL,30H ;把数字转换为ASCII码，这样就能显示了
MOV DS:[BP],CL ;把ASCII码放到内存中
INC DI ;用DI记录循环的次数
PUSH AX ;将低16位入栈
ADD AX,DX ;将高位与低位相加，接着判断是否已经除尽
JZ BACK ;除尽后返回调用处
POP AX ;将低16位出栈
DEC BP ;逆序存放转化后的字符，便于主程序调用SHOW_STR JMP S
BACK:POP AX ;为了得到正确的IP值，需要出栈一次
RET
DTOC ENDP
;子程序定义开始,功能是分离被除数的各个位的数字
;公式：X/N=int(H/N)*65536+[rem(H/N)*65536+L]/N
DIVDW PROC
PUSH AX ;低16位入栈
MOV AX,DX ;将高16位写入AX,
MOV DX,0 ;将高16位置零
DIV CX ;将新的数除10,。