用汇编语言编写的排序程序
汇编语言输入10个数排序并输出的实现
汇编语⾔输⼊10个数排序并输出的实现⼀：题⽬描述在键盘输⼊任意10个数1. 按从⼩到⼤排序后，在计算机屏幕上先输出来。
要有结果提⽰（字符串显⽰）。
2. 将10个数做累加，结果在计算机屏幕显⽰累加和。
⼆：伪指令的定义1.数据段ATAS SEGMENTstring_1 DB 'Please input a numbers(0-65536):','$'string_2 DB 'ERROR: OVERFLOW! Please input again:','$'string_3 DB 'The array you have input is:',0ah,0dh,'$'string_4 DB 'After Sort the num is:',0ah,0dh,'$'string_5 DB ' ','$'DATA DW 10 DUP(?)massege DB 'The sum of the array is: ',0ah,0DH,'$'DATAS ENDS说明：string_1输⼊范围提⽰string_2输⼊错误提⽰string_3输出原数组提⽰string_4输出排序后数组提⽰string_5空格符DATA缓冲区数组2.堆栈段STACKS SEGMENTDW 256 dup(?)STACKS ENDS3.代码段CODES SEGMENTASSUME CS:CODES,DS:DATAS,SS:STACKS三：模块分解与实现1. DOS输⼊10个数字输⼊10个⽆符号数存⼊缓冲区，并且保证 num<65536num < 65536num<65536为何输⼊范围是65536呢⼀个字的最⼤表⽰范围是 FFFFFFFFFFFF 其在⼗进制的表⽰下为 65535HEX FFFFDEC65535BIN1111 1111 1111 11111.1 输⼊函数⼦程序;---------输⼊函数（单数字输⼊）------------Input PROC Nearpush AXpush BXpush CXpush DX;---------输⼊提⽰--------------MOV BX, 0CLCMOV DX, 0;----------输⼊数字--------------Lp_0:MOV AH, 1INT 21HCMP AL, 20H ;回车JE L_CRLF;----- x belong to [0,9] ----------SUB AL, 30H ; ASCII -> intJL L_ERRORCMP AL, 9JG L_ERROR;------- string -> int -----------MOV AH, 0 ;将 AL扩展成 AXXCHG AX, BX ;保护 AX值MOV CX, 10MUL CX ; bx *= 10ADD AX , BXJC L_ERROR ; OVERFLOW处理XCHG AX, BXJMP Lp_0L_ERROR:MOV DX, 0MOV BX, 0CALL CRLF ; 换⾏CALL ERROR ; 输出错误提⽰JMP Lp_0L_CRLF: ; 以换⾏作为⼀个数的结束标志MOV DX, 0MOV DATA[SI], BX ;解析函数功能：本质类似于⾼精度计算，将读⼊的⼀个串转成数字存储在DATA数组中分成三⼤部分⼀：输⼊提⽰⼆：错误判断及提⽰三：转化为数字L_ERROR 错误处理L_CRLF 结束处理我们来举⼀个123412341234 的例⼦Register1234AX1234BX0112123CX10101010AX+(BX∗CX)AX + (BX * CX)AX+(BX∗CX)最后将结果存储在DATA数组⾥2.实现冒泡排序冒泡排序作为⼀个简单的排序算法，时间复杂度 O(n2)O(n^2)O(n2) 需要两层循环，为了提⾼代码的可读性，我们将内层的循环写成⼀个⼦程序每次调⽤内层循环很简单，每次从头⽐到尾，遇到⽐它⼩的交换就可以了。
基于8086用汇编语言实现的十个有符号数的排序(冒泡排序算法,输入为补码,从小到大)
提示：在做实验时，我们要自己将代码区和数据区分开，因为8086上没有软件帮我们完成这个任务。
MOV R0,#218 //之所以选择208这个大点的地址，是因为避免将数据写到了代码区LOOP1:IN //将数据读入AADD A,#128 //将补码转换为其对应的移码，因为补码本身参与加减不能比较出大//小，而移码就是将其真值在数轴上平移了2的n次方MOV @R0,AMOV A,R0sub a,#1SUB A,#208 //判断有没有输入完10个数JZ LOOP2 //输入完数据，跳转ADD A,#208MOV R0,AJMP LOOP1//没有输入完，就跳回接着输入LOOP2:MOV R0,#9 //9轮循环比较就可以排完序MOV R1,#209MOV R2,#210LOOP4:MOV A,@R2SUBC A,@R1JC LOOP3 //若210地址指向的单元中的数比209地址指向的单元中的小，则交//换LOOP5:MOV A,R2ADD A,#1SUBC A,#219 //判断此轮有没有比较完JZ LOOP6 //若比较完，就跳到LOOP6,否则继续比较ADD A,#219MOV R2,AJMP LOOP4LOOP3:MOV A,@R1MOV 208,AMOV A,@R2MOV @R1,AMOV A,208MOV @R2,AJMP LOOP5 //交换完了就跳回LOOP6: MOV A,R1ADD A,#1MOV R1,AADD A,#1MOV R2,A //让R2始终指向的是R1下一个单元MOV A,R0SUB A,#1JZ LOOP7 //判断9轮比较有没有完成，若完成，跳LOOP7，否则，继续比//较MOV R0,AJMP LOOP4LOOP7: MOV R0,#218LOOP9: MOV A,@R0 //下面这一段代码就是将数还原，因为原来我们是那人家的移码//形式来比较的，相信下面这一段就不用多讲了吧ADD A,#128MOV @R0,AMOV A,R0sub a,#1SUB A,#208JZ LOOP8ADD A,#208MOV R0,AJMP LOOP9LOOP8:END。
史上最牛最完整的汇编语言冒泡排序程序
;题目：编制一个完整的汇编语言程序，从键盘上读入若干个（可以超过十个）十进制数（正数），排序后在屏幕上输出。
;采用冒泡法排序，综合运用子程序和宏汇编，使程序模块化。
;程序代码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。
数组按大小排序汇编语句
数组按大小排序汇编语句在汇编语言中，对数组按照大小排序可以使用冒泡排序算法。
下面是一个使用汇编语言编写的对数组按大小排序的示例程序：```section .dataarray db 9, 2, 7, 4, 5 ; 数组存储在.data节中array_size equ ($ - array) ; 计算数组大小temp db 0 ; 用于交换数组元素的临时变量section .textglobal _start_start:; 初始化循环计数器mov ecx, array_size - 1outer_loop:; 初始内循环计数器mov ebx, 0inner_loop:; 比较array[ebx]和array[ebx+1]的大小mov al, [array + ebx]cmp al, [array + ebx + 1]; 如果array[ebx] > array[ebx+1]，交换它们jle skip_swapmov dl, [array + ebx + 1]mov [array + ebx + 1], almov [array + ebx], dlskip_swap:; 更新内循环计数器inc ebxcmp ebx, ecxjl inner_loop; 如果已经没有需要交换的元素，排序完成dec ecxjz done; 继续下一轮外循环jmp outer_loopdone:; 排序完成，程序退出mov eax, 1xor ebx, ebxint 0x80```这个示例程序使用冒泡排序算法对数组进行排序。
首先，它初始化两个循环计数器，外循环计数器 `ecx` 控制外层循环，内循环计数器 `ebx` 控制内层循环。
然后，它在内循环中比较相邻的两个元素，并根据需要交换它们的位置。
内循环执行完后，它检查是否还有需要交换的元素。
如果没有需要交换的元素，排序完成；否则，它继续进行下一轮外循环。
最后，排序完成后，程序通过系统调用退出。
8086 汇编语言顺序程序设计
汇编语言程序设计实验报告学院: 计算机科学与技术学院专业: 计算机科学与技术班级:计科131MOV AX,WORD PTR N1MOV DX,WORD PTR N1＋2MOV CX,WORD PTR N2MOV BX,WORD PTR N2＋2ADD AX,CXADC DX,BXMOV WORD PTR N3,AXMOV WORD PTR N3＋2,DXMOV AH,4CHINT 21HCODE ENDSEND START使用相应的文本编辑器建立文件two、asm,内容如上所示。
二、生成可执行文件:1、汇编:C:\masm> masm two;2、连接:C:\masm> link two;三、运行及调试:1、运行:C:\masm>debug two、exe－U0 ;通过反汇编查找程序的断点－T=0 2 ;加载数据段－D0 ;查瞧原始数据就是否正确－G=0 1F ;运行程序至断点1F 处－D0 ;查瞧程序运行结果2、调试:若要判断此程序对于其它32 位数相加就是否正确,则需要使用DEBUG 进行程序调试。
实验二:编程实现:将从2000H 单元开始的连续128 个单元的内容进行清零一. 编程CODE SEGMENTASSUME CS:CODE,DS:CODESTART:MOV BX,2000HMOV CX,128MOV AL,00HL1:MOV [BX],ALINC BXLOOP L1MOV AH,4CHINT 21HCODE ENDSEND START二.使用编辑器建立源程序文件four、asm。
三.生成可执行文件:1、汇编:C:\masm> masm four;2、连接:C:\masm> link four;四、运行及调试:1、运行:C:\masm>debug four、exe－D2000;－R;－D CS:2000;－G;－D2000;实验三:编程实现:将3000H 单元的一个字节的内容进行拆分,高半字节放进3001H 单元的低半部分,其低半字节放进3002H 单元的低半部分一、编程源程序:DATA SEGMENTN0 DW 3000HN1 DW 3001HN2 DW 3002HDATA ENDSCODE SEGMENTASSUME CS:CODE,DS:DATASTART:MOV AX,DATAMOV DS,AXMOV BX,N0AND BX,0FHMOV AX,N2MOV AX,[BX]MOV BX,N0MOV CL,4SHR AX,CLMOV AX,N1MOV AX,[BX]MOV AH,4CHINT 21HCODE ENDSEND START二.使用编辑器建立源程序文件five、asm。
汇编语言实现整数冒泡排序
第三次实验报告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实验结果：。
用汇编语言编写的排序程序
用汇编语言编写的排序程序一实验目的 (3)二题目 (3)三算法分析 (3)四流程图及算法 (5)五源程序附录a、参考文献一实验目的：1、进一步熟悉汇编语言的代码；2、学会分析算法并构造流程图；3、能够完成简单的子程序设计；4、学会查找程序的算法。
二题目将以地址ＤＡＴＡ开始的１０个无符号字数据按从大到小的顺序重新排列三算法分析排序算法采用冒泡法，假定待排序数组中有X1，X2，X3，…X10共十个无符号数据，冒泡排序法的具体做法是：最多有九次外循环。
每次外循环均从底部开始进行两两比较，若后者大于前者，两者位置交换，反之不变。
然后两两比较向前推移，直到本次外循环应完成的两两比较次数（成为内循环次数达到为止）。
此时，本次外循环结束,最大的数冒到本次外循环的顶部。
第一次外循环，第一次外循环，两两比较的次数为n-1次，最大数据冒到X1的位置；第二次外循环，两两比较次数为n-2次，剩余最大数据冒到X2位置；以此类推，第n-1次外循环，两两比较次数为1次，剩余最大数据项冒到X n-1的位置。
若再一次外循环结束后，经判断本次外循环一次位置交换也未发生过或仅在底部发生过一次交换，则本次外循环结束，数的顺序已排妥，余下的外循环不用进行了。
流程图如上所示。
根据流程图编写程序：如下：;程序模板SSEG SEGMENT PARA STACK 'stack'dw 100h dup(0) ;初始化堆栈大小为100SSEG ENDSDSEG SEGMENTDATA DW 150,12,54,89,73,152,45,68,98,65COUNT EQU $-DATABUFO DB 6 DUP (?),'$'DSEG ENDSESEG SEGMENT;附加段：在此处添加程序所需的数据ESEG ENDSCSEG SEGMENTassume cs:CSEG, ds:DSEG, es:ESEG, ss:SSEGDISP PROC ；显示DI所指ASCII字符串的子程序PUSH DXPUSH AXMOV DX,DIMOV AH,09HINT 21HMOV DL,','MOV AH,2INT 21HPOP AXPOP DXRETDISP ENDPDATCH PROC FAR ；转换数值成为ASCII串的子程序PUSH DX ；入口参数在AX中，要转换的数在DI中 PUSH CX ；出口参数在DI中，是结果缓冲区指针 PUSH BXMOV CX,10MOV BX,AXDLOP1:DEC DIXOR DX,DXDIV CXOR DL,30HMOV [DI], DLCMP AX,0JNZ DLOP1POP BXPOP CXPOP DXRETDATCH ENDPMAIN PROC FAR ;主程序入口mov ax, dsegmov ds, axmov ax,esegmov es, axSTART:XOR AX,AXMOV DX,AX ；主程序MOV CX,AXMOV DX,COUNT/2 ；DX，被排序数据个数LOP1: DEC DX ；DX，大循环变量（大循环次数）MOV CX,DX ；CX，小循环变量(两两比较次数) MOV BX,DX ;设置交换标志LEA SI,BUFOSUB SI,2LOP2: MOV AX,[SI]CMP AX,[SI-2]JBE PASSXCHG [SI-2],AXMOV [SI],AXMOV BX,CXPASS: SUB SI,2LOOP LOP2CMP BX,DXJE DLAST ；数的顺序已排妥，转DLASTJMP LOP1DLAST:MOV CX,COUNT/2 ；显示的数据个数LEA SI,DATA ；数据的缓存区首地址LOP3: MOV AX,[SI]MOV DI,OFFSET BUFOADD DI,LENGTH BUFOCALL DATCHCALL DISPADD SI,2LOOP LOP3mov ah,1int 21hmov ax, 4c00h ;程序结束，返回到操作系统系统int 21hMAIN ENDPCSEG ENDSEND MAIN结果：。
选择排序的汇编语言[整理]
![选择排序的汇编语言[整理]](https://img.taocdn.com/s3/m/c88b0a97e43a580216fc700abb68a98271feacfc.png)
00例：将10个单元字节无符号数升序排序，排序前后的数据均置于内部RAM的50H～59H单元内选择排序法0先确定位置，然后在寻找应该占用这个位置的对象，这就是选择排序算法。
假设要将N个无序数据按增序进行排序，首先确定第一个位置（地址），然后寻找数据对象，在N个无序数据中找到最小数据，放在第一个位置。
假设最小值占有第k个位置，则将它搬到第一个位置上，然后将原来占有第一个位置的数据元素存放到空出的第k个位置，即和应该占有这个位置的元素交换位置。
最后一个数据就是经过N-1次选择后剩下的数据，肯定是全部数据中的最大值，理所当然占有最后一个位置。
0选择排序算法主要是进行最小值的选择，这是通过一系列的比较实现的，不需要进行位置移动，故在数据元素的结构比较大（多字节）的情况下具有较高的效率。
0例：重作上题，要求用选择排序法。
001）题目分析00从50H单元开始进行比较，第一个循环比较9次，选择出最小值，存入50H；第二个循环比较8次，选择出次最小值，存入51H；依此类推，共需要进行9个循环。
002）硬件资源分配：00内部RAM的50H～59H：排序前后数据存放区00B：保存本轮比较最小值0R0：本次最小值存放地址00R1：与本次最小值存放地址相邻的地址00R2：排序处理的次数，即外循环次数0R3：一个内循环中最小值所在地址00R4：本次比较次数，即内循环次数003）程序流程图如图7-3所示004）参考程序0DAT EQU 50H ;待排序数据首地址00N EQU 10 ;待排序数据元素个数0XZPX: MOV R0,#DAT ;从第一个位置开始00MOV R2,#N-1 ;需要处理的元素为N-100 LOOP: MOV B,@R0 ;取当前元素作为最小值的初始值00MOV A,R00MOV R3,A ;取当前位置作为最小值的位置00 INC A0MOV R1,A ;取下一个位置作为比较的开始00MOV A,R2 00MOV R4,A ;控制比较次数0LOOP1:MOV A,@R1 ;取一个数据元素0CLR C0SUBB A,B ;与当前最小值比较00JNC LOOP2 ;不小于当前最小值00MOV B,@R1 ;保存新的最小值00MOV A,R1 00MOV R3,A ;保存新的最小值地址0LOOP2:INC R1 ;调整指针0DJNZ R4,LOOP1 ;比较完全部未排序元素00MOV A,R3 ;0MOV R1,A ;取当前最小值的地址0MOV A,@R1 ;将当前最小值和指定位置的数据元素进行交换00XCH A,@R0 00XCH A,@R100INC R0 ;处理下一个位置00DJNZ R2,LOOP ;处理完前N-1个位置0RET0。
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]，实现直接插入
汇编语言汇编语言实现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`寄存器中。
汇编实现冒泡排序的方法示例
汇编实现冒泡排序的⽅法⽰例冒泡排序算法的运作如下：（从后往前）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以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。
汇编语言实验2-顺序程序设计
汇编语言实验报告Assembly Language Programming Lab Reports______________________________________________________________________________班级： _________ 姓名：___________ 学号：___________ 实验日期：_____________学院： _____计算机与通信工程学院____ 专业：_______计算机科学与技术___________实验顺序：___实验二____ 实验名称： ___________顺序程序设计________________ 实验分数：_______ 考评日期:________ 指导教师：______________________________________________________________________________一．实验目的1.掌握非压缩的BCD码运算及其调整办法。
2.掌握Dos功能调用int 21h的1，2，9，10号功能。
3.掌握Bios功能调用int 10h的3号功能。
______________________________________________________________________________二．实验环境操作系统：windows xp编译程序：masm 5.0______________________________________________________________________________三．实验原理1.dos功能调用，利用10号dos功能调用，输入一串字符串，利用9号dos功能调用，输出显示之前输入的字符串代码如下：2.利用int10h获得光标的行列号，算出相应在显存的位置，输出想要的字符代码如下：3.输入是转化由ascii码转成实际十六进制数，mul相乘后，采用非压缩bcd码相乘调整aam，高位低位分别采用非进位加法和进位加法，最后转回ascii码输出代码如下：______________________________________________________________________________四．实验步骤及结果分析1.Dos功能调用。
用汇编语言冒泡排序经典程序
冒泡排序时间复杂度
最好情况：O(n)
平均情况：O(n²)
最坏情况：O(n²)
Part Two
汇编语言基础知识
汇编语言概述
汇编语言是一种低级编程语言，与机器语言相对应。
它使用助记符和操作码表示指令，易于理解和编写。
汇编语言通常用于嵌入式系统、操作系统等底层开发。
注意事项：确保编译和链接的正确性，避免出现错误和警告
工具使用：使用编译器和链接器等工具进行编译和链接
链接过程：将目标文件合并成一个可执行文件
程序运行及结果
输入数据：随机生成一组整数
程序运行过程：按照冒泡排序算法进行排序
输出结果：排序后的整数序列
测试结果：对多个不同规模的输入数据进行测试，验证程序的正确性和稳定性
代码注释：对每行代码进行详细解释，帮助理解算法实现过程
代码解析：分析代码结构，解释冒泡排序算法的汇编语言实现方式
寄存器使用：说明在汇编语言中如何使用寄存器进行数据交换和比较
优化点：分析代码中可以优化的地方，提高程序执行效率
Part Four
程序运行及测试
程序编译链接
编译过程：将源代码转换成机器语言
指令格式：汇编语言指令由操作码和操作数组成，操作码指明指令的操作类型，操作数指明操作数或操作数的地址。
伪指令：伪指令不是真正的计算机指令，而是用于告诉汇编程序如何组织程序的一种指示。常见的伪指令包括ORG、END、DB、DW等。
Part Three
汇编语言实现冒泡排序
排序数据准备
确定排序数据类型：根据具体需求选择合适的数据类型，如整数、字符等。
优化效果：通过减少数据交换次数，可以提高冒泡排序算法的执行效率，减少程序运行时间
排序汇编语言程序设计
第8章 数组 第3单元 问题求解与算法设计基础-3第13讲 冒泡排序怎么样帮我们按身材的高低顺序进行排队的61 83 88 84 8783 61 88 84 87 83 88 61 84 87 83 88 87 84 61第1遍84 83 87 61 88第2遍84 83 87 61 88 84 83 88 61 87第3遍83 84 87 61 8883 84 87 61 88第4遍83 84 87 61 8883 88 87 84 6184 88 87 83 61 84 88 87 83 61 84 87 88 83 61第1遍84 87 61 83 88第2遍84 87 61 83 88 84 87 61 83 88第3遍84 61 87 83 8884 61 87 83 88第4遍61 84 87 83 88比较相邻的两个数据 若顺序不对，则将其位置交换第8章 数组 第3单元 问题求解与算法设计基础-3第14讲 交换、选择排序哈尔滨工业大学叶麟683 88 87 84 6184 88 87 83 61 84 88 87 83 61 84 88 87 6183 第1遍84 88 87 61 83第2遍84 88 87 61 8388 87 84 61 83第3遍88 87 83 61 8487 88 83 61 84第4遍84 88 83 61 87第一个数分别与后面所有的数进行比较，若后面的数较小，则交换后面这个数和第一个数的位置第二个数分别与后面所有的数进行比较，若后面的数较小，则交换后面这个数和第二个数的位置……………………………………………………………………………83 88 87 84 6161 83 88 87 8461 83 87 88 8461 83 84 87 88第1遍第2遍 第3遍 第4遍 在每一遍比较中，在剩余的待比较的数中选择一个最小的数与这个剩余序列的第1个数交换位置n⏹ 选择排序是一种有效的排序算法吗？n⏹ 所需步骤Þ 找到最小的元素需要 n 步Þ 找到剩余的最小元素需要 n-1 步Þ ……n(n+1)/2或者(n2+n)/2 n⏹ 总运行时间Þ n + (n – 1) + … + 2 + 1n (n2+n)/2 10 5520 210 40 820100 5050 200 20100 400 80200 1000 500500 2000 2001000 4000 8002000 10000 50005000序列长度翻一番 排序算法的运行时间要翻两番n⏹ 随着n的增大，n和算法性能之间的关系称为算法的计算复杂度（Computational Complexity）n⏹ 时间复杂度（Time Complexity）和空间复杂度（SpaceComplexity）n⏹ 算法的时间复杂度是算法的时间量度，是指执行算法所需要的计算工作量n⏹ 一个算法花费的时间与算法中语句的执行次数是成正比的，n⏹ 算法的基本操作被重复执行的次数是问题规模n的某个函数f(n)，因此，算法的时间复杂度记为：T(n)=O(f(n))大O符号 大O记法(Big O notation) n⏹ O(n2)表示算法性能随问题规模n 的平方而变化n n2/2n/2(n2+n)/2 1050555100 5 00050 5 0501 000500 000500500 500 10 00050 000 000 5 00050 005 000 100 0005000 000 00050 0005000 050 000n⏹ 常用的简化方式如下：Þ 删除随n值增大而对总估值不再重要的项，只保留在公式中占主导地位的项，即最高阶项Þ 删除所有的常数因子。
选择排序的汇编语言
例：将10个单元字节无符号数升序排序，排序前后的数据均置于内部RAM的50H～59H单元内选择排序法先确定位置，然后在寻找应该占用这个位置的对象，这就是选择排序算法。
假设要将N个无序数据按增序进行排序，首先确定第一个位置（地址），然后寻找数据对象，在N个无序数据中找到最小数据，放在第一个位置。
假设最小值占有第k个位置，则将它搬到第一个位置上，然后将原来占有第一个位置的数据元素存放到空出的第k个位置，即和应该占有这个位置的元素交换位置。
最后一个数据就是经过N-1次选择后剩下的数据，肯定是全部数据中的最大值，理所当然占有最后一个位置。
选择排序算法主要是进行最小值的选择，这是通过一系列的比较实现的，不需要进行位置移动，故在数据元素的结构比较大（多字节）的情况下具有较高的效率。
例：重作上题，要求用选择排序法。
1）题目分析从50H单元开始进行比较，第一个循环比较9次，选择出最小值，存入50H；第二个循环比较8次，选择出次最小值，存入51H；依此类推，共需要进行9个循环。
2）硬件资源分配：内部RAM的50H～59H：排序前后数据存放区B：保存本轮比较最小值R0：本次最小值存放地址R1：与本次最小值存放地址相邻的地址R2：排序处理的次数，即外循环次数R3：一个内循环中最小值所在地址R4：本次比较次数，即内循环次数3）程序流程图如图7-3所示4）参考程序DAT EQU 50H ;待排序数据首地址N EQU 10 ;待排序数据元素个数XZPX: MOV R0,#DAT ;从第一个位置开始MOV R2,#N-1 ;需要处理的元素为N-1 LOOP: MOV B,@R0 ;取当前元素作为最小值的初始值 MOV A,R0MOV R3,A ;取当前位置作为最小值的位置 INC AMOV R1,A ;取下一个位置作为比较的开始 MOV A,R2MOV R4,A ;控制比较次数LOOP1:MOV A,@R1 ;取一个数据元素CLR CSUBB A,B ;与当前最小值比较JNC LOOP2 ;不小于当前最小值MOV B,@R1 ;保存新的最小值MOV A,R1MOV R3,A ;保存新的最小值地址LOOP2:INC R1 ;调整指针DJNZ R4,LOOP1 ;比较完全部未排序元素MOV A,R3 ;MOV R1,A ;取当前最小值的地址MOV A,@R1 ;将当前最小值和指定位置的数据元素进行交换XCH A,@R0XCH A,@R1INC R0 ;处理下一个位置DJNZ R2,LOOP ;处理完前N-1个位置RET。
汇编排序程序
用汇编语言编写一个程序，要求输入数据，并按照从小到大的顺序排序显示出来。
data segmentnum dw 20 dup(?);存输入数列i dw 0 ;数列个数char db 0dh,'xiao--->da:',0ah,0dh,'$'rec db 5 dup(?) ;输出缓存data endscode segmentmain proc farassume cs:code,ds:datastart:push dsmov ax,datamov ds,axmov si,0mov bx,0call inputzcall orderzcall outputzmain endpinputz procinput:mov ah,01hint 21hcmp al,20h;遇到空格写数据jz write1cmp al,0dh;遇到回车写最后一个数据jz write2sub al,30hmov cl,almov ch,00hmov ax,bxmov bx,0ahmul bxmov bx,axadd bx,cxjmp inputwrite1: ;write the numbers before Spaceadd si,2inc imov bx,0jmp inputwrite2:mov [num+si],bxadd si,2inc imov dl,0ahmov ah,02hint 21hretinputz endporderz procbeforeorder:mov cx,idec cxloop1:mov di,cxmov bx,0loop2:mov ax,num[bx]cmp ax,num[bx+2]jbe continuexchg ax,num[bx+2]mov num[bx],ax continue:add bx,2loop loop2mov cx,diloop loop1retorderz endp;outputz procinitnum: ;changenum初始化lea dx,charmov ah,09hint 21hmov cx,imov di,0 loopnum:add di,2mov bx,10mov si,4changenum: ;二进制->BCDmov dx,0div bxmov [rec+si],dldec sicmp ax,0ja changenumoutputnum: ;输出（从initnum开始，做预备工作）inc simov dl,[rec+si]add dl,30hmov ah,02hint 21hcmp si,4jb outputnummov dl,20hmov ah,02hint 21hloop loopnummov ah,4chint 21hretoutputz endpcode endsend start。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
用汇编语言编写的排序程序
一实验目的 (3)
二题目 (3)
三算法分析 (3)
四流程图及算法 (5)
五源程序
附录
a、参考文献
一实验目的：
1、进一步熟悉汇编语言的代码；
2、学会分析算法并构造流程图；
3、能够完成简单的子程序设计；
4、学会查找程序的算法。
二题目
将以地址ＤＡＴＡ开始的１０个无符号字数据按从大到小的顺序重新排列
三算法分析
排序算法采用冒泡法，假定待排序数组中有X1，X2，X3，…X10共十个无符号数据，冒泡排序法的具体做法是：最多有九次外循环。
每次外循环均从底部开始进行两两比较，若后者大于前者，两者位置交换，反之不变。
然后两两比较向前推移，直到本次外循环应完成的两两比较次数（成为内循环次数达到为止）。
此时，本次外循环结束,最大的数冒到本次外循环的顶部。
第一次外循环，第一次外循环，两两比较的次数为n-1次，最大数据冒到X1的位置；第二次外循环，两两比较次数为n-2次，剩余最大数据冒到X2位置；以此类推，第n-1次外循环，两两比较次数为1次，剩余最大数据项冒到X n-1的位置。
若再一次外循环结束后，经判断本次外循环一次位置交换也未发生过或仅在底部发生过一次交换，则本次外循环结束，数的顺序已排妥，余下的外循环不用进行了。
流程图如上所示。
根据流程图编写程序：如下：
;程序模板
SSEG SEGMENT PARA STACK 'stack'
dw 100h dup(0) ;初始化堆栈大小为100
SSEG ENDS
DSEG SEGMENT
DATA DW 150,12,54,89,73,152,45,68,98,65
COUNT EQU $-DATA
BUFO DB 6 DUP (?),'$'
DSEG ENDS
ESEG SEGMENT
;附加段：在此处添加程序所需的数据
ESEG ENDS
CSEG SEGMENT
assume cs:CSEG, ds:DSEG, es:ESEG, ss:SSEG
DISP PROC ；显示DI所指ASCII字符串的子程序
PUSH DX
PUSH AX
MOV DX,DI
MOV AH,09H
INT 21H
MOV DL,','
MOV AH,2
INT 21H
POP AX
POP DX
RET
DISP ENDP
DATCH PROC FAR ；转换数值成为ASCII串的子程序
PUSH DX ；入口参数在AX中，要转换的数在DI中 PUSH CX ；出口参数在DI中，是结果缓冲区指针 PUSH BX
MOV CX,10
MOV BX,AX
DLOP1:DEC DI
XOR DX,DX
DIV CX
OR DL,30H
MOV [DI], DL
CMP AX,0
JNZ DLOP1
POP BX
POP CX
POP DX
RET
DATCH ENDP
MAIN PROC FAR ;主程序入口
mov ax, dseg
mov ds, ax
mov ax,eseg
mov es, ax
START:XOR AX,AX
MOV DX,AX ；主程序
MOV CX,AX
MOV DX,COUNT/2 ；DX，被排序数据个数
LOP1: DEC DX ；DX，大循环变量（大循环次数）
MOV CX,DX ；CX，小循环变量(两两比较次数) MOV BX,DX ;设置交换标志
LEA SI,BUFO
SUB SI,2
LOP2: MOV AX,[SI]
CMP AX,[SI-2]
JBE PASS
XCHG [SI-2],AX
MOV [SI],AX
MOV BX,CX
PASS: SUB SI,2
LOOP LOP2
CMP BX,DX
JE DLAST ；数的顺序已排妥，转DLAST
JMP LOP1
DLAST:MOV CX,COUNT/2 ；显示的数据个数
LEA SI,DATA ；数据的缓存区首地址
LOP3: MOV AX,[SI]
MOV DI,OFFSET BUFO
ADD DI,LENGTH BUFO
CALL DATCH
CALL DISP
ADD SI,2
LOOP LOP3
mov ah,1
int 21h
mov ax, 4c00h ;程序结束，返回到操作系统系统int 21h
MAIN ENDP
CSEG ENDS
END MAIN
结果：。