微机原理实验报告冒泡排序
冒泡排序(实验报告)
一、实验目的和要求理解和掌握冒泡排序技术，使用C语言根据相应算法编写一个程序，实现冒泡排序。
要求仔细阅读下面的内容，编写C程序，上机通过，并观察其结果，写出实验报告书。
二、实验内容和原理内容：用冒泡排序对顺序存储的长度为10的无序线性表排序。
原理：首先，从表头开始往后扫描线性表，依次比较相邻两个元素，若前面的元素大于后面的元素，将它们交换。
然后，从后往前扫描后面的线性表，依次比较相邻两个元素，若后面的元素大于前面的元素，将它们交换。
对剩下的线性表重复上述过程，直到剩余表为空。
此时的线性表为有序。
三、主要仪器设备计算机一台四、实验主程序#include<stdio.h>void bub(int a[],int n);int main(void){inta[10]={456,1564,1231,44,1,32,78,15,3,6 56},i;for(i=0;i<10;++i)printf("%d ",a[i]);printf("\n");bub(a,10);for(i=0;i<10;++i)printf("%d ",a[i]);printf("\n");getchar();return 0;}void bub(int a[],int n){int i,j,k,m,temp;k=0;m=n-1;while(k<m){j=m;m=0;for(i=k;i<j;++i)if(a[i]>a[i+1]){temp=a[i];a[i]=a[i+1];a[i+1]=temp;m=i;}j=k;k=0;for(i=m;i>j;--i)if(a[i]<a[i-1]){temp=a[i];a[i]=a[i-1];a[i-1]=temp;k=i;}}}实验结果五、实验心得通过实验学习，我理解了冒泡排序的算法，并实现了用c语言编写程序，提高了我的编程能力，受益匪浅。
微机原理实验报告冒泡法对数据排序8页
微机原理实验报告冒泡法对数据排序8页
实验目的：通过对冒泡法进行实现，了解算法的实际应用，并且掌握编程语言的基本
技巧。
实验原理：
冒泡排序是一种简单的排序方法，它的基本思想就是通过不断交换相邻的元素，将较
小的元素交换到前面，较大的元素交换到后面，从而将整个数列按从小到大（或从大到小）的顺序进行排列。
实验步骤：
（1）首先，输入需要排序的数据，将这些数据依次存储在数组中。
（2）然后，对这个数组进行冒泡排序操作。
具体的操作是：从数组的第一个元素开始，依次比较相邻两个元素的大小关系，如果后面的元素小于前面的元素，就将它们交换位置，直到将整个数组排列好为止。
（3）最后，输出排列好的数据。
实验代码：
2. 对这个数组进行冒泡排序操作。
实验结果：
输入需要排序的 10 个整数：
5 2 4 7 9 1 3 8
6 0
冒泡排序后的结果为：
0 1 2 3 4 5 6 7 8 9
实验分析：
通过本次实验，我们成功地实现了冒泡法对数据排序的操作。
在程序的实现过程中，
我们利用了C语言中的数组和循环结构等基本语言要素，完成了对数组中的数据进行排序
的操作。
通过本次实验，我们深入了解了算法的实际应用，掌握了编程语言的基本技巧，
对于今后的学习和实践具有重要的意义。
冒泡实验报告怎么写
冒泡实验报告怎么写引言冒泡排序是一种简单但效率较低的排序算法，它通过比较相邻元素的大小并根据需要交换位置来逐渐将待排序的数列排序。
本实验旨在通过实际编程实现和运行冒泡排序算法，观察和分析其性能，并比较不同规模数据下冒泡排序的时间复杂度。
实验目的1. 理解冒泡排序算法的基本原理；2. 掌握冒泡排序算法的实现方法；3. 理解冒泡排序算法的时间复杂度。
实验步骤1. 首先，我们需要准备一个待排序的数组。
数组的大小可以根据实际需要进行调整，为了便于观察，我们选择了一个小规模的数组，但原理适用于任意长度的数组。
2. 实现冒泡排序算法。
冒泡排序算法的基本思想是从数组的第一个元素开始，不断比较相邻的两个元素，并根据需要交换它们的位置，直到没有需要交换的元素为止。
3. 计算冒泡排序算法的时间复杂度。
在冒泡排序算法中，最多需要比较和交换的次数是确定的，可以根据数组的大小进行计算。
实验结果经过实际运行，我们得到了冒泡排序算法的运行结果。
以一个长度为10的数组为例，初始数组为`[5, 8, 2, 6, 9, 1, 3, 7, 4, 10]`，经过冒泡排序后，数组变为`[1,2, 3, 4, 5, 6, 7, 8, 9, 10]`。
以下是冒泡排序算法的实现代码（使用Python语言编写）：pythondef bubble_sort(arr):n = len(arr)for i in range(n):for j in range(0, n - i - 1):if arr[j] > arr[j + 1]:arr[j], arr[j + 1] = arr[j + 1], arr[j]实验分析根据实验结果，我们可以得出结论：冒泡排序算法可以将给定的数组按升序排列。
但是，冒泡排序的时间复杂度较高，它需要进行多次比较和交换操作才能完成排序，导致性能较差。
尤其是当数组规模较大时，冒泡排序的时间复杂度会呈现指数级增长。
冒泡排序算法的时间复杂度为O(n^2)，其中n是数组的长度。
微机上机实验冒泡排序法
微机上机实验冒泡排序法DATAS SEGMENTINPUT DB 'INPUT',10,13,'$'NUM1 DB 4,?,3 DUP(?)NUM2 DB 4,?,3 DUP(?)NUM3 DB 4,?,3 DUP(?)NUM4 DB 4,?,3 DUP(?)NUM5 DB 4,?,3 DUP(?)NUM DB 3 DUP (?);作为比较后交换的一个过渡AV DB ?,?,?PAIXU DB 'PAI XU HOU DE SHU ZHI',10,13,'$'MAX DB 'ZUI DA ZHI SHI',10,13,'$'MIN DB 'ZUI XIAO ZHI SHI',10,13,'$'AVERAGE DB 'PING JUN SHU SHI',10,13,'$'TIME DW ?;过渡值TIME1 DB ?;过渡值CHUSHU1 DW 3CHUSHU DB 100,10HESHU DW ?STRINGS1 DB 16 DUP(?)STRINGS2 DB 'ER JIN ZHI CHUAN',10,13,'$'DATAS ENDSCODES SEGMENTASSUME CS:CODES,DS:DATASSTART:MOV AX,DATASMOV DS,AXMOV ES,AXLEA DX,INPUT;显示INPUTMOV AH,9INT 21H;*************************************************输入5个待比较数字MOV CX,5;输入五个数字MOV SI,0AGAIN:LEA DX,[NUM1+SI];输入字符串MOV AH,10INT 21HMOV DL,10;输入后换行MOV AH,2ADD SI,5;指针加5，指向下一个变量LOOP AGAIN;*************************************************比较五个数的大小，并从小到大排序CLDMOV CX,4L1: MOV BP,0PUSH CX;计数器入栈BJ:MOV AX,CXMOV CX,3LEA SI,[NUM1+BP+2];逐位比较两个数大小LEA DI,[NUM1+BP+7]REPZ CMPSBJB L2;如果小于直接比较下一个数，否则两个数对换位置MOV CX,3LEA SI,NUM1[BP+2];LEA DI,NUMREP MOVSBMOV CX,3LEA SI,NUM1[BP+7]LEA DI,NUM1[BP+2]REP MOVSBMOV CX,3LEA SI,NUMLEA DI,NUM1[BP+7]REP MOVSBL2:ADD BP,5;BP加5，执行后指向后面两个数字MOV CX,AXLOOP BJ;CX不等于零继续比较POP CX;计数器出栈LOOP L1;*************************************************输出排序后的5个数字LEA DX,PAIXU;输出字符串'PAI XU HOU DE SHU ZHI'MOV AH,9INT 21HMOV CX,5MOV SI,2OUTPUT:PUSH CX;计数器入栈MOV CX,3L3:MOV AL,[NUM1+SI];输出数字MOV AH,2INT 21HINC SILOOP L3MOV DL,3CHMOV AH,2INT 21HADD SI,2POP CX;计数器出栈LOOP OUTPUTMOV DL,10MOV AH,2INT 21HMOV DL,0DHMOV AH,2INT 21H;*************************************************求除最大最小数之外三个数的平均数MOV CX,3MOV BX,10;除数10MOV SI,2ADD0:MOV DX,0MOV AH,0MOV TIME,CX;将CX暂时放在TIME中MOV CX,3ADD1:MOV AL,[NUM2+SI];将十进制数转换为二进制数SUB AL,30HPUSH AXMOV AX,DXMUL BXMOV DX,AXPOP AXADD DX,AXINC SILOOP ADD1;每执行完一次，就完成一个3位十进制数的转换ADD SI,2MOV CX,TIMEADD HESHU,DX;将DX的数放在HESHU中LOOP ADD0;CX=0时，就完成三个十进制数转换为二进制数之后的相加和MOV DX,HESHU;MOV AX,DXXOR DX,DXDIV CHUSHU1;除3取平均值,CHUSHU1是字变量，结果将商放在AX中，余数放在DX中;*************************************************将平均数转化为相应的字符MOV BX,AX;给BX赋值平均数DIV CHUSHU;除100取最高位ADD AL,30H;转换为ASCII码MOV AV,ALMOV AL,AHXOR AH,AHDIV [CHUSHU+1];除10取十位ADD AL,30HADD AH,30H;余数就是个位MOV [AV+1],ALMOV [AV+2],AH;*************************************************输出最大数，最小数，平均数LEA DX,MAX;输出字符串'ZUI DA ZHI SHI'MOV AH,9INT 21HMOV CX,3MOV SI,2L4: MOV DL,[NUM5+SI];输出最大字MOV AH,2INT 21HINC SILOOP L4MOV DL,10;输出最大字后换行MOV AH,2INT 21HLEA DX,MIN;输出字符串'ZUI XIAO ZHI SHI'MOV AH,9INT 21HMOV CX,3MOV SI,2L5: MOV DL,[NUM1+SI];输出最小字MOV AH,2INT 21HINC SILOOP L5MOV DL,10;输出最小字后换行MOV AH,2INT 21HLEA DX,AVERAGE;输出字符串'PING JUN SHU SHI'MOV AH,9INT 21HMOV CX,3MOV SI,0L6: MOV DL,[AV+SI];输出平均数MOV AH,2INT 21HINC SILOOP L6MOV DL,10;输出最平均数后换行MOV AH,2INT 21H;*************************************************将平均数转换为二进制串，并输出LEA DX,STRINGS2 ;输出字符串'ER JIN ZHI SHU'MOV AH,9INT 21HL7: MOV CX,LENGTH STRINGS1;将平均数转换成二进制串，放在STRINGS1中LEA DI,STRINGS1PUSH CXMOV AL,30H;将STEINGS1中字符全部写为'0'REP STOSBPOP CXMOV SI,0L8: RCL BX,1JNC L9MOV [STRINGS1+SI],31HL9: MOV DL,[STRINGS1+SI];将二进制串逐个输出MOV AH,2INT 21HINC SILOOP L8MOV AH,4CHINT 21HCODES ENDSEND START。
算法冒泡排序实验报告(3篇)
第1篇一、实验目的本次实验旨在通过实现冒泡排序算法，加深对排序算法原理的理解，掌握冒泡排序的基本操作，并分析其性能特点。
二、实验内容1. 冒泡排序原理冒泡排序是一种简单的排序算法，它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。
遍历数列的工作是重复地进行，直到没有再需要交换，也就是说该数列已经排序完成。
2. 实验步骤（1）设计一个冒泡排序函数，输入为待排序的数组，输出为排序后的数组。
（2）编写一个主函数，用于测试冒泡排序函数的正确性和性能。
（3）通过不同的数据规模和初始顺序，分析冒泡排序的性能特点。
3. 实验环境（1）编程语言：C语言（2）开发环境：Visual Studio Code（3）测试数据：随机生成的数组、有序数组、逆序数组三、实验过程1. 冒泡排序函数设计```cvoid bubbleSort(int arr[], int n) {int i, j, temp;for (i = 0; i < n - 1; i++) {for (j = 0; j < n - i - 1; j++) {if (arr[j] > arr[j + 1]) {temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}}```2. 主函数设计```cinclude <stdio.h>include <stdlib.h>include <time.h>int main() {int n;printf("请输入数组长度：");scanf("%d", &n);int arr = (int )malloc(n sizeof(int)); if (arr == NULL) {printf("内存分配失败\n");return 1;}// 生成随机数组srand((unsigned)time(NULL));for (int i = 0; i < n; i++) {arr[i] = rand() % 100;}// 冒泡排序bubbleSort(arr, n);// 打印排序结果printf("排序结果：\n");for (int i = 0; i < n; i++) {printf("%d ", arr[i]);}printf("\n");// 释放内存free(arr);return 0;}```3. 性能分析（1）对于随机生成的数组，冒泡排序的平均性能较好，时间复杂度为O(n^2)。
川大微机上机实验报告（冒泡排序法）
川⼤微机上机实验报告（冒泡排序法）上机⽬的：1、了解并逐步熟悉汇编语⾔的编辑⽅法及特点.2、复习8088汇编语⾔的段结构、常⽤的指令与伪指令、存储空间的分配等。
3、掌握汇编语⾔的编辑、汇编及连接的过程。
4、了解并逐步掌握运⽤DEBUG进⾏调试汇编语⾔程序。
5、掌握循环结构程序的设计编程。
上机内容：⽤冒泡法对⼀组数300，250，280，240，260按从⼩到⼤的顺序排列。
提⽰：1、⽤冒泡的⽅法对⼀组数据元素排序，它的基本⽅法是：将相邻的两个元素通过⽐较进⾏排序，通过多次，多遍的邻元素排序，实现整个⼀组数的排序。
2、对于5（N）个元素，整个排序通过4遍（=N-1）邻元素排序完成。
每⼀遍的排序由若⼲次邻元素的排序组成。
3、4遍排序中，邻元素的排序依次为4，3，2，1遍。
完成第⼀遍排序后，最⼤数沉底，已经到达它应占据的位置，不需要参加下⼀遍的排序。
外循环的次数为CX=4次(N-1)，内循环的次数为4，3，2，1(DEC CX)思考如何输⼊任意五个数，五个数可以有⼀位数，⼆位数，三位数，四位数，五位数，混合输⼊⽐较⼤⼩；2、对这组数⽤冒泡法进⾏排序，并输出原始数据及排序后数据，两两数据之间⽤空格分隔；3、利⽤DEBUG调试⼯具，⽤D0命令，查看排序前后，内存数据的变化，以及会⽤调试命令查看程序运算中寄存器中的值；4、去掉最⼤和最⼩的两个值，求出其余值的平均值，并输出最⼤值，最⼩值和平均值；5、⽤压栈PUSH和出栈POP指令“先进后出”的特点，设计算法将平7、设计程序要有模块化的思想，⽤⼦程序实现不同的功能；8、所有数据输出前要⽤字符串的输出指令，进⾏输出提⽰（如：zui dazhi shi : 300等），所有数据结果能清晰地显⽰在电脑屏幕上。
程序流程图如下：程序清单：DATAS SEGMENTSHU2 DB 4,?,3 DUP(?)SHU3 DB 4,?,3 DUP(?)SHU4 DB 4,?,3 DUP(?)SHU5 DB 4,?,3 DUP(?)AVER DB 3 DUP(?)SHUCHU DB 'PAI XU HOU DE SHU JU SHUN XU SHI',':','$'MAX DB 'ZUI DA ZHI SHI',':','$'MIN DB 'ZUI XIAO ZHI SHI',':','$'AVERAGE DB 'PING JUN ZHI SHI',':','$'CHUSHU DB 100,10HE DW ?STR1 DB 16 DUP(30H)STR2 DB 'PING JUN ZHI DE ER JIN ZHI CHUAN SHU CHU',':','$' DATAS ENDS CODES SEGMENTASSUME CS:CODES,DS:DATASSTART: MOV AX,DATASMOV DS,AXMOV ES,AXLEA DX,SHURU;显⽰QING SHU RU 5 GE SHU JU：MOV AH,9INT 21HMOV CX,5;输⼊五个数字MOV SI,0INPUT: LEA DX,[SHU1+SI];输⼊要排序的原始数据MOV AH,10INT 21HMOV DL,10;输⼊后换⾏MOV AH,2INT 21HADD SI,5;指针加5，指向下⼀个变量LOOP INPUTCLDMOV CX,4;设定排序外循环次数L1: MOV BP,0PX: PUSH CXMOV CX,3LEA SI,[SHU1+BP+2];逐位⽐较两个数⼤⼩LEA DI,[SHU1+BP+7]REPZ CMPSBJB L2;如果⼩于直接⽐较下⼀个数，否则两个数对换位置MOV CX,3Jh: MOV AL,SHU1[BP+2]XCHG AL,SHU1[BP+7]；将两个字节对换位置，循环3次即完成这两个数的交换XCHG AL,SHU1[BP+2]INC BPLOOP JhSUB BP,3L2: ADD BP,5;指向后⾯两个数字POP CXLOOP PXPOP CX;外循环次数出栈LOOP L1LEA DX,SHUCHU;输出字符串'PAI XU HOU DE SHU JU SHUN XU SHI：' MOV AH,9 INT 21HMOV CX,5MOV SI,2OUTPUT:PUSH CX;计数器⼊栈实现循环嵌套MOV CX,3L3: MOV AL,[SHU1+SI];输出排序后的5个数字MOV DL,ALMOV AH,2INT 21HINC SILOOP L3MOV DL,2CHMOV AH,2INT 21HPOP CX;计数器出栈LOOP OUTPUTMOV DL,10MOV AH,2INT 21HMOV DL,0DHMOV AH,2INT 21HLEA DX,MAX;输出字符串'ZUI DA ZHI SHI：' MOV AH,9INT 21HMOV SI,2L4: MOV DL,[SHU5+SI];输出最⼤值MOV AH,2INT 21HINC SILOOP L4MOV DL,10;换⾏MOV AH,2INT 21HMOV DL,0DHMOV AH,2INT 21HLEA DX,MIN;输出字符串'ZUI XIAO ZHI SHI：' MOV AH,9INT 21HMOV CX,3MOV SI,2L5: MOV DL,[SHU1+SI];输出最⼩值MOV AH,2INT 21HINC SILOOP L5MOV DL,10INT 21HMOV DL,0DHMOV AH,2INT 21HLEA DX,AVERAGE;输出字符串'PING JUN ZHI SHI：'MOV AH,9INT 21HMOV CX,3MOV BX,10;除数10MOV SI,2AD: MOV DX,0MOV AH,0PUSH CXMOV CX,3ZH: MOV AL,[SHU2+SI];将⼗进制数转换为⼆进制数，为后⾯求平均值做准备 SUB AL,30H PUSH AXMOV AX,DXMUL BXPOP AXADD DX,AXINC SILOOP ZH;执⾏3次完成3个⼗进制数的转换ADD SI,2POP CXADD HE,DX;将DX的数放在HE中LOOP AD;循环后得到三个⼗进制数转换为⼆进制数之后的相加和MOV DX,HE;MOV AX,DXXOR DX,DXMOV BX,3DIV BX;除3取平均值,结果将商放在AX中，余数放在DX中MOV BX,AX;给BX赋值平均数，然后将BX中表⽰的⼗进制数转换为对应的字符串DIV CHUSHU;除100取最⾼位ADD AL,30H;转换为ASCII码DIV [CHUSHU+1];除10取⼗位ADD AL,30HADD AH,30H;余数就是个位MOV [AVER+1],ALMOV [AVER+2],AHMOV CX,3MOV SI,0L6: MOV DL,[AVER+SI];输出平均值MOV AH,2INT 21HINC SILOOP L6MOV DL,10MOV AH,2INT 21HMOV DL,0DHMOV AH,2INT 21HLEA DX,STR2 ;输出字符串'PING JUN ZHI DE ER JIN ZHI CHUAN SHU CHU：’ MOV AH,9 INT 21HMOV CX,16MOV SI,0L7: RCL BX,1;将平均数转换为⼆进制串JNC L8ADD [STR1+SI],1；如果不为0就将其加1变成1的ASCII码值L8: MOV DL,[STR1+SI];将⼆进制串逐个输出MOV AH,2INT 21HINC SILOOP L7MOV AH,4CHINT 21H⼼得体会：本次实验编程⽐较复杂，在编这个程序之前⾃⼰先将前⾯三个练习编了⼀下，然后参考了书上的⼀个冒泡排序法的程序，之后才开始动⼿编该程序。
冒泡排序算法实验报告
fori←0ton-2do
forj←0ton-2-ido
ifA[j+1] < A[j]
swap A[j] and A[j+1]
Ⅲ、Java算法代码：
import java.util.*;
public class Maopao {
public static void main(String args[]){
}
for (i=0;i<=n-1;i++){
for(j=0;j<n-1-i;j++){
if(a[j+1]<a[j]){
sm=a[j+1];
a[j+1]=a[j];
a[j]=sm;
}
}
}
System.out.println("冒泡排序输出结果如下：");
for (i=0;i<n;i++){
System.out.println(a[i]);
算法设计与分析基础
实验报告
应用数学学院
二零一六年六月
实验冒泡排序算法
一、实验性质设计
二、实验学时14学时
三、实验目的
1、掌握冒泡排序的方法和原理。
2、掌握java语言实现该算法的一般流程。
四、实验内容
1、数组的输入。
2、输入、输出的异常处理。
3、冒泡排序的算法流程。
4、运行结果的输出。
五、实验报告
Ⅰ、算法原理
比较相邻元素，若他们是逆序的话，就交换它们的位置。重复多次以后，最终，最大的元素就沉到了列表的最后一个位置。第二遍操作将最大的元素沉下去。操作直到n-1遍以后，就排好序了。
微机原理及接口技术实验——冒泡法
微机原理及接口技术实验——冒泡法冒泡排序是一种简单的排序算法，其基本思想是通过重复比较相邻的两个元素，并将较大的元素交换到右侧，从而将最大的元素逐渐"冒泡"到最右侧。
这种算法得名于每次比较时较大元素"冒泡"到右侧的过程。
冒泡排序算法的步骤如下：1.比较相邻的两个元素。
如果第一个元素大于第二个元素，则交换它们的位置。
2.对每一对相邻元素进行同样的操作，从左往右依次进行，这样一轮比较下来，最大的元素将会移动到最右侧。
3.重复上述步骤，每次比较的次数减1，直到所有元素都排好序。
下面是一个使用冒泡排序算法的示例程序：```pythondef bubble_sort(arr):n = len(arr)for i in range(n-1):for j in range(n-i-1):if arr[j] > arr[j+1]:arr[j], arr[j+1] = arr[j+1], arr[j]arr = [64, 34, 25, 12, 22, 11, 90]bubble_sort(arr)print(arr)```在上述示例程序中，我们定义了一个名为`bubble_sort`的函数，该函数接受一个列表作为参数，并对列表进行冒泡排序。
在外层循环中，我们迭代n-1次，其中n为列表的长度。
在内层循环中，我们通过比较相邻元素并交换它们的位置，将较大的元素"冒泡"到右侧。
通过多次迭代，最终实现将所有元素按从小到大的顺序排列。
除了基本的冒泡排序算法，我们还可以对其进行一些改进，以提升排序的效率。
例如，我们可以设置一个标志位`flag`来记录本轮是否进行了元素的交换。
如果本轮没有进行交换，说明列表已经排好序，可以提前结束循环。
这样可以减少无意义的比较操作，提高效率。
冒泡排序算法的时间复杂度为O(n^2)，其中n为列表的长度。
在最坏情况下，即列表本身为逆序，需要进行n*(n-1)/2次比较和交换操作。
微机原理实验报告冒泡法对数据排序
实验内容:用“冒泡“法对一组数300,250,280,240,260,按从小到大的顺序排列。
实验要求:1、编制程序,对这组数进行排序,并输出原数据及排序后数据;2、利用DEBUG调试工具,用D0命令,查瞧排序前后,内存数据的变化;3、去掉最大与最小的两个值,求出其余值的平均值,并输出最大值,最小值与平均值;4、用学过的压栈PUSH与出栈POP指令,将平均值按位逐个输出(即输出263);5.将平均值263转化为二进制串,并将这组二进制串输出。
6、所有数据输出前要用字符串的输出指令,进行输出提示(如:zui da zhi shi : 300等),所有数据结果能清晰地显示在屏幕上。
程序代码:DATA SEGMENT ;定义数据段DT1 DW 300,250,280,240,260DT2 DB 'what five data input is',0DH,0AH,'$'DT3 DB 'what after rank is',0DH,0AH,'$'DT4 DB 'The max is',0DH,0AH,'$'DT5 DB 'The min is',0DH,0AH,'$'DT6 DB 'The average is',0DH,0AH,'$'DT7 DB 'show you the average one by one',0DH,0AH,'$'DT8 DB 'show you the average in binary form',0DH,0AH,'$'DT9 DB 0DH,0AH,'$'DT0 DB 'B',0DH,0AH,'$'N EQU 5DATA ENDSCODE SEGMENTASSUME CS:CODE,DS:DATA ;说明代码段、数据段STAT: MOV AX,DATAMOV DS,AXLEA DX,DT2 ;输出字符串MOV AH,09HINT 21HCALL ZIXU ;调用数据输出过程对数据进行排序:MOV CX,N-1 ;设置N-1轮比较次数MOV DX,1 ;比较轮次技术JM4:PUSH CXMOV CX,NSUB CX,DXLEA SI,DT1JM3:MOV AX,[SI]CMP AX,[SI+2]JLE JM2XCHG AX,[SI+2]XCHG AX,[SI]JM2:ADD SI,2LOOP JM3POP CXINC DXLOOP JM4输出排序后的顺序:LEA DX,DT3MOV AH,09HINT 21HCALL ZIXU输出最大值:LEA DX,DT4MOV AH,09HINT 21HLEA SI,DT1+8 ;排序后最后一个数就就是最大值MOV AX,[SI]CALL ZIXU1输出最小值:LEA DX,DT5MOV AH,09HINT 21HLEA SI,DT1 ;排序后第一个数就就是最小值MOV AX,[SI]CALL ZIXU1输出平均值:LEA DX,DT6MOV AH,09HLEA SI,DT1+2 ;去掉最大最小后的数求与MOV AX,[SI]ADD AX,[SI+2]ADD AX,[SI+4]MOV BX,3MOV DX,0DIV BX ;求其平均值MOV CX,AXCALL ZIXU1 ;调用输出程序输出把平均值分三位输出:LEA DX,DT7MOV AH,09HINT 21HMOV AX,CXMOV BX,100MOV DX,0DIV BXPUSH DXADD AL,30HMOV DL,AL ;输出平均值的第一位MOV AH,2INT 21HLEA DX,DT9 ;换行MOV AH,09HINT 21HPOP DXMOV AX,DXMOV BX,10MOV DX,0DIV BXPUSH DXADD AL,30HMOV DL,AL ;输出平均值的第二位MOV AH,2INT 21HLEA DX,DT9 ;换行MOV AH,09HPOP DXADD DX,30HMOV AH,2 ;输出平均值的第三位I NT 21HLEA DX,DT9MOV AH,09HINT 21H;以二进制位输出平均值LEA DX,DT8MOV AH,09HINT 21HMOV BX,CXMOV CX,16JM5:MOV DX,0SAL BX,1RCL DX,1ADD DX,30HMOV AH,02HINT 21H DEC CXJNZ JM5LEA DX,DT0MOV AH,09HINT 21HMOV AH,4CH ;返回DOSINT 21H;数据序列的输出写成一个过程:ZIXU PROCMOV CX,5LEA SI,DT1JM1:MOV AX,[SI]MOV BX,100MOV DX,0DIV BXPUSH DXADD AL,30HMOV DL,ALINT 21HPOP DXMOV AX,DXMOV BX,10MOV DX,0DIV BXPUSH DXADD AL,30HMOV DL,ALMOV AH,2INT 21HPOP DXADD DX,30HMOV AH,2INT 21HLEA DX,DT9MOV AH,09HINT 21HADD SI,2LOOP JM1RETZIXU ENDP;当个数据输出过程:ZIXU1 PROC ;将数据的输出写成一个过程MOV BX,100MOV DX,0DIV BXPUSH DXADD AL,30HMOV DL,ALMOV AH,2INT 21HPOP DXMOV AX,DXMOV BX,10MOV DX,0DIV BXADD AL,30HMOV DL,ALMOV AH,2INT 21HPOP DXADD DX,30HMOV AH,2INT 21HLEA DX,DT9MOV AH,09HINT 21HRETZIXU1 ENDPCODE ENDSEND STAT调试中出现的一些问题:1.输入时不慎将字母O当数字0输入,结果导致了下面第5行提示的错误。
冒泡排序实验
一、实验目的和要求1.熟悉MCS-51指令系统，掌握程序设计方法2.掌握排序程序算法3.掌握用循环程序实现数据排序基本方法二、实验内容和原理1.实验内容：编写并调试一个通用排列子程序，其功能为将RAM的40H~4FH单元16个字节无符号二进制数按从小到大的顺序排列，将排序后数据存储于RAM的50H~5FH单元中。
2.实验原理：从40H单元的第一个数开始依次和相邻单元的另一个数比较，如果顺序对，则不做任何操作；如果顺序不对，则将这两个数字交换位置。
这样，在完成第1遍n-1次比较后，最大的数到了最后，所以第2遍比较只需要比较n-2次，最多做了n-1遍比较就可完成排序。
在比较中设立一个标志位flag，每次进入外循环时把flag清零，在内循环结束时若flag=1说明排序未完成，进入外循环；若flag=0；说明排序完成，程序结束。
三、主要仪器设备计算机一台。
硬件配置：Pentium II及以上配置，内存为128M、硬盘剩余空间为100MB，配置有串口、并口和USB口。
操作系统：Windows98/2000/XP。
应用软件：KeilC51或其他。
四、操作方法与实验步骤（可选）ORG 0000HMOV R7,#10HMOV R0,#40HMOV R1,#30HSTART: MOV A,R1MOV @R0,AINC R0DEC R1DJNZ R7,STARTMOV R7,#0FHLP0: MOV R0,#40HMOV A,R7MOV R6,ACLR 7FHLP1: MOV A,@R0MOV 20H,@R0INC R0MOV 21H,@R0CLR CSUBB A,21HJC LP2SETB 7FHMOV @R0,20HDEC R0MOV @R0,21HINC R0LP2: DJNZ R6,LP1JNB 7FH,LP3DJNZ R7,LP0LP3: MOV R7,#10HMOV R0,#40HMOV R1,#50HLP4: MOV A,@R0MOV @R1,AINC R0INC R1DJNZ R7,LP4SJMP $END五、实验结果与分析六、讨论、心得。
冒泡排序实习报告
实习报告实习单位：XX科技有限公司实习岗位：软件开发工程师实习时间：2023年2月1日至2023年2月28日一、实习背景及目的作为一名计算机专业的学生，我一直对算法和数据结构有着浓厚的兴趣。
冒泡排序作为一种基础的排序算法，我一直想亲自动手实现并深入了解其原理。
因此，在本次实习中，我选择了XX科技有限公司，希望能在这里的实际工作中锻炼自己的编程能力，并深入理解冒泡排序算法。
二、实习内容及过程在实习期间，我主要参与了公司的一个小型项目的开发，负责实现一个冒泡排序算法。
在实现过程中，我首先了解了冒泡排序的基本原理，即通过不断比较和交换相邻元素的位置，使得待排序序列中的较大元素逐渐移动到序列的尾部，较小元素逐渐移动到序列的首部。
在实际编程过程中，我首先编写了一个简单的冒泡排序函数，然后将其应用到实际项目中。
在实现过程中，我遇到了一些问题，如如何避免重复比较同一对元素、如何判断序列已经排序完成等。
通过查阅资料和与同事的交流，我逐渐解决了这些问题，并成功实现了冒泡排序算法。
三、实习成果及收获通过本次实习，我成功实现了冒泡排序算法，并将其应用到实际项目中。
在实现过程中，我对冒泡排序的原理有了更深入的理解，同时也锻炼了自己的编程能力。
此外，在实习过程中，我还学会了如何查阅资料、如何与同事沟通合作等实际工作技能。
四、实习总结通过本次实习，我对冒泡排序算法有了更深入的了解，同时也锻炼了自己的编程能力。
同时，我也认识到自己在实际工作中的不足，如对某些算法细节的理解不够深入、编程习惯有待改进等。
在今后的学习和工作中，我将继续努力提高自己的能力，为成为一名优秀的软件开发工程师而努力。
（注：本文为示例文章，实际实习报告应根据个人实习经历和收获进行撰写。
）。
冒泡排序实习报告
一、实习背景随着计算机科学技术的不断发展，算法和数据结构在计算机编程中扮演着越来越重要的角色。
冒泡排序作为一种基础的排序算法，对于理解排序算法的原理和实现具有重要意义。
为了提高自己的编程能力和对数据结构的理解，我选择在实习期间进行冒泡排序项目的实践。
二、实习目的1. 理解冒泡排序算法的基本原理和实现过程；2. 掌握冒泡排序算法在不同编程语言中的实现；3. 通过实际操作，提高自己的编程能力和对数据结构的理解；4. 体验编程项目的完整流程，包括需求分析、设计、编码、测试和优化。
三、实习内容1. 冒泡排序算法原理冒泡排序是一种简单的排序算法，其基本思想是通过相邻元素的比较和交换，将较大的元素逐步“冒泡”到数组的末尾，从而实现数组的有序排列。
具体过程如下：（1）从数组的第一个元素开始，比较相邻的两个元素，如果它们的顺序错误（即第一个比第二个大），就交换它们的位置；（2）对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。
这步做完后，最后的元素会是最大的数；（3）针对所有的元素重复以上的步骤，除了最后已经排序好的元素；（4）重复步骤1~3，直到排序完成。
2. 冒泡排序算法实现在实习过程中，我尝试使用Python、Java和C三种编程语言实现冒泡排序算法。
（1）Python实现```pythondef bubble_sort(arr):n = len(arr)for i in range(n):for j in range(0, n-i-1):if arr[j] > arr[j+1]:arr[j], arr[j+1] = arr[j+1], arr[j] return arr```（2）Java实现```javapublic class BubbleSort {public static void bubbleSort(int[] arr) {int n = arr.length;for (int i = 0; i < n-1; i++) {for (int j = 0; j < n-i-1; j++) {if (arr[j] > arr[j+1]) {int temp = arr[j];arr[j] = arr[j+1];arr[j+1] = temp;}}}}}```（3）C实现```cvoid bubbleSort(int arr[], int n) {int i, j, temp;for (i = 0; i < n-1; i++) {for (j = 0; j < n-i-1; j++) {if (arr[j] > arr[j+1]) {temp = arr[j];arr[j] = arr[j+1];arr[j+1] = temp;}}}}```3. 冒泡排序算法测试为了验证冒泡排序算法的正确性，我编写了测试代码，分别对Python、Java和C 三种语言的实现进行测试。
微机原理实验报告冒泡法对数据排序之欧阳引擎创编
实验内容：欧阳引擎（2021.01.01）用“冒泡“法对一组数300，250，280，240，260，按从小到大的顺序排列。
实验要求：1.编制程序，对这组数进行排序，并输出原数据及排序后数据；2.利用DEBUG调试工具，用D0命令，查看排序前后，内存数据的变化；3. 去掉最大和最小的两个值，求出其余值的平均值，并输出最大值，最小值和平均值；4. 用学过的压栈PUSH和出栈POP指令，将平均值按位逐个输出(即输出263)；5．将平均值263转化为二进制串，并将这组二进制串输出。
6.所有数据输出前要用字符串的输出指令，进行输出提示（如：zui da zhi shi : 300等），所有数据结果能清晰地显示在屏幕上。
程序代码：DATA SEGMENT ；定义数据段DT1 DW 300,250,280,240,260DT2 DB 'what five data input is',0DH,0AH,'$'DT3 DB 'what after rank is',0DH,0AH,'$'DT4 DB 'The max is',0DH,0AH,'$'DT5 DB 'The min is',0DH,0AH,'$'DT6 DB 'The average is',0DH,0AH,'$'DT7 DB 'show you the average one by one',0DH,0AH,'$'DT8 DB 'show you the average in binary form',0DH,0AH,'$' DT9 DB 0DH,0AH,'$'DT0 DB 'B',0DH,0AH,'$'N EQU 5DATA ENDSCODE SEGMENTASSUME CS:CODE,DS:DATA；说明代码段、数据段STAT:MOV AX,DATAMOV DS,AXLEA DX,DT2；输出字符串MOV AH,09HINT 21HCALL ZIXU；调用数据输出过程对数据进行排序：MOV CX,N-1；设置N-1轮比较次数MOV DX,1；比较轮次技术JM4:PUSH CXMOV CX,NSUB CX,DXLEA SI,DT1JM3:MOV AX,[SI]CMP AX,[SI+2]JLE JM2XCHG AX,[SI+2]XCHG AX,[SI]JM2:ADD SI,2LOOP JM3POP CXINC DXLOOP JM4输出排序后的顺序：LEA DX,DT3MOV AH,09HINT 21HCALL ZIXU输出最大值：LEA DX,DT4MOV AH,09HINT 21HLEA SI,DT1+8；排序后最后一个数就是最大值MOV AX,[SI]CALL ZIXU1输出最小值：LEA DX,DT5MOV AH,09HINT 21HLEA SI,DT1；排序后第一个数就是最小值MOV AX,[SI]CALL ZIXU1输出平均值：LEA DX,DT6MOV AH,09HINT 21HLEA SI,DT1+2；去掉最大最小后的数求和MOV AX,[SI]ADD AX,[SI+2]ADD AX,[SI+4]MOV BX,3MOV DX,0DIV BX；求其平均值MOV CX,AXCALL ZIXU1；调用输出程序输出把平均值分三位输出：LEA DX,DT7MOV AH,09HINT 21HMOV AX,CXMOV BX,100MOV DX,0DIV BXPUSH DXADD AL,30HMOV DL,AL；输出平均值的第一位MOV AH,2INT 21HLEA DX,DT9；换行MOV AH,09HINT 21HPOP DXMOV AX,DXMOV BX,10MOV DX,0DIV BXPUSH DXADD AL,30HMOV DL,AL；输出平均值的第二位MOV AH,2INT 21HLEA DX,DT9；换行MOV AH,09HINT 21HPOP DXADD DX,30HMOV AH,2;输出平均值的第三位INT 21HLEA DX,DT9MOV AH,09HINT 21H;以二进制位输出平均值LEA DX,DT8MOV AH,09HINT 21HMOV BX,CXMOV CX,16JM5:MOV DX,0SAL BX,1RCL DX,1ADD DX,30HMOV AH,02HINT 21H DEC CXJNZ JM5LEA DX,DT0MOV AH,09HINT 21HMOV AH,4CH;返回DOSINT 21H;数据序列的输出写成一个过程：ZIXU PROCMOV CX,5LEA SI,DT1JM1:MOV AX,[SI]MOV BX,100MOV DX,0DIV BXPUSH DXADD AL,30HMOV DL,ALMOV AH,2INT 21HPOP DXMOV AX,DXMOV BX,10MOV DX,0DIV BXPUSH DXADD AL,30HMOV DL,ALMOV AH,2INT 21HPOP DXADD DX,30HMOV AH,2INT 21HLEA DX,DT9MOV AH,09HINT 21HADD SI,2LOOP JM1RETZIXU ENDP;当个数据输出过程：ZIXU1 PROC；将数据的输出写成一个过程MOV BX,100MOV DX,0DIV BXPUSH DXADD AL,30HMOV DL,ALMOV AH,2INT 21HPOP DXMOV AX,DXMOV BX,10MOV DX,0DIV BXPUSH DXADD AL,30HMOV DL,ALMOV AH,2INT 21HPOP DXADD DX,30HMOV AH,2INT 21HLEA DX,DT9MOV AH,09HINT 21HRETZIXU1 ENDPCODE ENDSEND STAT调试中出现的一些问题：1.输入时不慎将字母O当数字0输入，结果导致了下面第5行提示的错误。
实验一 冒泡排序原理验证(1)
南京邮电大学通达学院实验报告实验名称: 冒泡排序原理验证课程名称：微型计算机原理与接口技术姓名班级学号: ________________________________________________实验时间：_____________________冒泡排序一、实验原理：经典排序算法- 冒泡排序Bubble sort原理是临近的数字两两进行比较,按照从小到大或者从大到小的顺序进行交换, 这样一趟过去后,最大或最小的数字被交换到了最后一位,然后再从头开始进行两两比较交换,直到倒数第二位时结束,其余类似看例子例子为从小到大排序,原始待排序数组| 6 | 2 | 4 | 1 | 5 | 9 |第一趟排序(外循环)第一次两两比较6 > 2交换(内循环)交换前状态| 6 | 2 | 4 | 1 | 5 | 9 |交换后状态| 2 | 6 | 4 | 1 | 5 | 9 |第二次两两比较,6 > 4交换交换前状态| 2 | 6 | 4 | 1 | 5 | 9 |交换后状态| 2 | 4 | 6 | 1 | 5 | 9 |第三次两两比较,6 > 1交换交换前状态| 2 | 4 | 6 | 1 | 5 | 9 |交换后状态| 2 | 4 | 1 | 6 | 5 | 9 |第四次两两比较,6 > 5交换交换前状态| 2 | 4 | 1 | 6 | 5 | 9 |交换后状态| 2 | 4 | 1 | 5 | 6 | 9 |第五次两两比较,6 < 9不交换交换前状态| 2 | 4 | 1 | 5 | 6 | 9 |交换后状态| 2 | 4 | 1 | 5 | 6 | 9 |第二趟排序(外循环)第一次两两比较2 < 4不交换交换前状态| 2 | 4 | 1 | 5 | 6 | 9 |交换后状态| 2 | 4 | 1 | 5 | 6 | 9 |第二次两两比较,4 > 1交换交换前状态| 2 | 4 | 1 | 5 | 6 | 9 | 交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |第三次两两比较,4 < 5不交换交换前状态| 2 | 1 | 4 | 5 | 6 | 9 | 交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |第四次两两比较,5 < 6不交换交换前状态| 2 | 1 | 4 | 5 | 6 | 9 |交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |第三趟排序(外循环)第一次两两比较2 > 1交换交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |第二次两两比较,2 < 4不交换交换后状态| 1 | 2 | 4 | 5 | 6 | 9 | 交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |第三次两两比较,4 < 5不交换交换后状态| 1 | 2 | 4 | 5 | 6 | 9 | 交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |第四趟排序(外循环)无交换第五趟排序(外循环)无交换排序完毕,输出最终结果1 2 4 5 6 9二、实验代码#include<stdio.h>void main(){int a[7];int i,j,k;printf("输入7个数字\n");for(i=0;i<7;i++)scanf("%d",&a[i]);for(i=0;i<6;i++){for(j=0;j<6-i;j++)if(a[j]>a[j+1]){k=a[j];a[j]=a[j+1];a[j+1]=k;}printf("hen bubble sorting process:\n");for(k=0;k<7;k++)printf("%d ",a[k]);printf("\n");}printf("冒泡排序后:\n");for(i=0;i<7;i++)printf("%d",a[i]);printf("\n");}三、实验数据（给出实验结果）49 38 65 97 76 13 27四、实验总结（问题、解决方法、心得体会等）通过此次微型计算机原理与接口技术的冒泡排序的上机实验，巩固了冒泡排序的有关知识技能，增强了实践本领；而使用改进过的冒泡排序算法更能够反映其排序技巧的优先性，便利性；所使用的C语言代码篇幅较短，便于理解；总而言之，这一次的收获颇多，带来了更多学习的兴趣和动力；。
冒泡排序和快速排序实验报告
实验报告
实验名称实验三冒泡排序和快速排序
班级
学号
姓名
成绩
move++;
}
while(x[i]<=temp && j>i)
{
i++;
}
if(j>i)
{
x[j--]=x[i];
}
}
x[i]=temp;
kuaisu(x,left,i-1);
kuaisu(x,i+1,right);
}
【实验过程】（实验步骤、数据、分析）
实验步骤：
1）随机产生20位整数
2）输入序列，编写程序，按下列排序方法将序列从小到大排序并输出。
1.冒泡排序
2.快速排序
3）纪录每种方法比较次数和移动次数
实验结果分析：
根据冒泡法和快速法输出地移动次数和比较次数可以看出，快速法的移动次数和比较次数要比冒泡法少许多。
因此，快速法是一种比冒泡法更好的排序法。
【结论】（结果）
冒泡法排序的结果的截图：
快速法排序的结果的截图：
【小结】
由于大一下学期学习C语言时，冒泡法和快速法都是重点内容，这次实验进行的比较顺利，没有遇到太多困难。
只是刚开始不知道怎样输出比较次数和移动次数，后来定义了两个全程变量，解决了这个问题。
另外，虽然实验说明上有怎样输出时间的语句，但是尝试了许多次还是没有成功。
先是提示变量类型错误，然后提示没有GetTickCount()函数。
最后只好没有输出时间，也没有比较两种方法的运行时间
指导教师评语及成绩：
成绩：指导教师签名：
批阅日期：。
冒泡排序的实验报告
冒泡排序的实验报告冒泡排序的实验报告一、引言冒泡排序是一种简单但效率较低的排序算法。
它的基本思想是通过相邻元素的比较和交换来将最大（或最小）的元素逐渐“冒泡”到数列的末尾。
本实验旨在通过编写冒泡排序的程序，验证其排序效果和时间复杂度。
二、实验过程1. 程序设计根据冒泡排序的思想，我们编写了一个C++程序来实现该算法。
程序接受用户输入的待排序数组，并使用冒泡排序算法对其进行排序。
具体实现过程如下：```cpp#include <iostream>using namespace std;void bubbleSort(int arr[], int n) {for (int i = 0; i < n - 1; i++) {for (int j = 0; j < n - i - 1; j++) {if (arr[j] > arr[j + 1]) {swap(arr[j], arr[j + 1]);}}}}int main() {int n;cout << "请输入待排序数组的长度：";cin >> n;int arr[n];cout << "请输入待排序的数组元素：";for (int i = 0; i < n; i++) {cin >> arr[i];}bubbleSort(arr, n);cout << "排序结果为：";for (int i = 0; i < n; i++) {cout << arr[i] << " ";}cout << endl;return 0;}```2. 实验步骤（1）编译并运行程序；（2）根据提示输入待排序数组的长度和元素；（3）程序将输出排序结果。
三、实验结果我们分别对不同规模的数组进行了排序实验，并记录了排序所需的时间。
冒泡排序实验报告
冒泡排序实验报告冒泡排序实验报告一、引言冒泡排序是一种简单但效率较低的排序算法，它通过多次比较和交换相邻元素的方式，将待排序的元素逐渐“冒泡”到正确的位置。
本实验旨在通过实际操作验证冒泡排序算法的原理和性能。
二、实验目的1. 理解冒泡排序算法的基本原理；2. 掌握冒泡排序算法的实现方法；3. 分析冒泡排序算法的时间复杂度。
三、实验步骤1. 准备实验材料：一组待排序的整数序列；2. 实现冒泡排序算法：a. 从序列的第一个元素开始，依次比较相邻的两个元素；b. 如果前一个元素大于后一个元素，则交换它们的位置；c. 继续比较下一对相邻元素，直到最后一个元素；d. 重复上述步骤，直到所有元素都排序完成。
3. 执行冒泡排序算法，记录每一次比较和交换的过程；4. 分析实验结果，计算比较和交换次数；5. 绘制比较和交换次数随元素数量增加的曲线图。
四、实验结果与分析在本次实验中，我们选取了一个包含10个整数的序列进行冒泡排序。
经过实际操作，我们记录下了每一次比较和交换的过程，并进行了统计和分析。
首先，我们执行第一次冒泡排序，结果如下：第一次比较：5与3比较，交换位置；第二次比较：5与7比较，不交换位置；...第九次比较：7与6比较，交换位置；第十次比较：7与9比较，不交换位置。
通过第一次冒泡排序，我们发现有3次比较导致了位置的交换。
接下来，我们继续执行冒泡排序，直到所有元素都排序完成。
经过多次比较和交换，最终得到了一个有序的序列。
通过统计和分析实验结果，我们可以得出以下结论：1. 冒泡排序的比较次数与序列的初始顺序有关，最好情况下为n-1次，最坏情况下为n*(n-1)/2次；2. 冒泡排序的交换次数与序列的初始顺序和大小有关，最好情况下为0次，最坏情况下为n*(n-1)/2次；3. 冒泡排序的时间复杂度为O(n^2)，属于一种较为低效的排序算法。
五、实验总结通过本次实验，我们深入了解了冒泡排序算法的原理和性能。
微机实验排序实验报告
一、实验目的1. 熟悉排序算法的基本原理和实现方法；2. 掌握冒泡排序、选择排序、插入排序等常用排序算法；3. 通过实验，加深对排序算法的理解，提高编程能力。
二、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发环境：Visual Studio 2019三、实验内容1. 冒泡排序2. 选择排序3. 插入排序四、实验原理1. 冒泡排序：冒泡排序是一种简单的排序算法，它重复地遍历待排序的序列，比较相邻的元素，如果它们的顺序错误就把它们交换过来。
遍历序列的工作是重复地进行，直到没有再需要交换，也就是说该序列已经排序完成。
2. 选择排序：选择排序是一种简单直观的排序算法。
它的工作原理是：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
以此类推，直到所有元素均排序完毕。
3. 插入排序：插入排序是一种简单直观的排序算法。
它的工作原理是：将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录数增加1的有序表。
对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
五、实验步骤1. 冒泡排序（1）定义一个函数，用于实现冒泡排序算法；（2）在主函数中，定义一个整数数组，并对其进行初始化；（3）调用冒泡排序函数，对数组进行排序；（4）打印排序后的数组。
2. 选择排序（1）定义一个函数，用于实现选择排序算法；（2）在主函数中，定义一个整数数组，并对其进行初始化；（3）调用选择排序函数，对数组进行排序；（4）打印排序后的数组。
3. 插入排序（1）定义一个函数，用于实现插入排序算法；（2）在主函数中，定义一个整数数组，并对其进行初始化；（3）调用插入排序函数，对数组进行排序；（4）打印排序后的数组。
六、实验结果与分析1. 冒泡排序实验结果：```原始数组：5 3 8 6 2排序后数组：2 3 5 6 8```分析：冒泡排序在最好情况下（已排序）的时间复杂度为O(n)，在平均和最坏情况下（逆序）的时间复杂度为O(n^2)。
实验06 冒泡排序
实验六循环结构（冒泡排序）（四课时）一、实验目的1、掌握循环结构语句的特点。
2、了解内存的块操作方法。
3、掌握冒泡排序的方法4、掌握EXE模板的使用二、实验内容对指定内存起址和长度的数据块，要求将其按照从小到大（从大到小）的顺序排序三、EXE模板的使用1、当程序中出现分段时，需要使用EXE模板程序中的分段，需要段定义语句如数据段定义D SEGMENTV AR DB -1，-10，-100，27HN DB N-V ARD ENDS此处定义了一个数据段，段名称为D，在数据段中，一次存放两个区域的数据一个是字节数组VAR ，一个是字变量N2、EXE模板的使用（1）单击菜单[文件][新建]，出现如下图所示的对话框，选择EXE模板，单击确定（2）在出现的编程界面中，默认生成了三个段，如下图所示其中，DSEG为数据段，SSEG为堆栈段，CSEG为代码段数据段和堆栈段中没有任何内容堆栈段暂时不使用，代码段需要编写自己的程序所以，默认的堆栈段定义语句可以删除。
代码段中默认的内容也要删除（以后的实验，同样的操作）删除之后如下图所示。
可以在下图中的DSEG中定义数据，在CSEG中编写代码。
也可以将默认生成的代码全部删除，自己编写代码。
四、实验程序清单1.、采用EXE模板，单步调试下列程序，观察内存变化，并截图（源程序见教材P151，有改动）DSEG SEGMENT 'DATA'VAR DB 11,-8,-25,76,9,52N DW N-VARDSEG ENDSCSEG SEGMENT 'CODE'ASSUME CS:CSEG,DS:DSEGSTART: MOV AX,DSEGMOV DS,AXMOV CX,NDEC CXMOV DX,1AG: CALL SUBPINC DXLOOP AGMOV AH,4CHINT 21HSUBP PROCPUSH CXMOV CX,NSUB CX,DXMOV SI,0RECMP: MOV AL,VAR[SI]CMP AL,VAR[SI+1]JLE NOCHXCHG AL,VAR[SI+1]XCHG AL,VAR[SI]NOCH: INC SILOOP RECMPPOP CXRETSUBP ENDPCSEG ENDSEND START ; set entry point.单击[模拟]之后，出现如图所示的界面，观察可知，默认CS=0B68H，DS=0B57H。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
一、实验目的(1)学习汇编语言循环结构语句的特点,重点掌握冒泡排序的方法。
(2)理解并掌握各种指令的功能,编写完整的汇编源程序。
(3)进一步熟悉D ＥB ＵＧ的调试命令,运用DE ＢＵG 进行调试汇编语言程序。
二、实验内容及要求(1)实验内容:从键盘输入五个有符号数,用冒泡排序法将其按从小到大的顺序排序。
(2)实验要求:①编制程序,对这组数进行排序并输出原数据及排序后的数据;②利用D ＥＢU Ｇ调试工具,用D0命令,查瞧排序前后内存数据的变化;③去掉最大值与最小值,求出其余值的平均值,输出最大值、最小值与平均值;④用压栈P ＵＳＨ与出栈P ＯP 指令,将平均值按位逐个输出;⑤将平均值转化为二进制串,并将这组二进制串输出;⑥所有数据输出前要用字符串的输出指令进行输出提示,所有数据结果能清晰显示。
三、程序流程图ﻩ(1)主程序:MAIN否(2)冒泡排序子程序: ＳORT否四、程序清单ＮA ＭＥ BUBBLE_ＳＯRTDAT Ａ ＳＥG ＭＥＮTARRAY D Ｗ 5 DU Ｐ(?) ;输入数据的存储单元COU ＮT DW 5TWO DW 2ＦLAG1 ＤＷ 0 ;判断符号标志FL ＡG2 DB 0 ;判断首位就是否为零的标志ＦＡULT ＤＷ -1 ;判断出错标志CR ＤB 0DH,0ＡＨ,'$'ＳT Ｒ1 ＤB ＇P ｌｅa ｓｅ i ｎp ｕｔ five numbers sep ｅｒated with space ａnd f ｉnisheｄ with E ｎter:','$'ST Ｒ2 DB 'The orig ｉn ａl numbers:','＄'ＳTR3 ＤB 'T ｈe sort ｅd num ｂｅrs:','$'ＳTR4 D Ｂ 'The Mi ｎ:','$'ＳTR ５ ＤB ＇The Ma ｘ:',＇$'ＳＴＲ6 D Ｂ 'Ｔhe Av ｅr ａg ｅ:','$'STR7 DB 'The ｂinary ｓyst ｅm of the av ｅｒage :','$＇ST Ｒ８ DB 'Ｉnp ｕt err ｏr!Ple ａse input again!''$'D ＡTA ENDSCODE ＳEGMEN ＴＭAIN PRO Ｃ FARＡSSUME C Ｓ:ＣODE,ＤS:DATA,E Ｓ:DATAS ＴAR Ｔ: PUSH DSAND AX,0ＰUSH AXMOV A Ｘ,DATAＭOV DS,AXL ＥＡ DX,ST Ｒ1M ＯＶ A Ｈ,09Ｈ ;9号DO Ｓ功能调用,提示输入数据IN Ｔ 21HＣALL C ＲL Ｆ ;回车换行RE ＩＮ: ＣALL ＩＮＰUT ;调用IN ＰＵＴ子程序,输入原始数据C ＭP AX,FAULT ;判断就是否出错,JE RE ＩN ;出错则重新输入LEA DX,STR2M ＯV AH,０9H ;9号DO Ｓ功能调用,提示输出原始数据I ＮＴ ２1HＣALL OUTPUT ;调用OU ＴPUT 子程序,输出原始数据ＣA ＬＬ SORT ;调用SO ＲT 子程序,进行冒泡排序ＬEA DX,STR３MＯVＡＨ,09H;9号DOS功能调用,提示输出排序后的数据IＮT ２１HCAＬLＯUＴPUT;调用OＵTPUＴ子程序,输出排序后的数据ＡＮD SI,0AND BX,0MOＶＢX,AＲＲAY[SI];将最小值存入BＸLEA DＸ,STR4MＯV AH,09H;9号DOS功能调用,提示输出数据的最小值ＩNT 21ＨCAＬL ONＥ;调用ONE子程序,输出最小值CALL CRLFＬEA DX,STR5MOV AH,09Ｈ;9号ＤOＳ功能调用,提示输出排序后的最大值INT 21ＨMＯV ＢＸ,AＲRAY[SI＋8] ;将最大值存入BＸCAＬL OＮE ;调用OＮE子程序,输出最大值CAＬL ＣRLＦLＥAＤX,STR6MOV ＡＨ,0９Ｈ;9号DOS功能调用,提示输出平均值ＩNT ２１ＨＡＮD ＤX,０MOV AX,ＡRRＡY［SI＋２] ;将去掉最大最小值的其余各数之与存入ＡＸADＤAX,ＡRRAＹ［ＳI+4]AＤC AX,ARRAＹ[SI+６]MOV CX,CＯＵＮT;计数器CX=５DＥC ＣX ;CＸ←CＸ－1DEC CＸＤIV CX ;字除法,余数存入AXMOV ＢＸ,AX;将余下各数的平均值存入BＸCALL ONE ;调用ＯNE子程序,输出去掉最大最小值的其余数平均值CＡＬL CRLFLEA DX,STR6MOV AH,０９H;9号DOS功能调用,提示输出平均值的二进制串MOＶCX,16 ;16位二进制串,计数器初始值为16LL1: AＮD DX,0DIV ＴWOＰUSH DＸＬOOP ＬL１MOV CX,16LＬ2: POP DＸADＤDL,30H ;将DＬ中的数进行ASCIＩ码转换MOＶAＨ,2 ;2号DOS功能调用,输出字符“0”或“1”IＮT ２1ＨLOＯP LＬ2MOＶＡH,４CHINＴ21H ;4C号功能调用,返回DOＳMAIＮEＮＤP;----－－-－-－------－－--------－-－--－-－－-－--------－----－-－－－--------－---－－-－---－--－---－-----－------－-----－---－-－--－--－－--－－-－--------子程序:CRLＦ功能:回车与换行;-－－--－-----－--－-－－---－-----－------－-－---－－----------－----－－-----－----------－－------－-----－-------－---－---－------－-----－－--------ＣRＬF PＲOCＬEA DX,CRMOＶAH,0９HＩＮＴ２1HＲETCRＬＦENＤP;---------－--－------------－-----－--－----－--－------－--－----－－-－------------－－-－----－－-－---－----－--－--－-－--－－－－－------－------------子程序:ＩＮPUT功能: 输入一组数据;----------－-－--－---－－－------－-－-----－--－-----－--－--－－----------－--------－－-－---－－-－-－-－－－--－-－-----－--------－-－------－----－-----INPＵT PROCMOV CX,COUNT ;计数器CX=5AND SＩ,０ＮEXT1: CＡLL ＤＴＢ;调用ＤTB子程序,将输入转换为二进制数DEC CX ;CX←CX-１ＣMP DL,20H ;判断输入字符就是否为空格符JE STOＣＭP DL,0DＨ;判断输入字符就是否为换行符JE EXＩT２CＡLL CRＬFERROR: LEＡDＸ,SＴＲ8MOＶAH,０9H ;9号DＯS功能调用,提示输入不合法INT２1HCALL CＲLFＭOV AX,ＦAUＬＴ;以AX中的值作为出错标志JMP EXIT3STO: MＯV AＲRＡY［SI］,BＸ;就是空格符,将BX中的二进制数存入存储单元AＤD SI,２JMＰNEXT1EXIT２: ＭOＶＡRRAＹ[SＩ],BＸ;就是换行符,将BＸ中的二进制数存入存储单元CALＬCRLFＥXIT3: ＲETINＰＵT EＮDP;----－----－-------－-－－-------－--－---－-－---－--－--－-－-－-－-----－---－------－--------－---－----－-----------－----－--－----－------－－－-－---子程序:ＤＴB功能:将键盘输入的十进制数转换为二进制数形式存入ＢＸ;－－--－---－-－－-----------－－-----------－-－-－-－-----－－--－----－-－-－－-－－-－----－----－-------－－--－－----------－---－--－--－--------------－-ＤTBＰROＣAND BＸ,0ＡND FＬＡG1,０;符号标志,0为正,1为负CＨAR: ＭＯＶＡH,01Ｈ;1号DＯS功能调用,输入一个字符,存入ＡL ＩNT21HＭOV ＤL,AＬCMP AＬ,２DH;判断输入字符就是否为负号"-"JNＺNEXＴ2MOV FLＡＧ１,1 ;就是负数,将符号标志FＬAG１置１JMP CHＡRNEXT2: ＳUB AL,３0H ;判断输入字符就是否在0-9之间JL NEXT3CＭP AL,09HJG NＥXT３CBWXCＨG AX,BX ;输入字符在0－9之间,将BX中的数乘以10 MOV CX,1０MUL CＸXＣHＧＡX,BXADＤBX,AX;将BＸ中的数与新输入的数相加ＪMP ＣHARNEXＴ3: CMP FLAG1,１;根据符号标志判断输入就是否为负JNZ EXＩＴ１NEＧBＸ;对ＢＸ中的数求补EXIT1: RETDTB ENDP;－--------－--------－-------－－-－-----－-－----－----－-----------－-----－----－----------－---－-----－-－--------－-－-----－--------－--－--－--子程序:OＵＴＰUT功能: 输出一组数据;－-－－－----------－---－-－------－－--－---－---------－-－－-－-－----－-－----－--－------－--－---－--－-－---－－－－－------－-----------－-－－----－－----ＯUTPUT PＲＯCＣALＬCRLFMOV ＤI,CＯUNT ;计数器ＤI=5AND SＩ,0ＧO1: ＭOV BＸ,ARＲAＹ［SＩ] ;将存储单元的第一组数据存入ＢＸTESＴBＸ,800０H;判断正负ＪZ GO2MOＶDL,2ＤHＭOＶAH,02Ｈ;２号DOＳ功能调用,输出负号"-"INT 2１HNＥGＢXGO2: CALL ONＥ;调用ONE子程序,将BX中二进制数转换为十进制数输出ＭOVＤL,２0HMOV AH,02Ｈ;２号DOＳ功能调用,输出空格符ＩＮT ２１HADＤＳI,２;指针指向下一数据DＥC DＩ;DI←ＤI-１JNZ GＯ１;计数器DＩ不为零,继续循环ＣＡLL CRLFＲETＯＵTPUＴＥＮDＰ;－-------－－-－－－-－--------－--------－-－---－---－---－--－---－--－-－－--------－-----－--－---------－－--－---－---－－－-－--－-------－----－－---－-－子程序:ONE功能:将BX中的的二进制数转换为十进制数,由高到低各位依次输出;－-----－－－--－-－------－---－－－--－--－-－---－-－-－--－---－－-----－-----－－－－------－-－－---－--－------－－--－－---－------－-----－-－------－－-----－ONE PROCPUＳH BＸPUSＨＣＸPUSH SＩPUＳH ＤIMOV CX,10０00 ;除数存入CXＣＡLL BTDMOＶCX,１0００CALL BTDＭOV ＣX,１00CALL BTＤMＯＶCＸ,10CAＬL BTＤＭＯV CＸ,１CALLＢTDAＤDＤＬ,FLAG2CMＰDL,30H ;与"0"的AＳＣＩI码比较,判断该数就是否为"０＂JＮE QUIT3MOＶAH,02H ;2号ＤOS功能调用,输出"0"IＮT 21HＱＵIT３: POP ＤIＰOＰＳIＰＯP ＣXＰＯＰBXＡND FLAＧ2,0 ;将首位标志FLAG2重新置0RETOＮE ENDP;--－－-－---------－-----－----－--－－－---－------------------------－-－--－－---------------------－－--－－---－-－---－---－-－---－------－-－－---－子程序:ＢTD功能: 将BX中的二进制数转换为一个十进制数输出;----－-－-－－--－-------－------－－－--－---－－------－----－-－--------－-－－-------－---－----－-------－-－---－---－－-----－------－------－－---－---BＴD PＲOCMOＶAＸ,ＢXAND DX,０DIV CＸ;字除法,商值存入AX,余数存入DX ＭＯV BX,DX ;余数存入BXＭOV DL,AＬADD DＬ,3０H ;对DL中的数进行ASCＩI码转换ＣMP FＬAＧ2,0;判断就是否为首位数据ＪNE QUIT1CＭＰDＬ,3０Ｈ;就是首位则判断就是否为"0"JE ＱUIT２;就是＂０"则不输出MOV FLAG２,１;不就是"0"将首位标志置1QUＩT1: MOＶＡＨ,0２H ;２号DOS功能调用,输出一位十进制数INT 21HＱUIＴ2: RＥTＢTD ENDP;--－－－----－－－－－------－------－－---－－-----－-----------－－----－－---－－---－－－-－---－－-－--------------－---－--－－--－－------－--－-－-－-－------子程序:ＳORT功能: 冒泡排序;---－----－－-----－--－---------------－--－-－－-－－-－-----－------------－-－－--－---------－-－-－--－---－--------－--－------－-－－----－--－-－-－--SORＴPRＯCCLDＭＯV ＣX,COUNT;初始化计数器CＸDEC CX ;ＣＸ=4LOO1: MOV DI,CＸ;CX中的数存入DＩANＤSI,0ＬOO2:MＯV AX,ARRAY［SI]CMP AX,AＲＲＡY[SＩ+2］;相邻两数进行比较JＬLＯO3XCＨG AX,ＡRRAY[SＩ+2] ;前一数较大则进行数据交换MOV ARＲＡＹ[SI],ＡXＬOO3: ADD SI,２;前一数较小,则进行下一组比较LOＯP ＬOO２;ＣX=0,停止内循环MOV CX,DI ;还原计数器ＣX的值LOOP LOO１;ＣX＝0,停止外循环RＥTSORT ENDP;--－--－－-－-----－-－--------－－－－--－－---－----－-------－－－－--－---－－-－-------－-－------------------－------------－－---－-－--－－------－－-－－-ＣODEＥNDSEND STARＴ五、运行结果(1)对３00,２50,280,240,２60五个数进行冒泡排序,运行结果如下:(２)对-１,2,5４,-38,４３五个数进行冒泡排序,运行结果如下(1)当输入不合法时,出现错误提示:(4)当输入数据不足5个时程序自动补0:六、心得体会在本次汇编语言程序设计实验中,我们学习了汇编语言的循环结构,并对冒泡排序法进行了汇编程序设计,我首先编写了对给定数据进行冒泡排序的算法设计,这有助于我熟悉冒泡排序的逻辑结构,理清设计思路。