汇编语言实现实现冒泡排序,并将排序后的数输出

合集下载

汇编语言输入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) 需要两层循环，为了提⾼代码的可读性，我们将内层的循环写成⼀个⼦程序每次调⽤内层循环很简单，每次从头⽐到尾，遇到⽐它⼩的交换就可以了。

汇编冒泡法排序

汇编实验报告实验题目：从键盘输入任意5个2位有符号十进制数，采用“冒泡法”进行升序排序，输出排序后的结果，并输出排序次数。

实验设计：实验要求用16位机的汇编语言完成，键盘上输入的的数据最终都会以ASCII码形式接受，输出也要求用ASCII码，因而我决定设计专门负责输入和输出的两个子程序。

但是由于要求输入的是有符号的而且是长度不一定不确定的十进制数，用一个子程序直接在输入时转换成二进制会比较麻烦，因而决定可以先以字符串的形式接受来自用户的数据，这样可以以最自由的形式接受数据，不仅数据长度问题可以解决，带不带‘+’‘-’符号也可以识别，而且方便查错。

排序的主要部分是比较简单的，学C的时候已经了解，况且数据结构课又重复了一遍，因而本次实验主要需要解决的还是输入输出、以及数据的转化问题。

我的程序结构比较简单，主要包含几个子程序：GET : 调用10号模块接收一串字符,放进缓存dataEXDTB:解析缓存中的符号数据,转化为二进制并存入数组ansEXBTD:对从BX传过来的二进制数解析,并在屏幕上输出相应的十进制数,无运算结果程序:DATAS SEGMENTDATA DB 21 DUP('$')ANS DW 10 DUP(0)TES DB 'RUN HRER','$'LEN DW 0TMP DW 0SIG DW 00HSTA DW 00H ;STA ANS[STA] IS DIGENT DB 0DH,0AH,'$'RNM DB 'READ 5 DIGITALS',0AH,0DH,'$'PRIT DB 'PAIXU:',0AH,0DH,'$'FINSH DB 'NEW ORDER:','$'EORR DB 'INPUT ERROR!',0AH,0DH,'$'CISHU DB 'EXCHANGE TIME:',0DH,0AH,'$'CIS DW 0EXIT DB 'ENTER A NUMBER TO EXIT',0AH,0DH,'$'DATAS ENDSSTACK SEGMENTTOPE DW 300H DUP(0)STACK ENDSCODES SEGMENTASSUME CS:CODES, DS:DATAS,SS:STACKSTART: ;先跳过写在开头的子程序MOV AX,DATASMOV DS,AXMOV AX,STACKMOV SS,AXMOV SP,00HJMP SART ;AH=09 OUPUT AH=10 INPUT，前面注意有两个字节没用从ds:dx+2开始才是 ;第一个是输入及字符数ENTE PROC ;ENTE DISPLAY '/N' ON THE SCREENPUSH AXPUSH DXMOV AX,OFFSET ENTMOV DX,AXMOV AH,09HINT 21HPOP DXPOP AXRETENTE ENDPGET PROC ;PROC GET READ A TWO BIT DIGITAL FROM USCERPUSH AX ;;DX HAS ADDRESSPUSH DXMOV DX,OFFSET DATAMOV AH,0AH ;GET A LINE OF NUMBERINT 21H;CALL ENTEPOP DXPOP AXRETGET ENDPEXDTB PROC ;PROC EXCHANGE SIGNED DIGITAL TO BINARYPUSH AXPUSH BXPUSH CXPUSH DX ;USE DX TO STORE ANS;ANS[STA] HAS RESULT XOR DX,DXXOR CX,CXMOV BX,OFFSET DATAINC BX ;DS:DX+1 IS THE NUMBER OF INPUTED CHAR MOV CL,[BX] ;cl HAS LENGTHXOR CH,CHINC BX ;NOW BX COME TO FIRST CHAR INPUTEDMOV AL,[BX]CMP AL,'-' ;TO CHECK IF IT IS SIGNJNZ POST ;WITHOUT '-',THAT WILL BE POSTIVEMOV WORD PTR[SIG], 0001H ;SET SIG 0001H IF NEGETIVE JMP SIGNEDPOST:MOV SIG,WORD PTR 0000H ;SET POSTIVECMP AL,'+' ;IF IT HAS '+',IGNORE ITJNE PASSSIGNED:INC BXSUB CX,01HJMP STLOP ;PASS THE SIGN + -PASS: ;DIRECTLY TO NUMBERSCMP AL,'0' ;IF IT IS NUMBERJL NOTHINGCMP AL,'9'JG NOTHINGMOV DL,ALSUB DL,'0'CMP CL,1JE POSTYSUB CX,01HSTLOP:MAINLOOP:MOV AL,[BX]SUB AL,'0'JS NOTHING ;JUMP IF AL-'0'< 0 , ILLEAGLE INPUT CMP AL,09H ;JUMP IF AL-'9'> 0 ,JG NOTHINGMOV DH,DL ;SHIFT DL TO TIMES 10SHL DH,01H ;SHIFT 2 TIMES 4SHL DH,01H ;DL=DL*4+DL=5*DLADD DL,DHSHL DL,01H ;DL=5*DL*2=10*DLADD DL,ALINC BXLOOP MAINLOOPTEST SIG,0001HJZ POSTY ;JUMP TO AVOID -DXNEG DLPOSTY:MOV BX,OFFSET ANSADD BX,STAMOV AL,DLCBWMOV [BX],AXJMP DONENOTHING: ;IF NOT NUMBER , RETURN 0MOV DX,OFFSET EORRMOV AH,09HINT 21HMOV BX,OFFSET ANSADD BX,STAMOV [BX],WORD PTR 0001HDONE:CALL ENTEPOP CXPOP BXPOP AXRETEXDTB ENDPEXBTD PROC ;PROC EXCHANGE BINARY NUMBER IN BX TO DIGITAL PUSH AXPUSH BXPUSH CXPUSH DXCALL ENTE ;DISPLAY '/N'TEST BX,8000HJZ POSTVMOV DL,'-'MOV AH,02HINT 21HNEG BX ;EXCHANGE TO POSTIVEPOSTV:MOV CX,1111HPUSH CXMOV AX,BXCWDMOV BX,10MLOOP:DIV BX ;DIV 10PUSH DX ;PUSH BX MOD 10CWDADD AX,00HJNZ MLOOPDSLOOP: ;DISPLAY NUMPOP DXCMP DX,1111HJE FINISHADD DL,'0'MOV AH,02HINT 21HJMP DSLOOPFINISH:;CALL ENTEPOP DXPOP CXPOP BXPOP AXRETEXBTD ENDPSART:MOV DX,OFFSET PRITMOV AH,09HINT 21HMOV DX,OFFSET RNMMOV AH,09INT 21HMOV CX,05HMOV WORD PTR[STA],0000HGETLOOP:CALL GET ；读入符号数CALL EXDTB ;转为二进制ADD WORD PTR[STA],0002H;存入数组ans LOOP GETLOOPMOV WORD PTR[CIS],00HARRAGE: ；排序MOV CX,05HSUB CX,0001HMOV BX,OFFSET ANSADD BX,CXADD BX,CXLOOP1:MOV TMP,CXPUSH BXLOOP2:MOV AX,WORD PTR[BX]SUB BX,0002HMOV DX,WORD PTR[BX]CMP AX,DXJNS BIGGERINC WORD PTR[CIS]MOV WORD PTR[BX],AXMOV 02H[BX],DXBIGGER:SUB WORD PTR[TMP],0001H JNZ LOOP2POP BXLOOP LOOP1WRITE: ；输出排好序的数MOV DX,OFFSET FINSHMOV AH,09HINT 21HMOV CX,05MOV WORD PTR[STA],0000HMOV BX,OFFSET ANSLOOPWR:PUSH BXADD BX,STAMOV DX,[BX]MOV BX,DXCALL EXBTDPOP BXADD WORD PTR[STA],0002HLOOP LOOPWRCALL ENTEMOV DX,OFFSET CISHUMOV AH,09HINT 21HMOV BX,[CIS]CALL EXBTDCALL ENTEMOV DX,OFFSET EXITMOV AH,09HINT 21HCALL GETMOV AX,4C00HINT 21HCODES ENDSEND START问题及调试:主要问题是数据的转化，当我们用C写程序时，直接可以用%开头的格式命令进行特定类型的数据输入输出，但是用汇编时就没有那么好办了，输入的时候要识别数据，输出也要转化数据。

史上最牛最完整的汇编语言冒泡排序程序

;题目：编制一个完整的汇编语言程序，从键盘上读入若干个（可以超过十个）十进制数（正数），排序后在屏幕上输出。

;采用冒泡法排序，综合运用子程序和宏汇编，使程序模块化。

;程序代码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，则退;进行显示;子程序返回。

汇编语言实现整数冒泡排序

第三次实验报告1.实现正整数的冒泡排序，要求有输入与输出。

实验源程序;LT413.ASM.model small.stack.datacount = 10array dw count dup(0)wtemp dw ?flg db 0.code.startupmov cx,countmov bx,offset arrayagaini: call readmov [bx],axinc bxinc bxcall dpcrlfiloop againi;;mov cx,countdec cxoutlp:mov flg,0mov dx,cxmov bx,offset arrayinlp: mov ax,[bx]cmp ax,[bx+2]jna nextxchg ax,[bx+2]mov flg,1mov [bx],axnext: inc bxinc bxjnz inlpcmp flg,0jz fxwloop outlp;;fxw:mov cx,countmov bx,offset array againo: mov ax,[bx]mov wtemp,axcall writeinc bxinc bxcall dpcrlfoloop againo.exit 0read procpush bxpush cxpush dxxor bx,bxxor cx,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,1mov dx,bxshl bx,1add bx,dx;mov ah,0add bx,axjmp read1read3: cmp cx,0jz read4neg bxread4: mov ax,bxpop dxpop cxpop bxretread endp dpcrlfi procpush axpush dxmov ah,2mov dl,0dhint 21hmov ah,2mov dl,0ahint 21hpop dxpop axretdpcrlfi endpwrite procpush axpush bxpush dxmov ax,wtemptest ax,axjnz write1mov dl,'0'mov ah,2int 21hjmp write5 write1: jns write2 mov bx,axmov dl,'-'mov ah,2int 21hmov ax,bxneg axwrite2: mov bx,10push bxwrite3: cmp ax,0jz write4sub dx,dxdiv bxadd dl,30hpush dxjmp write3write4: pop dxcmp dl,10je write5mov ah,2int 21hjmp write4write5: pop dxpop bxpop 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.datastring1 db 'Mean1 use register :','$'string2 db 'Mean2 use variable :','$'string3 db 'Mean3 use stack :','$'string4 db 0dh,0ah,'$'mydata dw 1992hwordTEMP dw ?.code.startup;AX方式mov dx,offset string1;mov ah,9;int 21h;mov ax,word ptr mydata;call chan1;;变量方式push axmov dx,offset string4;mov ah,09h;int 21h;mov dx,offset string2;mov ah,09h;int 21h;pop axmov word ptr wordTEMP,ax;call chan2;;栈方式push axmov dx,offset string4;mov ah,09h;int 21h;mov dx,offset string3;mov ah,09h;int 21h;pop axpush ax;call chan3;pop ax;.exit 0chan1 procpush ax;push bx;mov bl,al;mov al,ah;call ALdisp;mov al,bl;call ALdisp;pop bx;pop ax;retchan1 endpchan2 proc;wordTEMP传递push ax;push bx;mov bl,al;mov al,ah;call ALdisp;mov al,bl;call ALdisp;pop ax;retchan2 endpchan3 proc;栈传递push bp;mov bp,sp;push ax;push bx;mov ax,[bp+4];mov bl,al;mov al,ah;call ALdisp;mov al,bl;call ALdisp;pop bx;pop ax;pop bp;retchan3 endpALdisp procpush axpush cxpush dxpush axmov dl,almov cl,4shr dl,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实验结果：。

汇编语言-冒泡排序(绝对给力)

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。

单片机用51汇编实现冒泡

单片机作业题目要求：用冒泡排序法实现将一组无序的数据从小到大的排列（本人设计的程序实现的是8个无序数字的排序）。

程序设计：程序实现（已做详细注释）：;================================================; 文件名称: Asm2.asm; 功能描述: 冒泡排序，升序;================================================ORG 0000H ;程序的加载地址LJMP MAIN ;程序加载后执行的第一条语句，即跳刀main 函数ORG 0100H ;;MAIN: MOV R0,#07H ;MOV 20H,#34H ;把数据存到起始地址为20H的内存中MOV 21H,#23H ;把数据存到起始地址为21H的内存中MOV 22H,#89H ;把数据存到起始地址为22H的内存中MOV 23H,#30H ;把数据存到起始地址为23H的内存中MOV 24H,#22H ;把数据存到起始地址为24H的内存中MOV 25H,#01H ;把数据存到起始地址为25H的内存中MOV 26H,#20H ;把数据存到起始地址为26H的内存中MOV 27H,#86H ;把数据存到起始地址为27H的内存中MOV 28H,#38H ;把数据存到起始地址为28H的内存中MOV 29H,#76H ;把数据存到起始地址为29H的内存中LOOP1: MOV R1,#20H ;R1指向数据首地址MOV A,R0 ;MOV R2,A ;把进行一次冒泡的次数存到R2中LOOP2: MOV A,@R1 ;比较开始，取第一个数MOV R3,A ;简单的转存一下前一个数，腾出累加器; AINC R1 ; 指向下一个地址SUBB A,@R1 ;取后一个数，并与前一个数相减，看是否有CY位溢出，溢出则说明前一个数小，要换位JC LOOP3 ;前一个数小的情况下，两个数交换位置，否则，继续执行MOV A,R3 ;把后一个数存到累加器下XCH A,@R1 ;累加器的数与R1指向的数交换;位置，即;前一个数和后一个数交; 换位置DEC R1 ;R1自减，准备将后面的数存到前面MOV @R1,A ;将后面的数存到前面INC R1 ;R1自增，准备下次转换LOOP3: DJNZ R2,LOOP2 ;R2自减，为下次冒泡准备DJNZ R0,LOOP1 ;跳回去进行下一轮冒泡SJMP $ ;程序结束END程序调试：1.单步调试，展示内存中存入的无序的数据存入时的代码：MOV 20H,#34H ;把数据存到起始地址为20H的内存中MOV 21H,#23H ;把数据存到起始地址为21H的内存中MOV 22H,#89H ;把数据存到起始地址为22H的内存中MOV 23H,#30H ;把数据存到起始地址为23H的内存中MOV 24H,#22H ;把数据存到起始地址为24H的内存中MOV 25H,#01H ;把数据存到起始地址为25H的内存中MOV 26H,#20H ;把数据存到起始地址为26H的内存中MOV 27H,#86H ;把数据存到起始地址为27H的内存中可以看到已存内存中的数完全无序。

汇编语言实现实现冒泡排序,并将排序后的数输出

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次
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 ;下一个数
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
ADD SI,2 ;下一个数
POP CX ;循环次数出栈栈
LOOP SHOW
MOV AH,4CH
INT 21H
BUBBLE PROC
L1: PUSH CX ;将循环次数入栈
LEA SI,A ;SI遍历DATAS数据段的数字
MOV CX,DX ;将余数转移到CX
MOV DX,BX ;将商int(H/N)转移到dx,相当于int(H/N)*65536
RET ;子程序定义结束
DIVDW ENDP
;实现字符串的输出
LOOP L2 ;注意内层循环的次数已经确定了

arm汇编之冒泡排序

arm汇编之冒泡排序AREA Sort,CODE,READONLY ：首先用AREA伪代码加上CODE，表明下面引出的将是一个代码段（于此相对的还有数据段DATA），ENTRY 和END成对出现，说明他们之间的代码是程序的主体ENTRY：表示代码的开始Start MOV r4,#0 ：将0赋值给r4LDR r6,=src ：在使用LDR时，当格式是LDR r0,=0x022248，则第二个参数表示地址，即0x022248，同样的，当src变量代表一个数组时，需要r0寄存器指向src则需要这样赋值：LDR r0,=src 当格式是LDR r0,[r2]，则第二个参数表示寄存器，我的理解是[]符号表示取内容，r2本身表示一个寄存器地址，取内容候将其存取r0这个寄存器中跳转到LDR R0,[R1]将存储器地址为R1的字数据读入寄存器R0 LDRR0,[R1,#8]将存储器地址为R1+8的字数据读入寄存器R0，并将新地址R1+8写入R1，此句是将数据src的首地址赋值给R6ADD r6,r6,#len：R6为数组的最后一个数组元素的地址。

数组这时是连续分配的。

Outer LDR r1,=src：将src地址即数组元素首地址赋值给R1Inner LDR r2,[r1] ：将存储器地址为r1的字数据读入r2 LDR r3,[r1,#4]：将存储器地址为R1+4的字数据读入R3CMP r2,r3 ：比较R2,R3STRGT r3,[r1]：若（有符号数）大于，则将R3中的字数据写入以R1为地址的存储器中STRGT r2,[r1,#4]：若大于，则将R2中的字数据写入以R1+4为地址的存储器中ADD r1,r1,#4：R1+4赋值给R1CMP r1,r6：R1与R6比较BLT Inner：若是有符号数小于，即R1<R6，则跳转到Inner行执行ADD r4,r4,#4：R4+4赋值给R4CMP r4,#len：R4与len比较SUBLE r6,r6,#4 ：若有符号数小于或等于，则R6-4赋值给R6BLE Outer ：若有符号数小于或等于，则跳转到OuterStop MOV r0,#0x18 ， stop一段是用来是程序退出的，第一个语句“MOV r0，#0x18”将r0赋值为0x18，这个立即数对应于宏angel_SWIreason_ReportException。

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

计算机组成原理和汇编语言实验报告专业班级：计算机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．掌握简单运算器的组成以及数据传送通路。

汇编程序键盘输入10个数,排序后输出

push cx
push dx
endm
popreg macro
pop dx
pop cx
pop bx
endm
code segment
assume ds:data,cs:code,ss:stact
main: mov ax,data
mov ds,ax
mБайду номын сангаасv ax,stact
mov ss,ax
mov cx,10
汇编程序键盘输入10个数,排序后输出
从键盘输入10个数，经过冒泡排序后输出显示在屏幕上。data segment
tat db 10 dup(?)
as db 13,10,'$'
data ends
stact segment
sac db 120 dup(?)
stact ends
pushreg macro
push bx
mov bl,dh
and bl,0fh
add bl,30h
cmp bl,3ah
jl mm
add bl,7h mm: mov dl,bl
mov ah,2
int 21h
dec cx
jnz ms
mov dl,' '
mov ah,2h
int 21h
popreg
dec dx
mov cx,dx
inc bx
cmp bx,10
汇编程序键盘输入10个数,排序后输出从键盘输入10个数,经过冒泡排序后输出显示在屏幕上.data segment tat db 10 dup(?) as db 13,10,'$' data ends stact segment sac db 120 dup(?) stact ends pushreg macro push bx push cx push dx endm popreg macro pop dx pop cx pop bx endm code segment assume ds:data,cs:code,ss:stact main: mov ax,data mov ds,ax mov ax,stact mov ss,ax mov cx,10 lea si,tat qq: mov ah,1 int 21h sub al,30h rol al,4 mov bl,al mov ah,1 int 21h sub al,30h or bl,al mov [si],bl add si,1 mov ah,2 mov dl,' ' int 21h loop qq lea dx,as mov ah,09h int 21h mov dx, 10 mov cx,dx lea bx,tat p3: mov al,[bx] mov si,bx p1: inc si cmp [si],al jae p2 loop p1 p4: xchg [bx],al pushreg mov dh,[bx] mov cx,2 ms: rol dh,4 mov bl,dh and bl,0fh add bl,30h cmp bl,3ah jl mm add bl,7h mm: mov dl,bl mov ah,2 int 21h dec cx jnz ms mov dl,' ' mov ah,2h int 21h popreg dec dx mov cx,dx inc bx cmp bx,10 jnz p3 mov ah,4ch int 21h p2: xchg al,[si] dec cx jcxz p4 jmp p1 code ends end main

汇编语言汇编语言实现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`寄存器中。

8086汇编程序,实现对输入字符进行冒泡排序后输出

STACK1 SEGMENT STACKDW 256 DUP(?)STACK1 ENDSDATA SEGMENT USE16MES1 DB 'Welcome!',0AH,0DH,0AH,0DH,'Please input several alphabets:',0AH,0DH,'Press ENTER to finish!',0AH,0DH,0AH,0DH,'$'MES2 DB 'Number of total input letters(Decimal):','$'MES3 DB 'Number of big letters(Decimal):','$'MES4 DB 'Number of small letters(Decimal):','$'ALPHA DB 100 DUP(0)SUM DW 3 DUP(0)DATA ENDSCRLF MACROMOV DL,0AHMOV AH,02HINT 21HMOV DL,0DHMOV AH,02HINT 21HENDMOUTCHAR MACRO XMOV DL,XMOV AH,02HINT 21HENDMOUTSTR MACRO XLEA DX,X ;提示显示开始MOV AH,09HINT 21H ;提示显示结束ENDMSHOWNUM MACRO XMOV AX,XMOV CL,0AHDIV CLMOV CL,ALMOV CH,AHADD CH,30HADD CL,30HOUTCHAR CLOUTCHAR CHCRLFENDMSHOWRLT MACRO X,Y,Z,KCMP X,0HJE KMOV CX,XMOV BX,YZ: OUTCHAR ALPHA[BX]INC BXLOOP ZK: CRLFCRLFENDMCODE SEGMENT USE16ASSUME CS:CODE,DS:DATA START:MOV AX,DATAMOV DS,AXOUTSTR MES1 ;输出提示语MOV BX,0HAGAIN: MOV AH,07H ;键盘输入开始INT 21HCMP AL,0DH ;ENTER键JE OVERCMP AL,41H ;是否小于AJB AGAINCMP AL,7AH ;是否大于zJA AGAINCMP AL,5AH ;是否大于ZJA C1ADD SUM[02H],01HMOV ALPHA[BX],ALINC BXJMP C2C1: CMP AL,61H ;是否小于aJB AGAINADD SUM[04H],01HMOV ALPHA[BX],ALINC BXC2: OUTCHAR ALJMP AGAINOVER: CRLF ;输入结束CMP BX,0H ;输入0个字母JE EXITMOV SUM[00H],BXMOV BX,0HMOV AX,0HLEA DI,ALPHASORT: INC AXCMP AX,SUM[00H]JE EXITMOV DL,[DI]MOV BX,AXNEXT: CMP DL,ALPHA[BX]JB NOXCHG DL,ALPHA[BX]NO: INC BXCMP BX,SUM[00H]JE RANKJMP NEXTRANK: MOV [DI],DLINC DIJMP SORTJMP EXIT;TOKEY:JMP KEYEXIT: CRLFOUTSTR MES2 ;输出提示语SHOWNUM SUM[00H]CRLFOUTSTR MES3 ;输出提示语SHOWNUM SUM[02H]SHOWRLT SUM[02H],0H,BIG,OBIGOUTSTR MES4 ;输出提示语SHOWNUM SUM[04H]SHOWRLT SUM[04H],SUM[02H],SML,OSMLKEY: MOV AH,1 ;程序功能结束INT 16HJZ KEYMOV AX,4C00HINT 21HCODE ENDSEND START。

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

结果截图这样子的程序：;;无符号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
汇编语言实现冒泡排序
排序数据准备
确定排序数据类型：根据具体需求选择合适的数据类型，如整数、字符等。
优化效果：通过减少数据交换次数，可以提高冒泡排序算法的执行效率，减少程序运行时间

汇编语言基础程序 -回复

汇编语言基础程序-回复三种不同的排序算法（冒泡排序，插入排序和选择排序）在汇编语言中的基本实现。

本文将介绍每种排序算法的原理和实现步骤，并通过编写相应的汇编程序进行演示。

冒泡排序（Bubble Sort）是一种简单的排序算法，它的基本思想是通过比较相邻元素的大小，将较大（或较小）的元素逐步交换到右（或左）侧，从而实现排序。

具体而言，冒泡排序从第一个元素开始，一直到倒数第二个元素，依次比较相邻元素的大小，并逐步交换。

这样经过一轮比较和交换后，最大（或最小）的元素会浮动到右（或左）侧。

然后，继续进行下一轮比较和交换，直到所有元素都以正确的顺序排列。

代码实现：assemblysection .dataarray db 5, 9, 1, 3, 2, 8, 4, 7, 6 ; 待排序数组length equ -array ; 数组长度section .textglobal _start_start:mov ecx, 0 ; 循环计数器置0mov edx, length ; 数组长度outer_loop:cmp ecx, edx ; 判断循环是否结束jge end ; 结束循环mov eax, edx ; 内层循环次数sub eax, ecxdec eax ; 循环次数减1inner_loop:mov edi, ecx ; 当前元素索引mov esi, ecx + 1 ; 下一个元素索引mov al, [array + edi] ; 当前元素mov ah, [array + esi] ; 下一个元素cmp al, ah ; 比较大小jle skip_swap ; 如果当前元素小于等于下一个元素，则跳过交换; 交换当前元素和下一个元素mov dl, [array + edi]xchg dl, [array + esi]mov [array + edi], dlskip_swap:inc ecx ; 循环计数器加1cmp ecx, edx ; 判断是否还需进行下一轮比较和交换jl inner_loop ; 如果不需要，则退出内层循环inc edx ; 数组长度减1loop outer_loop ; 继续下一轮比较end:; 排序完成; 输出排序后的数组mov ecx, length ; 循环计数器置为数组长度print_loop:movzx eax, byte [array + ecx - 1] ; 输出当前元素add al, '0'mov [output_char], almov eax, 4mov ebx, 1mov ecx, output_charmov edx, 1int 0x80dec ecx ; 循环计数器减1cmp ecx, 0 ; 判断是否还需输出下一个元素jg print_loop; 退出程序mov eax, 1xor ebx, ebxint 0x80section .bssoutput_char resb 1插入排序（Insertion Sort）是一种简单直观的排序算法，它的基本思想是将一个待排序的元素插入已排序序列中的合适位置，从而逐步完成排序。

汇编语言冒泡排序

DATAS SEGMENTKEYBUFFER DB 100DB ?DB 100 DUP(?)A DB 100 DUP(?)X DB ?TEMP DB ?STRING1 DB 'PLEASE INPUT 10 NUMBERS : ',0DH,0AH, '$' DATAS ENDSSTACKS SEGMENT STACK 'STACK'DW 100H DUP(?)TOP LABEL WORDSTACKS ENDSCODES SEGMENTASSUME CS:CODES,DS:DATAS,SS:STACKS,ES:DATAS START:MOV AX,DATASMOV DS,AXMOV ES,AXMOV AX,STACKSMOV SS,AXLEA SP,TOPLEA DX,STRING1MOV AH,09HINT 21HLEA DX,KEYBUFFERMOV AH,0AHINT 21HMOV CX,0AHMOV DI,0LEA SI ,KEYBUFFER+2JMP LOOP1NEXT1:INC SILOOP1:MOV TEMP,10;MOV X,0MOV DL,[SI]CMP DL,20HJE NEXT1SUB DL,'0'MOV AL,DL ;十位放到ALMOV DL,[SI+1] ;个位放到DLCMP DL,20HJE NEXTCMP DL,0DHJE NEXT;MOV X,AL ;个位放入X;MUL TEMP ;个位乘1 ;MOV X,AX;MOV AL,10 ;;TEMP*10;MUL TEMP;MOV TEMP,AL ;;MUL TEMP;MOV AL,DL;MUL TEMPADD AL,DLNEXT:MOV A[DI],ALINC DIINC SI;MOV DL,X;INC SI;POP CXLOOP LOOP1MOV CX,10LOP1:MOV SI,0MOV AL,A[SI]MOV BL,10HDIV BLMOV DL,30HADD AL,DLMOV AH,02HINT 21HADD AH,DLMOV X,AHMOV AH,02HINT 21HINC SILOOP LOP1;MOV CX ,9;MOV SI,0;LOOP4:;PUSH CX;LOOP3:;MOV AL,A[SI];CMP AL,A[SI+1];JB CONTINUE;MOV BL,A[SI+1];XCHG AL,A[SI+1];MOV A[SI],BL;CONTINUE:;INC SI;LOOP LOOP3;POP CX;;MOV SI,0;LOOP LOOP4;;LEA DX,AMOV AH,9INT 21HMOV AH,4CHINT 21H CODES ENDSEND START。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

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
PUSH AX ;将低16位入栈
ADD AX,DX ;将高位与低位相加，接着判断是否已经除尽
JZ BACK ;除尽后返回调用处
POP AX ;将低16位出栈
DEC BP ;逆序存放转化后的字符，便于主程序调用SHOW_STR
JMP S
BACK:POP AX ;为了得到正确的IP值，需要出栈一次
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
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,DX ;将余数转移到CX
MOV DX,BX ;将商int(H/N)转移到dx,相当于int(H/N)*65536
RET ;子程序定义结束
DIVDW ENDP
;实现字符串的输出
SHOW_STR PROC
XCHG AX,A[SI+2] ;否则，交换前后两个数的位置
MOV A[SI],AX
NEXT:ADD SI,2 ;下一个数
LOOP L2 ;注意内层循环的次数已经确定了
POP CX ;将循环次数出栈
LOOP L1 ;下一轮比较
RET
BUBBLE ENDP
;将十进制数转换为字符串并储存起来
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
CALL BUBBLE ;调用BUBBLE将原来的数排序
;输出排序后的数
MOV CX,N/2 ;循环M次输出排序后的M个数
MOV SI,0 ;SI遍历排序后的数
MOV DI,0 ;用DI记录数字的位数
MOV BP,N+5 ;用于遍历存储的转化后的字符的位置
SHOW: PUSH CX ;循环次数入栈
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位置零
XCHG AX,A[SI+2] ;否则，交换前后两个数的位置
MOV A[SI],AX
NEXT:ADD SI,2 ;下一个数
LOOP L2 ;注意内层循环的次数已经确定了
POP CX ;将循环次数出栈
LOOP L1 ;下一轮比较
RET
BUBBLE ENDP
; 将十进制数转换为字符串并储存起来
MOV AX,[SI] ;低16位为排序后的数
CALL DTOC ;调用DTOC将十进制数转换为字符串
CALL SHOW_STR ;调用SHOW_STR将一个数转化得到的字符串输出
ADD SI,2 ;下一个数
POP CX ;循环次数出栈栈
LOOP SHOW
MOV AH,4CH
MOV DX,BX ;将商int(H/N)转移到dx,相当于int(H/N)*65536
RET ;子程序定义结束
DIVDW ENDP
;实现字符串的输出
MOV DX,0 ;由于将要进行16位除需要置高16位为0
MOV AX,[SI] ;低16位为排序后的数
CALL DTOC ;调用DTOC将十进制数转换为字符串
CALL SHOW_STR ;调用SHOW_STR将一个数转化得到的字符串输出
ADD SI,2 ;下一个数
Pபைடு நூலகம்P CX ;循环次数出栈栈
;用汇编语言实现实现冒泡排序，并将排序后的数输出
DATAS SEGMENT
A dw 100,344,3435,43433,3438,343,134,80,8,1000,65535,54,45
N=$-A ;计算数字所占的字节数
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位置零
PUSH AX ;将低16位入栈
ADD AX,DX ;将高位与低位相加，接着判断是否已经除尽
JZ BACK ;除尽后返回调用处
POP AX ;将低16位出栈
DEC BP ;逆序存放转化后的字符，便于主程序调用SHOW_STR
JMP S
BACK:POP AX ;为了得到正确的IP值，需要出栈一次
DTOC PROC
S:MOV CX,10 ;将除数10，放入CX中
CALL DIVDW ;调用DIVDW程序
ADD CL,30H ;把数字转换为ASCII码，这样就能显示了
MOV DS:[BP],CL ;把ASCII码放到内存中
INC DI ;用DI记录循环的次数
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 ;输出空格
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
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 ;如果前一个数小于或等于后一个数则继续本轮的比较
DTOC PROC
S:MOV CX,10 ;将除数10，放入CX中
CALL DIVDW ;调用DIVDW程序
ADD CL,30H ;把数字转换为ASCII码，这样就能显示了
MOV DS:[BP],CL ;把ASCII码放到内存中
INC DI ;用DI记录循环的次数
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 ;如果前一个数小于或等于后一个数则继续本轮的比较
;输出排序后的数
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
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次
INT 21H
RET
SHOW_STR ENDP
CODES ENDS
END START