您的位置：360文档中心› 汇编语言实现冒泡排序(一)

汇编语言实现冒泡排序(一)

合集下载

汇编--BubbleSort(冒泡排序)

汇编--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语言调用汇编函数实现冒泡排序

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指令实现）

汇编：汇编语言实现冒泡排序（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实验结果：。

计算机组成原理和汇编语言实验报告

计算机组成原理和汇编语言实验报告

计算机组成原理和汇编语言实验报告专业班级：计算机0801班实验一、汇编：冒泡排序1、实验内容：定义一个字数组序列：1567，25，46，4560，678，1234，32540。

用冒泡排序对该数组由小到大排序，并将排序结果以十进制数字的形式在屏幕上显示出来。

2、实验原理：程序首先定义了要排序的数组，然后对其在原数组内进行冒泡排序。

冒泡排序是基于交换排序的一种算法，它依次两两比较待排序的元素，若为逆序则进行交换。

每趟冒泡都将待排元素序列中的最大量交换到最后位置。

冒泡过程共需进行n(n-1)/2次比较，直到全部元素有序为止。

数组有序以后，进行输出的工作。

依次从小到大，将元素转换为十进制数的ASCII码值来输出，并在输出每个数时，增加输出回车换行来使输出结果清晰。

3、实验代码：;-------------------------PROGRAM BEGINS---------------------------;----------------------------DEFINE DS-------------------------------DATA SEGMENTTIME DW 0 ;THE LOOP TIME OF THE OUTER LOOPCHU DW 10 ;USED TO CONVERT THE NUM TO DECIMAL DTY DW 1567,25,46,4560,678,1234,32540 ,'$' ;DEFINE THE ARRARYRESULT DB ?DATA ENDS;-----------------------------DEFINE CS-----------------------------CODE SEGMENT "CODE"ASSUME CS:CODE ,DS:DATASTART:MOV AX,DATAMOV DS,AXAGAIN:MOV CX, 6 ;THE LOOP NUM OF THE INER LOOP MOV BP,12 ;NUM OF THE BYTESAGAIN1:MOV AX,DTY[BP]CMP DTY[BP-2],AX ;CMP WITH THE FORMER BYTEJBE NEXT ;JMP IF BELOW OR EQUALXCHG AX,DTY[BP-2] ;IF ABOVE,THEN CHANGEXCHG AX,DTY[BP]NEXT:SUB BP,2 ;POINT TO THE FORMER ONEDEC CXCMP CX,TIME ;IS IT DONE?JE NEXT1 ;DONEJMP AGAIN1 ;NOT DONE YETNEXT1:INC TIMECMP TIME,6 ;IS IT DONE?JE NEXT3 ;DONEJMP AGAIN ;NOT DONE YETNEXT3:MOV TIME,0 ;RENEW THE DATAMOV BP,0CHANGE:MOV RESULT[5],13 ;FINISH OF THE NUMMOV RESULT[6],10MOV RESULT[7],'$'MOV AX,WORD PTR DTY[BP] ;THE DW TO OUTPUTMOV CX,5 ;LOOP NUMMOV BX,4 ;TWO BITS * 4 =WORD CHANGE1:MOV DX,0DIV CHU ;DX:AX/CHUMOV RESULT[BX],DL ;THE REMAINDERADD RESULT[BX],30H ;TO DECIMALDEC BX ;POINT TO THE FORMER TWO BITS LOOP CHANGE1MOV CX,4MOV BX,0FIND0:CMP RESULT[BX], '0' ;IS IT ZERO?JNE FINAL ;NOT ZEROADD BX,1 ;ZEROLOOP FIND0FINAL:LEA DX, RESULT[BX] ;OUTPUTMOV AH,09HINT 21HADD BP, 2 ;POINT TO NEXT WORDINC TIMECMP TIME,7 ;IS IT DONE?JNE CHANGE ;NOT NONEMOV AH,4CHINT 21HCODE ENDSEND START;--------------------PROGRAM ENDS--------------------实验二算术逻辑运算实验一、实验目的1．掌握简单运算器的组成以及数据传送通路。

8086汇编实现冒泡排序、直接插入排序、折半查找

8086汇编实现冒泡排序、直接插入排序、折半查找

（2）直接插入法 直接插入排序：将一个数据插入到一个已排好序的数据中，主要步骤如下：
① 查找应该插入的位置，这个过程免不了要比较数据的大小； ② 找到位置后，需将这个位置以及其后的数据都向后移动一位，空出此位置，等待插入 ③ 插入数据。
其 C 语言版的代码如下：
for(int i=2;i<=100;i++)
DSEG SEGMENT SCORE DB 31H,02H,15H,4H,5H,6H,7H,8H,9H,10H,90 DUP(05H) MAX DB ? MIN DB ?
DSEG ENDS CSEG SEGMENT
ASSUME DS:DSEG,CS:CSEG START: MOV AX,DSEG
MOV DS,AX
;相当于 i
L2: MOV AL,[BX+DI] ; L2 为内循环，(DI)为循环变量，相当于 j
CMP AH,AL
JAE L3
MOV DH,AH
;AH<Al，交换两个数
MOV AH,AL
MOV AL,DH
MOV [BX+DI],AL ;将交换后的数存入存储器
MOV [BX+SI],AH ;这两步很重要
L4: MOV DL,[BX+DI] ;从内存中取出 a[j]，给(DL)
CMP DH,DL
;比较 a[0]和 a[j]
JAE L5
;a[0]<a[j],向后移
MOV [BX+DI+1],DL ;存入内存，实现真正的后移
DEC DI
;j--
JMP L4
L5: MOV [BX+DI+1],DH ;a[0]>=a[j]，a[0]—>a[j+1]，实现直接插入

汇编语言冒泡法排序

汇编语言冒泡法排序

汇编语言冒泡法排序汇编语言中的冒泡排序算法如下：```assemblysection .dataarray db 5, 1, 4, 2, 8 ; 待排序的数组size equ $-array ; 数组的大小section .textglobal _start_start:mov ecx, size ; 初始化循环计数器为数组大小outer_loop:xor eax, eax ; 清零标志寄存器，用于判断是否有交换发生mov edi, 1 ; 初始化内层循环计数器为1inner_loop:movsx ebx, byte [array + edi - 1] ; 将当前元素加载到寄存器ebxcmp bl, byte [array + edi] ; 比较当前元素和下一个元素jg swap ; 如果当前元素大于下一个元素，则交换它们inc edi ; 内层循环计数器加1 loop inner_loop ; 继续内层循环cmp eax, 0 ; 判断标志寄存器是否为0jne outer_loop ; 如果有交换发生，则继续外层循环exit:mov eax, 1 ; 系统调用号1代表退出程序xor ebx, ebx ; 退出状态码为0int 0x80 ; 调用系统调用swap:mov dl, byte [array + edi] ; 将下一个元素加载到寄存器dlmov byte [array + edi], bl ; 将当前元素赋值给下一个元素mov byte [array + edi - 1], dl ; 将下一个元素赋值给当前元素mov eax, 1 ; 设置标志寄存器为非零，表示有交换发生jmp inner_loop ; 继续内层循环```这段汇编代码使用了两层循环，外层循环控制整个排序过程，内层循环用于比较相邻的两个元素并交换它们。

内层循环每次都会比较当前元素和下一个元素，如果当前元素大于下一个元素，则交换它们。

汇编语言汇编语言实现ifwhilefor以及编写冒泡排序

汇编语言汇编语言实现ifwhilefor以及编写冒泡排序

汇编语言汇编语言实现ifwhilefor以及编写冒泡排序在计算机科学中，汇编语言是一种底层编程语言，它直接与计算机的硬件交互。

在汇编语言中，我们可以利用条件语句（if）、循环语句（while、for）以及排序算法（冒泡排序）来实现各种功能。

本文将介绍汇编语言中如何使用这些关键字来编写相应功能的代码，并且以冒泡排序算法为例进行详细说明。

一、if语句实现if语句在汇编语言中通常使用条件判断指令来实现。

下面是一个示例代码，演示如何使用if语句判断两个数的大小关系：```section .datanum1 db 10num2 db 20result db 0section .textglobal _start_start:mov al, byte[num1]mov bl, byte[num2]cmp al, bl ; 比较num1和num2的值jg greater ; 如果num1 > num2，则跳转到greater标签处jl less ; 如果num1 < num2，则跳转到less标签处jmp equal ; 如果num1 = num2，则跳转到equal标签处greater:mov byte[result], 1jmp doneless:mov byte[result], -1jmp doneequal:mov byte[result], 0jmp donedone:; 其他操作，比如打印结果或进行下一步操作```在上述代码中，我们将两个数分别存在`num1`和`num2`变量中，用`cmp`指令进行比较，根据比较结果使用`jmp`指令跳转到相应的标签位置。

通过这样的比较和跳转操作，我们可以实现基本的if语句功能。

二、while语句实现while语句在汇编语言中可以通过使用条件循环指令来实现。

下面是一个示例代码，演示如何使用while语句计算1到10的和：```section .datasum dw 0counter dw 1section .textglobal _start_start:mov cx, 10 ; 设置循环次数mov ax, 1 ; 设置计数器初始值loop_start:add word[sum], ax ; 将计数器的值加到sum中inc ax ; 计数器自增1loop loop_start ; 循环开始; 其他操作，比如打印结果或进行下一步操作```在上述代码中，我们将循环次数存储在`cx`寄存器中，将计数器的初始值存储在`ax`寄存器中。

微机原理-实验一-汇编语言-冒泡排序

微机原理-实验一-汇编语言-冒泡排序

微机原理实验报告班级：XXXXX姓名：XXXX学号：20XXXXXXXXX大学信息科学与技术学院信息工程系实验一汇编语言程序设计-（具体题目）一、实验目的（根据实际情况修改）：1、熟悉MASM编译环境，了解程序的汇编方法；2、熟悉常用汇编指令，学习汇编程序设计方法；3、学习汇编语言的调试过程，通过调试过程认识CPU执行程序的方式；4、了解冒泡法原理，学习多重循环的编程方法。

二、实验内容：编写程序，用冒泡法实现将数据段内9,8,7,6，5,4,3,2,1按照由小到大的顺序重新排列。

三、程序流程图和程序代码1、流程图2、代码与注释（代码不能和指导书完全一样，写出注释，写出寄存器尤其是DS的值）data segmentbuf1 db 8,7,6,5,4,3,2,1data endscode segmentassume cs:code,ds:datastart: mov ax,data //传送数据段datamov ds,axmov dx,7 //dx放外循环7次L3: mov cx,dx //cx放内循环7次lea si,buf1 //将db里的数据传送到siL2: mov al,[si]cmp al,[si+1] //比较[si]与[si+1]jb L1 //[si]<[si+1],跳转到L1xchg al,[si+1] //[si]>[si+1],两两交换mov [si],alL1: inc si //si减1loop L2 //循环L2dec dx //外循环减1，没减到0则跳转到L3 jnz L3 //入内循环，计数初值mov ah,4chint 21hcode endsend start四、调试过程及遇到的问题1、程序执行截图2、调试用到的命令-U命令：查看数据段地址；-d命令：查看运行前后存储器内容；-g命令：运行程序；-t命令：查看运行前后寄存器和存储器内容。

3、遇到的问题及解决办法问题：运行程序后，数据1在存储器地址末尾没变。

汇编冒泡排序程序

汇编冒泡排序程序

为掌握用汇编语言编写排序程序的思路和方法。

编写程序，在s中存放100个数，要求设计程序将这些数由小到大排序，排序后的数，仍放在该区域中，并显示排序后的结果。

DATA SEGMENTSTR1 DB 'PLEASE INPUT SOME DATA,THE END FLAG IS$','$'S DB 100DB ?DB 100 DUP(?)DATA ENDSCODE SEGMENTASSUME CS:CODE,DS:DATASTART:MOV AX,DATAMOV DS,AXLEA DX,STR1MOV AH,9INT 21HMOV DL,0AHMOV AH,2INT 21HLEA DX,SMOV AH,0AHINT 21HMOV SI,DXMOV DL,0AHMOV AH,2INT 21HMOV CL,[SI+1]MOV CH,0SUB CX,2MOV DX,CXDEC DXADD SI,2L1:MOV BL,[SI]INC SIMOV BH,[SI]CMP BH,BLJG L2MOV [SI],BLMOV [SI-1],BHL2:LOOP L1LEA SI,SADD SI,2MOV CX,DXDEC DXJNZ L1LEA DX,S ADD DX,2 MOV AH,9 INT 21HMOV AH,4CH INT 21H CODE ENDSEND START欢迎您的下载，资料仅供参考！致力为企业和个人提供合同协议，策划案计划书，学习资料等等打造全网一站式需求。

汇编实现冒泡排序的方法示例

汇编实现冒泡排序的方法示例

汇编实现冒泡排序的⽅法⽰例冒泡排序算法的运作如下：（从后往前）1.⽐较相邻的元素。

如果第⼀个⽐第⼆个⼤，就交换他们两个。

2.对每⼀对相邻元素作同样的⼯作，从开始第⼀对到结尾的最后⼀对。

在这⼀点，最后的元素应该会是最⼤的数。

3.针对所有的元素重复以上的步骤，除了最后⼀个。

4.持续每次对越来越少的元素重复上⾯的步骤，直到没有任何⼀对数字需要⽐较。

以下为实现代码：S0 SEGMENT STACKDW 30 DUP(?)TOP LABEL WORDS0 ENDSS1 SEGMENTTIP DB "Input ten number and separate the numbers with space:", 0DH, 0AH, 24HARY DW 20 DUP(0)CRLF DB 0DH, 0AH, 24HN DW 0S1 ENDSS2 SEGMENTASSUME SS:S0, DS:S1, CS:S2, ES:S1P PROC FARMOV AX, S0MOV SS, AXLEA SP, TOPMOV AX, S1MOV DS, AXMOV AX, S1MOV ES, AXLEA DX, TIPMOV AH, 9INT 21HLEA SI, ARYXOR DX, DXMOV BL, 10MOV CX, 10INPUT: MOV AH, 1INT 21HCMP AL, 20H ;空格分隔字符JE SAVE;输⼊⼗进制数，将数存⼊SI对应的内存单元MOV DL, ALMOV AX, [SI]MUL BLSUB DL, 30HADD AL, DLMOV [SI], AXJMP INPUTSAVE:ADD SI, 2LOOP INPUT;数组保存完毕LEA SI, ARYMOV DI, SIADD DI, 2CMPA: MOV BX, [DI]CMP BX, [DI-2]JA CONMOV DX, [DI-2]PUSH DXMOV [DI-2], BXPOP DXMOV [DI], DXCON: ADD DI, 2DEC CHCMP CH, 0JNE CMPACALL PRINTMOV DI, SIADD DI, 2DEC CLMOV CH, CLCMP CL, 1JNE CMPA;以下为⼗进制输出ARY中的数EXIT: MOV AH, 4CHINT 21HP ENDPPRINT PROC NEARPUSH SIPUSH CXPUSH AXPUSH DXLEA DX, CRLFMOV AH, 9INT 21HLEA SI, ARYMOV CX, 10L1: MOV AX, [SI]MOV N, AXCALL OUTPUTADD SI, 2MOV DX, 20HMOV AH, 2INT 21HLOOP L1POP DXPOP AXPOP CXPOP SIRETPRINT ENDPOUTPUT PROC NEARPUSH AXPUSH BXPUSH CXPUSH DXXOR CX, CXMOV AX, NMOV BX, 10L2: XOR DX, DXDIV BXPUSH DXINC CXL3: POP DXADD DX, 30HMOV AH, 2INT 21HLOOP L3POP DXPOP CXPOP BXPOP AXRETOUTPUT ENDPS2 ENDSEND P以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。

汇编实现冒泡排序并输出结果

汇编实现冒泡排序并输出结果

结果截图这样子的程序：;;无符号16位整数冒泡排序data segmenta dw 12,4,9,0,65358,6,1,3,5,79cnt dw 10data endsstack segmentstack endscode segmentassume cs:code,ds:data,ss:stacksort proc near ;冒泡排序，具有两个参数，数组偏移和个数push bppush axpush cxpush sipush dimov bp,spmov cx,ss:[bp+0CH] ;取出函数形参，放在(si,cx)mov si,ss:[bp+0EH]loop1:push cx ;外层循环还有cx-1 次，将次数压栈;同时cx-1 也是内层循环次数,不再赋值mov di,si ;di为内层循环遍历指针loop2:mov ax,ds:[di]cmp ax,ds:[di+2]jna noswapmov dx,ds:[di+2]mov ds:[di+2],axmov ds:[di],dxnoswap:inc diinc didec cxcmp cx,1ja loop2pop cx ;外层循环次数出栈dec cxcmp cx,1ja loop1pop dipop sipop cxpop axpop bpret 4sort endpdisplay proc near ;将0-15转换为0-9&&A-Fpush axmov ah,02Hcmp dl,0AHjae addAjb add0addA:add dl,37Hint 21Hjmp ffadd0:add dl,30Hint 21Hjmp ffff:pop axretdisplay endpshow proc near ;打印数组，具有两个参数，数组偏移和个数push bppush axpush bxpush cxpush sipush dxmov bp,spmov cx,ss:[bp+0EH] ;取出函数形参，放在(si,cx)mov si,ss:[bp+10H]lop1: ;将一个0-65535 的数据以十进制的形式打印push cxmov cx,0mov dx,0mov ax,ds:[si]lop2:mov bx,0AHdiv bxpush dx ;数字顺序是个,十,百,千所以先存起来inc cxmov dx,0cmp ax,0ja lop2lop21: ;和lop2并列的内循环,用于将颠倒顺序的十进制反转打印pop dxcall displaydec cxcmp cx,0ja lop21mov ah,02Hmov dl,20Hint 21Hpop cxinc siinc sidec cxcmp cx,0ja lop1pop dxpop sipop cxpop bxpop axpop bpret 4show endpstart: ;主程序调用子程序进行排序及打印mov ax,stackmov ss,axmov ax,datamov ds,axlea ax,a ;参数两个（a,cnt）push axmov ax,cntpush axcall sortlea ax,a ;参数两个（a,cnt）push axmov ax,cntpush axcall showmov ah,4CHint 21Hcode endsend start。

用汇编语言冒泡排序经典程序

用汇编语言冒泡排序经典程序
交换位置：如果前一个元素比后一个元素大，则交换它们的位置
冒泡排序时间复杂度
最好情况：O(n)
平均情况：O(n²)
最坏情况：O(n²)
Part Two
汇编语言基础知识
汇编语言概述
汇编语言是一种低级编程语言，与机器语言相对应。
它使用助记符和操作码表示指令，易于理解和编写。
汇编语言通常用于嵌入式系统、操作系统等底层开发。
注意事项：确保编译和链接的正确性，避免出现错误和警告
工具使用：使用编译器和链接器等工具进行编译和链接
链接过程：将目标文件合并成一个可执行文件
程序运行及结果
输入数据：随机生成一组整数
程序运行过程：按照冒泡排序算法进行排序
输出结果：排序后的整数序列
测试结果：对多个不同规模的输入数据进行测试，验证程序的正确性和稳定性
代码注释：对每行代码进行详细解释，帮助理解算法实现过程
代码解析：分析代码结构，解释冒泡排序算法的汇编语言实现方式
寄存器使用：说明在汇编语言中如何使用寄存器进行数据交换和比较
优化点：分析代码中可以优化的地方，提高程序执行效率
Part Four
程序运行及测试
程序编译链接
编译过程：将源代码转换成机器语言
指令格式：汇编语言指令由操作码和操作数组成，操作码指明指令的操作类型，操作数指明操作数或操作数的地址。
伪指令：伪指令不是真正的计算机指令，而是用于告诉汇编程序如何组织程序的一种指示。常见的伪指令包括ORG、END、DB、DW等。
Part Three
汇编语言实现冒泡排序
排序数据准备
确定排序数据类型：根据具体需求选择合适的数据类型，如整数、字符等。
优化效果：通过减少数据交换次数，可以提高冒泡排序算法的执行效率，减少程序运行时间
  1. 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 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,。

相关文档
最新文档