微机原理实验报告-冒泡排序

合集下载

冒泡排序(实验报告)

一、实验目的和要求理解和掌握冒泡排序技术，使用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. 操作系统：Windows 102. 编程语言：Python3.73. 开发环境：PyCharm三、实验内容1. 冒泡排序算法的实现2. 冒泡排序算法的性能测试3. 结果分析四、实验步骤1. 实现冒泡排序算法```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. 生成测试数据```pythonimport randomdef generate_data(n):return [random.randint(0, 10000) for _ in range(n)]```3. 测试冒泡排序算法性能```pythondef test_bubble_sort():data_sizes = [100, 1000, 10000, 100000]for size in data_sizes:data = generate_data(size)sorted_data = bubble_sort(data.copy())assert sorted_data == sorted(data), "排序结果错误"print(f"数据规模：{size}, 排序耗时：{time.time() - start_time:.4f}秒")start_time = time.time()test_bubble_sort()print(f"实验总耗时：{time.time() - start_time:.4f}秒")```五、结果分析1. 冒泡排序算法的时间复杂度分析冒泡排序算法的时间复杂度主要取决于两层循环的执行次数。

微机原理实验报告-冒泡排序

一、实验目的（1）学习汇编语言循环结构语句的特点，重点掌握冒泡排序的方法。

（2）理解并掌握各种指令的功能，编写完整的汇编源程序。

（3）进一步熟悉DEBUG的调试命令，运用DEBUG进行调试汇编语言程序。

二、实验内容及要求（1）实验内容：从键盘输入五个有符号数，用冒泡排序法将其按从小到大的顺序排序。

（2）实验要求：①编制程序，对这组数进行排序并输出原数据及排序后的数据；②利用DEBUG调试工具，用D0命令，查看排序前后内存数据的变化；③去掉最大值和最小值，求出其余值的平均值，输出最大值、最小值和平均值；④用压栈PUSH和出栈POP指令，将平均值按位逐个输出；⑤将平均值转化为二进制串，并将这组二进制串输出；⑥所有数据输出前要用字符串的输出指令进行输出提示，所有数据结果能清晰显示。

三、程序流程图（1）主程序:MAIN是（2）冒泡排序子程序: SORT否是是四、程序清单NAME BUBBLE_SORTDATA SEGMENTARRAY DW 5 DUP() ;输入数据的存储单元COUNT DW 5TWO DW 2FLAG1 DW 0 ;判断符号标志FLAG2 DB 0 ;判断首位是否为零的标志FAULT DW -1 ;判断出错标志CR DB 0DH,0AH,'$'STR1 DB 'Please input five numbers seperated with space and finished with Enter:','$'STR2 DB 'The original numbers:','$'STR3 DB 'The sorted numbers:','$'STR4 DB 'The Min:','$'STR5 DB 'The Max:','$'STR6 DB 'The Average:','$'STR7 DB 'The binary system of the average :','$'STR8 DB 'Input error!Please input again!''$'DATA ENDSCODE SEGMENTMAIN PROC FARASSUME CS:CODE,DS:DATA,ES:DATASTART: PUSH DSAND AX,0PUSH AXMOV AX,DATAMOV DS,AXLEA DX,STR1MOV AH,09H ;9号DOS功能调用，提示输入数据INT 21HCALL CRLF ;回车换行REIN: CALL INPUT ;调用INPUT子程序，输入原始数据CMP AX,FAULT ;判断是否出错，JE REIN ;出错则重新输入LEA DX,STR2MOV AH,09H ;9号DOS功能调用，提示输出原始数据INT 21HCALL OUTPUT ;调用OUTPUT子程序，输出原始数据CALL SORT ;调用SORT子程序，进行冒泡排序LEA DX,STR3MOV AH,09H ;9号DOS功能调用，提示输出排序后的数据 INT 21HCALL OUTPUT ;调用OUTPUT子程序，输出排序后的数据AND SI,0AND BX,0MOV BX,ARRAY[SI] ;将最小值存入BXLEA DX,STR4MOV AH,09H ;9号DOS功能调用，提示输出数据的最小值INT 21HCALL ONE ;调用ONE子程序，输出最小值CALL CRLFLEA DX,STR5MOV AH,09H ;9号DOS功能调用，提示输出排序后的最大值INT 21HMOV BX,ARRAY[SI+8] ;将最大值存入BXCALL ONE ;调用ONE子程序，输出最大值CALL CRLFLEA DX,STR6MOV AH,09H ;9号DOS功能调用，提示输出平均值INT 21HAND DX,0MOV AX,ARRAY[SI+2] ;将去掉最大最小值的其余各数之和存入AXADD AX,ARRAY[SI+4]ADC AX,ARRAY[SI+6]MOV CX,COUNT ;计数器CX=5DEC CX ;CX←CX-1DEC CXDIV CX ;字除法，余数存入AXMOV BX,AX ;将余下各数的平均值存入BXCALL ONE ;调用ONE子程序，输出去掉最大最小值的其余数平均值 CALL CRLFLEA DX,STR6MOV AH,09H ;9号DOS功能调用，提示输出平均值的二进制串MOV CX,16 ;16位二进制串，计数器初始值为16LL1: AND DX,0DIV TWOPUSH DXLOOP LL1MOV CX,16LL2: POP DXADD DL,30H ;将DL中的数进行ASCII码转换MOV AH,2 ;2号DOS功能调用，输出字符“0”或“1”INT 21HLOOP LL2MOV AH,4CHINT 21H ;4C号功能调用，返回DOSMAIN ENDP;--------------------------------------------------------------------------------------------------------------------------------子程序：CRLF功能：回车和换行;--------------------------------------------------------------------------------------------------------------------------------CRLF PROCLEA DX,CRMOV AH,09HINT 21HRETCRLF ENDP;--------------------------------------------------------------------------------------------------------------------------------子程序：INPUT功能：输入一组数据;--------------------------------------------------------------------------------------------------------------------------------INPUT PROCMOV CX,COUNT ;计数器CX=5AND SI,0NEXT1: CALL DTB ;调用DTB子程序，将输入转换为二进制数DEC CX ;CX←CX-1CMP DL,20H ;判断输入字符是否为空格符JE STOCMP DL,0DH ;判断输入字符是否为换行符JE EXIT2CALL CRLFERROR: LEA DX,STR8MOV AH,09H ;9号DOS功能调用，提示输入不合法INT 21HCALL CRLFMOV AX,FAULT ;以AX中的值作为出错标志JMP EXIT3STO: MOV ARRAY[SI],BX ;是空格符，将BX中的二进制数存入存储单元ADD SI,2JMP NEXT1EXIT2: MOV ARRAY[SI],BX ;是换行符，将BX中的二进制数存入存储单元CALL CRLFEXIT3: RETINPUT ENDP;--------------------------------------------------------------------------------------------------------------------------------子程序：DTB功能：将键盘输入的十进制数转换为二进制数形式存入BX;--------------------------------------------------------------------------------------------------------------------------------DTB PROCAND BX,0AND FLAG1,0 ;符号标志，0为正，1为负CHAR: MOV AH,01H ;1号DOS功能调用，输入一个字符，存入ALINT 21HMOV DL,ALCMP AL,2DH ;判断输入字符是否为负号"-"JNZ NEXT2MOV FLAG1,1 ;是负数，将符号标志FLAG1置1JMP CHARNEXT2: SUB AL,30H ;判断输入字符是否在0-9之间JL NEXT3CMP AL,09HJG NEXT3CBWXCHG AX,BX ;输入字符在0-9之间，将BX中的数乘以10MOV CX,10MUL CXXCHG AX,BXADD BX,AX ;将BX中的数与新输入的数相加JMP CHARNEXT3: CMP FLAG1,1 ;根据符号标志判断输入是否为负JNZ EXIT1NEG BX ;对BX中的数求补EXIT1: RETDTB ENDP;--------------------------------------------------------------------------------------------------------------------------------子程序：OUTPUT功能：输出一组数据;--------------------------------------------------------------------------------------------------------------------------------OUTPUT PROCMOV DI,COUNT ;计数器DI=5AND SI,0GO1: MOV BX,ARRAY[SI] ;将存储单元的第一组数据存入BXTEST BX,8000H ;判断正负JZ GO2MOV DL,2DHMOV AH,02H ;2号DOS功能调用，输出负号"-"INT 21HNEG BXGO2: CALL ONE ;调用ONE子程序，将BX中二进制数转换为十进制数输出 MOV DL,20HMOV AH,02H ;2号DOS功能调用，输出空格符INT 21HADD SI,2 ;指针指向下一数据DEC DI ;DI←DI-1JNZ GO1 ;计数器DI不为零，继续循环CALL CRLFRETOUTPUT ENDP;--------------------------------------------------------------------------------------------------------------------------------子程序：ONE功能：将BX中的的二进制数转换为十进制数,由高到低各位依次输出;--------------------------------------------------------------------------------------------------------------------------------ONE PROCPUSH CXPUSH SIPUSH DIMOV CX,10000 ;除数存入CXCALL BTDMOV CX,1000CALL BTDMOV CX,100CALL BTDMOV CX,10CALL BTDMOV CX,1CALL BTDADD DL,FLAG2CMP DL,30H ;与"0"的ASCII码比较，判断该数是否为"0"JNE QUIT3MOV AH,02H ;2号DOS功能调用，输出"0"INT 21HQUIT3: POP DIPOP SIPOP CXPOP BXAND FLAG2,0 ;将首位标志FLAG2重新置0RETONE ENDP;--------------------------------------------------------------------------------------------------------------------------------子程序：BTD功能：将BX中的二进制数转换为一个十进制数输出;--------------------------------------------------------------------------------------------------------------------------------BTD PROCMOV AX,BXAND DX,0DIV CX ;字除法，商值存入AX,余数存入DXMOV BX,DX ;余数存入BXMOV DL,ALADD DL,30H ;对DL中的数进行ASCII码转换CMP FLAG2,0 ;判断是否为首位数据JNE QUIT1CMP DL,30H ;是首位则判断是否为"0"JE QUIT2 ;是"0"则不输出MOV FLAG2,1 ;不是"0"将首位标志置1QUIT1: MOV AH,02H ;2号DOS功能调用，输出一位十进制数INT 21HQUIT2: RETBTD ENDP;--------------------------------------------------------------------------------------------------------------------------------子程序：SORT功能：冒泡排序;--------------------------------------------------------------------------------------------------------------------------------SORT PROCCLDMOV CX,COUNT ;初始化计数器CXDEC CX ;CX=4LOO1: MOV DI,CX ;CX中的数存入DIAND SI,0LOO2: MOV AX,ARRAY[SI]CMP AX,ARRAY[SI+2] ;相邻两数进行比较JL LOO3XCHG AX,ARRAY[SI+2] ;前一数较大则进行数据交换MOV ARRAY[SI],AXLOO3: ADD SI,2 ;前一数较小，则进行下一组比较LOOP LOO2 ;CX=0,停止内循环MOV CX,DI ;还原计数器CX的值LOOP LOO1 ;CX=0,停止外循环RETSORT ENDP;--------------------------------------------------------------------------------------------------------------------------------CODE ENDSEND START五、运行结果（1）对300,250,280,240,260五个数进行冒泡排序，运行结果如下：（2）对-1,2,54，-38,43五个数进行冒泡排序，运行结果如下（1）当输入不合法时，出现错误提示：（4）当输入数据不足5个时程序自动补0：六、心得体会在本次汇编语言程序设计实验中，我们学习了汇编语言的循环结构，并对冒泡排序法进行了汇编程序设计，我首先编写了对给定数据进行冒泡排序的算法设计，这有助于我熟悉冒泡排序的逻辑结构，理清设计思路。

实验报告_冒泡排序法(3篇)

第1篇一、实验目的1. 理解冒泡排序算法的基本原理和操作步骤。

2. 掌握冒泡排序算法的实现方法。

3. 分析冒泡排序算法的时间复杂度和空间复杂度。

4. 通过实验验证冒泡排序算法的效率。

二、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发环境：Visual Studio 2019三、实验原理冒泡排序是一种简单的排序算法，其基本思想是通过多次比较和交换相邻元素，将待排序的序列变为有序序列。

冒泡排序算法的基本步骤如下：1. 从第一个元素开始，相邻的两个元素进行比较，如果它们的顺序错误（即第一个元素大于第二个元素），则交换它们的位置。

2. 重复步骤1，对相邻的元素进行比较和交换，直到整个序列的最后一个元素。

3. 第一轮排序完成后，最大的元素被放置在序列的最后一个位置。

4. 从第一个元素开始，对剩余的元素重复步骤1和步骤2，直到序列的倒数第二个元素。

5. 重复步骤3和步骤4，直到整个序列有序。

四、实验步骤1. 编写冒泡排序算法的C++代码，实现上述算法步骤。

2. 在主函数中创建一个待排序的数组。

3. 调用冒泡排序函数对数组进行排序。

4. 输出排序前后的数组，验证排序结果。

五、实验代码```cppinclude <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]) {// 交换相邻元素int temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}}// 打印数组函数void printArray(int arr[], int n) {for (int i = 0; i < n; i++) {cout << arr[i] << " ";}cout << endl;}int main() {// 创建待排序的数组int arr[] = {64, 34, 25, 12, 22, 11, 90};int n = sizeof(arr) / sizeof(arr[0]);// 打印排序前的数组cout << "排序前的数组：\n";printArray(arr, n);// 调用冒泡排序函数bubbleSort(arr, n);// 打印排序后的数组cout << "排序后的数组：\n";printArray(arr, n);return 0;}```六、实验结果与分析1. 运行实验程序，输出排序前后的数组，验证排序结果是否正确。

冒泡排序法实验报告

一、实验目的1. 理解冒泡排序的基本原理和步骤。

2. 掌握冒泡排序算法的实现方法。

3. 通过实验，分析冒泡排序算法的时间复杂度和空间复杂度。

4. 了解冒泡排序在实际应用中的优缺点。

二、实验内容1. 实验环境：Windows操作系统，C++编程语言。

2. 实验步骤：（1）创建一个冒泡排序函数，用于对整数数组进行升序排序。

（2）编写主函数，接收用户输入的整数个数和整数数据，调用冒泡排序函数进行排序。

（3）输出排序后的数组。

（4）分析冒泡排序算法的时间复杂度和空间复杂度。

三、实验代码```cpp#include <iostream>using namespace std;// 冒泡排序函数void bubbleSort(int arr[], int size) {for (int i = 0; i < size - 1; i++) {for (int j = 0; j < size - i - 1; j++) {if (arr[j] > arr[j + 1]) {// 交换相邻元素int temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}}// 主函数int main() {int n;cout << "请输入整数个数: ";cin >> n;int arr[n];// 读取用户输入的整数cout << "请输入 " << n << " 个整数: "; 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;}```四、实验结果与分析1. 运行程序，输入10个整数：34, 12, 56, 78, 9, 25, 47, 89, 36, 15。

微机原理及接口技术实验——冒泡法

微机原理及接口技术实验——冒泡法冒泡排序是一种简单的排序算法，其基本思想是通过重复比较相邻的两个元素，并将较大的元素交换到右侧，从而将最大的元素逐渐"冒泡"到最右侧。

这种算法得名于每次比较时较大元素"冒泡"到右侧的过程。

冒泡排序算法的步骤如下：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行提示的错误。

微机原理冒泡排序实验报告含源程序

实验报告实验名称_ _冒泡排序实验_课程名称____ __ __微机原理_____________院系部:控计学院专业班级：信安1101学生姓名：陈茹君学号:1111290106同组人:实验台号:18指导教师：闫江毓成绩：实验日期:2014年5月9日华北电力大学一、实验目的掌握用汇编语言编写气泡排序程序的思路和方法，掌握字符和数据的显示方法。

二、实验内容从键盘输入5个有符号2位十进制数，将它转换成有符号二进制数，将结果送入内存中buff开始的单元中。

将这些数从大到小排序，并将排序结果显示在屏幕上。

三、实验步骤1.算法设计1)问题分析键盘输入子程序inword 出口：buff开始的单元，CX排序子程序sort：入口：buff开始的单元，CX；出口：buff开始的单元，CX显示子程序display：入口：AL2)绘出流程图2.详细设计1)变量定义及说明.databuff db -5,-43,-32,-22,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,02)寄存器的使用及含义使用了al、ah、bl、bh、ax、bx、cx、di、si寄存器，都是用来存放数据，比较数据的大小，进行数据的值的转化和计算。

3)程序功能说明4)源程序清单.model small.data;buff db 20 dup(1)buff db -5,-43,-32,-22,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0.codestart:mov ax, @datamov ds, axcall inwordcall sortcall displaymov ax, 4c00hint 21hinword procpush axpush bxpush cxpush dxpush simov si, offset buffmov cx, 5read:mov ah, 01hint 21hmov ah, 10xor bh, bhcmp al, 2dhmov bl, 1mov ah, 01hint 21h pos:add bh, alsub bh, 30hmov ah, 01hint 21hcmp al, 20hje donesub al, 30hxchg bh, almov ah, 10mul ahadd bh, 30hjmp pos done:cmp bl, 1jne finishneg bhmov bl, 0 finish:mov [si], bhinc siloop readpop sipop dxpop cxpop bxpop axretendpsort procpush axpush cxpush sipush dimov bx, 4 first:mov al, [si]mov cx, bxmov di, si second:inc dicmp al, [di]jge nextxchg al, [di]mov [si], al next:loop secondinc sidec bxjnz firstpop dipop sipop cxpop bxpop axretendp display procpush axpush bxpush cxpush dxpush simov dl, 0dhmov ah, 02hmov dl, 0ahmov ah, 02hint 21hmov cx, 5mov si, offset buffmov dh, 10dis:test [si], 10000000bjz positivemov dl, 2dhmov ah, 02hint 21hneg [si] positive:mov al, [si]xor ah, ahdiv dhmov dl, aladd dl, 30hmov bh, ahmov ah, 02hint 21hmov dl, bhadd dl, 30hmov ah, 02hint 21hmov dl, 20hmov ah, 02hint 21hinc siloop dispop sipop dxpop cxpop axretendpend start四、调试结果及调试分析五、结论与心得我们不仅要学习书本上的知识，更要知识与实践相结合，多动手发现问题解决问题，学会举一反三、融会贯通。

冒泡排序的实验报告

一、实验目的1. 理解冒泡排序算法的基本原理；2. 掌握冒泡排序算法的实现方法；3. 分析冒泡排序算法的时间复杂度；4. 通过实验验证冒泡排序算法的效率。

二、实验原理冒泡排序是一种简单的排序算法，它通过重复遍历待排序的数列，比较每对相邻的项，并在顺序错误时交换它们的位置，直到没有需要交换的项为止。

由于排序过程中小数逐渐浮到前面，大数逐渐沉到后面，故得名冒泡排序。

冒泡排序的基本思想是：比较相邻的两个元素，如果它们的顺序错误（即前一个比后一个大），则交换它们的位置。

这样，每一轮遍历后，最大的元素就会被“冒泡”到数组的末尾。

重复此过程，直到整个数组排序完成。

三、实验步骤1. 准备实验材料：一组待排序的整数序列；2. 实现冒泡排序算法，包括以下步骤：a. 初始化一个布尔变量flag，用于标记是否发生了交换；b. 遍历数组，比较相邻的两个元素，如果顺序错误则交换它们的位置；c. 如果在某一轮遍历中没有发生交换，说明数组已经排序完成，退出循环；d. 重复步骤b和c，直到数组排序完成；3. 对排序结果进行验证，确保数组已正确排序；4. 记录冒泡排序算法的执行时间；5. 分析冒泡排序算法的时间复杂度。

四、实验结果与分析1. 实验数据（1）待排序数组：[5, 3, 8, 6, 2, 7, 4, 1]（2）排序前数组：[5, 3, 8, 6, 2, 7, 4, 1]（3）排序后数组：[1, 2, 3, 4, 5, 6, 7, 8]2. 实验结果冒泡排序算法对上述数组进行排序，经过8轮遍历后，数组已正确排序。

3. 实验分析（1）冒泡排序的时间复杂度分析冒泡排序的时间复杂度为O(n^2)，其中n是待排序数组的长度。

原因如下：- 在最坏的情况下（即数组完全逆序），冒泡排序需要进行n-1轮遍历，每轮遍历需要比较n-1次，因此总比较次数为(n-1)+(n-2)+...+1，即(n-1)n/2，即O(n^2)。

- 在最好的情况下（即数组已经排序），冒泡排序在第一轮遍历后即可发现没有发生交换，此时只需进行一轮遍历，比较次数为n-1，即O(n)。

冒泡排序实习报告

一、实习背景随着计算机科学技术的不断发展，算法和数据结构在计算机编程中扮演着越来越重要的角色。

冒泡排序作为一种基础的排序算法，对于理解排序算法的原理和实现具有重要意义。

为了提高自己的编程能力和对数据结构的理解，我选择在实习期间进行冒泡排序项目的实践。

二、实习目的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 三种语言的实现进行测试。

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

微机原理实验报告班级：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在存储器地址末尾没变。

微机实验排序实验报告

一、实验目的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)。

实验一冒泡排序原理验证(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语言代码篇幅较短，便于理解；总而言之，这一次的收获颇多，带来了更多学习的兴趣和动力；。

四川大学微机原理冒泡法排序实验报告

《微机原理与接口技术实验报告》学院：电气信息学院班级：电力老师：学号：姓名：目录1.实验目的 (1)2.实验内容 (1)3.程序流程图 (2)4.程序清单与注释 (4)5.运行结果 (10)6.实验心得 (11)一、实验目的：经过第一次试验，我们初次了解了DEBUG调试程序强大功能。

1.学习汇编语言循环结构语句的特点，重点掌握冒泡排序的方法。

2.理解并掌握各种指令的功能，编写完整的汇编源程序。

3.进一步熟悉DEBUG的调试命令。

二、实验内容:用冒泡的方法对一组数据元素排序，它的基本方法是：将相邻的两个元素通过比较进行排序，通过多次，多遍的邻元素排序，实现整个一组数的排序。

对于5（N）个元素，整个排序通过4遍（=N-1）邻元素排序完成。

每一遍的排序由若干次邻元素的排序组成。

4遍排序中，邻元素的排序依次为4，3，2，1遍。

完成第一遍排序后，最大数沉底，已经到达它应占据的位置，不需要参加下一遍的排序。

实验要求：1.编制程序，从键盘输入300，250，280，240，260这五个数，并思考如何输入任意五个数，五个数可以有一位数，二位数，三位数，四位数，五位数，混合输入比较大小；2.对这组数用冒泡法进行排序，并输出原始数据及排序后数据，两两数据之间用空格分隔；3.利用DEBUG调试工具，用D0命令，查看排序前后，内存数据的变化，以及会用调试命令查看程序运算中寄存器中的值；4.去掉最大和最小的两个值，求出其余值的平均值，并输出最大值，最小值和平均值；5.用压栈PUSH和出栈POP指令“先进后出”的特点，设计算法将平均值按位逐个输出(即输出263)；6.用移位指令将平均值以二进制串的形式输出。

7.设计程序要有模块化的思想，用子程序实现不同的功能；8.所有数据输出前要用字符串的输出指令，进行输出提示（如：zui da zhi shi : 300等），所有数据结果能清晰地显示在电脑屏幕上。

三、程序流程图：1.主程序MAIN：2.冒泡排序子程序：SORT四、程序清单与注释：NAME BUBBLE_SORTDATA SEGMENTARRAY DW 5 DUP(?)COUNT DW 5TWO DW 2FLAG1 DW 0FLAG2 DB 0FAULT DW -1CR DB 0DH,0AH,'$'STR1 DB'Please input five numbers seperated with space and finished with Enter:','$'STR2 DB'The original numbers:','$'STR3 DB'The sorted numbers:','$'STR4 DB'The Min:','$'STR5 DB'The Max:','$'STR6 DB'The Average:','$'STR7 DB'The binary system of the average:','$'STR8 DB'Input error!Please input again!','$'DATA ENDSCODE SEGMENTMAIN PROC FARASSUME CS:CODE,DS:DATA,ES:DATASTART: PUSH DSAND AX,0PUSH AXMOV AX,DATAMOV DS,AXLEA DX,STR1MOV AH,09HINT 21HCALL CRLFREIN: CALL INPUTCMP AX,FAULTJE REINLEA DX,STR2MOV AH,09HINT 21HCALL OUTPUTCALL SORTLEA DX,STR3MOV AH,09HINT 21HCALL OUTPUTAND SI,0AND BX,0MOV BX,ARRAY[SI] LEA DX,STR4MOV AH,09HINT 21HCALL ONECALL CRLFLEA DX,STR5MOV AH,09HINT 21HMOV BX,ARRAY[SI+8] CALL ONECALL CRLFLEA DX,STR6MOV AH,09HINT 21HAND DX,0MOV AX,ARRAY[SI+2] ADD AX,ARRAY[SI+4] ADC AX,ARRAY[SI+6] MOV CX,COUNTDEC CXDEC CXDIV CXMOV BX,AXCALL ONECALL CRLFLEA DX,STR6MOV AH,09HMOV CX,16LL1: AND DX,0DIV TWOPUSH DXLOOP LL1MOV CX,16LL2: POP DXADD DL,30HMOV AH,2INT 21HLOOP LL2MOV AH,4CHINT 21HMAIN ENDPCRLF PROCLEA DX,CRMOV AH,09HINT 21HRETCRLF ENDPINPUT PROCMOV CX,COUNTAND SI,0NEXT1: CALL DTBDEC CXCMP DL,20HJE STOCMP DL,0DHJE EXIT2CALL CRLF ERROR: LEA DX,STR8 MOV AH,09HINT 21HCALL CRLFMOV AX,FAULTJMP EXIT3STO: MOV ARRAY[SI],BX ADD SI,2JMP NEXT1EXIT2: MOV ARRAY[SI],BX CALL CRLFEXIT3: RETINPUT ENDPDTB PROCAND BX,0AND FLAG1,0 CHAR: MOV AH,01HINT 21HMOV DL,ALCMP AL,2DHJNZ NEXT2MOV FLAG1,1JMP CHARNEXT2: SUB AL,30HJL NEXT3CMP AL,09HJG NEXT3CBWXCHG AX,BXMOV CX,10MUL CXXCHG AX,BXADD BX,AXJMP CHARNEXT3: CMP FLAG1,1JNZ EXIT1NEG BXEXIT1: RETDTB ENDPOUTPUT PROCCALL CRLFMOV DI,COUNTAND SI,0GO1: MOV BX,ARRAY[SI] TEST BX,8000HJZ GO2MOV DL,2DHMOV AH,02HINT 21HNEG BXGO2: CALL ONEMOV DL,2DHMOV AH,02HINT 21HADD SI,2DEC DIJNZ GO1CALL CRLFRETOUTPUT ENDPONE PROCPUSH BXPUSH CXPUSH SIPUSH DIMOV CX,10000 CALL BTDMOV CX,1000 CALL BTDMOV CX,100 CALL BTDMOV CX,10CALL BTDMOV CX,1CALL BTDADD DL,FLAG2 CMP DL,30H JNE QUIT3MOV AH,02H INT 21H QUIT3: POP DIPOP SIPOP CXPOP BXAND FLAG2,0 RETONE ENDPBTD PROCMOV AX,BXAND DX,0DIV CXMOV BX,DXMOV DL,ALADD DL,30H CMP FLAG2,0 JNE QUIT1CMP DL,30HJE QUIT2MOV FLAG2,1QUIT1: MOV AH,02HINT 21HQUIT2: RETBTD ENDPSORT PROCCLDMOV CX,COUNTDEC CXLOO1: MOV DI,CXAND SI,0LOO2: MOV AX,ARRAY[SI] CMP AX,ARRAY[SI+2] JL LOO3XCHG AX,ARRAY[SI+2] MOV ARRAY[SI],AX LOO3: ADD SI,2LOOP LOO2MOV CX,DILOOP LOO1RETSORT ENDPCODE ENDSEND START五、运行结果：1.对300、250、280、240、260五个数据进行冒泡排序，运行结果如下：2、对5802、129、30、7、1233五个数据进行冒泡排序，运行结果如下：3.对-1、23、189、-234、6五个数据进行冒泡排序，运行结果如下：4.当输入不合法时，显示如下：六、实验心得：在本次汇编语言程序设计实验中，我们运用了循环结构对冒泡排序进行了汇编设计。

冒泡排序和快速排序实验报告

实验报告
实验名称实验三冒泡排序和快速排序
班级
学号
姓名
成绩
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()函数。

最后只好没有输出时间，也没有比较两种方法的运行时间
指导教师评语及成绩：
成绩：指导教师签名：
批阅日期：。

实验06 冒泡排序实验报告

实验六循环结构（冒泡排序）[二课时]实验日期：11月27日学校：安徽农业大学经济技术学院星期：三节次：1、2 实验课时：姓名：江珊珊学号：专业、班级：通信三班得分：1、实验目的1、掌握循环结构语句的特点。

2、了解内存的块操作方法。

3、掌握冒泡排序的方法4、掌握EXE模板的使用2、实验内容对指定内存起址和长度的数据块，要求将其按照从小到大（从大到小）的顺序排序3、实验步骤采用EXE模板，单步调试下列程序，观察内存变化（源程序见教材P151，有改动）DSEG SEGMENT 'DATA'V AR DB 11,-8,-25,76,9,52N DW N-V ARDSEG 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.4、实验运行结果：设DB 11,-8,-25,76,9,52单击[模拟]之后，出现如图所示的界面，观察可知，默认CS=0B68H，DS=0B57H。

单步执行完第二句程序之后，可以发现，DS的值变成了0B67H运行结束后，可以观察数据区中的前6个数据已经按照从小到大排序5、思考题解答⑴数据段中，有语句N DW N-V AR，观察存储区域中，N所在的单元内容，说出变量N的含义答：变量N的含义是V AR定义的字节数⑵上述程序，若采用EXE模板，程序装入内存的首地址（物理地址）是多少？提示：CS的值，程序首地址的偏移地址是0000H。

川大微机上机实验报告(冒泡排序法)

上机目的：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遍。

完成第一遍排序后，最大数沉底，已经到达它应占据的位置，不需要参加下一遍的排序。

思考如何输入任意五个数，五个数可以有一位数，二位数，三位数，四位数，五位数，混合输入比较大小；2、对这组数用冒泡法进行排序，并输出原始数据及排序后数据，两两数据之间用空格分隔；3、利用DEBUG调试工具，用D0命令，查看排序前后，内存数据的变化，以及会用调试命令查看程序运算中寄存器中的值；4、去掉最大和最小的两个值，求出其余值的平均值，并输出最大值，最小值和平均值；5、用压栈PUSH和出栈POP指令“先进后出”的特点，设计算法将平均值按位逐个输出(即输出263)；6、用移位指令将平均值以二进制串的形式输出。

7、设计程序要有模块化的思想，用子程序实现不同的功能；8、所有数据输出前要用字符串的输出指令，进行输出提示（如：zui dazhi shi : 300等），所有数据结果能清晰地显示在电脑屏幕上。

程序流程图如下：程序清单：DATAS SEGMENTSHURU DB 'QING SHU RU 5 GE SHU JU',13,10,'$'SHU1 DB 4,?,3 DUP(?)SHU2 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 ENDSCODES 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,0PUSH CX;外循环次数入栈PX: 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,9INT 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 21HADD SI,2POP 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,10MOV AH,2INT 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,30HPUSH 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码MOV AVER,ALMOV AL,AHXOR AH,AHDIV [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,9INT 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 21HCODES ENDSEND START运行结果:心得体会：本次实验编程比较复杂，在编这个程序之前自己先将前面三个练习编了一下，然后参考了书上的一个冒泡排序法的程序，之后才开始动手编该程序。

冒泡排序代码实验报告

一、实验目的1. 理解冒泡排序的基本原理和算法步骤。

2. 掌握冒泡排序的代码实现。

3. 分析冒泡排序的时间复杂度和空间复杂度。

4. 通过实验验证冒泡排序的性能。

二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.83. 开发工具：PyCharm三、实验内容1. 冒泡排序的基本原理冒泡排序是一种简单的排序算法，它重复地遍历要排序的数列，每次比较两个相邻的元素，如果它们的顺序错误就把它们交换过来。

遍历数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

2. 冒泡排序的算法步骤（1）比较相邻的元素。

如果第一个比第二个大（小），就交换它们两个；（2）对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。

这步做完后，最后的元素会是最大的数；（3）针对所有的元素重复以上的步骤，除了最后一个；（4）重复步骤1~3，直到排序完成。

3. 冒泡排序的代码实现```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```4. 冒泡排序的性能分析（1）时间复杂度：冒泡排序的平均时间复杂度为O(n^2)，最坏的时间复杂度也为O(n^2)，最好时间复杂度为O(n)，即当输入数组已经是有序的情况下。

（2）空间复杂度：冒泡排序的空间复杂度为O(1)，因为它是一个原地排序算法，不需要额外的存储空间。

四、实验步骤1. 导入Python代码编辑器。

2. 编写冒泡排序的代码。

3. 创建一个待排序的数组。

4. 调用冒泡排序函数，传入待排序的数组。

5. 输出排序前后的数组，观察排序效果。

6. 分析冒泡排序的性能。

五、实验结果1. 测试数组：[5, 2, 9, 1, 5, 6]排序前：[5, 2, 9, 1, 5, 6]排序后：[1, 2, 5, 5, 6, 9]2. 性能分析通过多次运行冒泡排序函数，并记录排序所需的时间，可以得出以下结论：- 在数组元素较少的情况下，冒泡排序的性能较好；- 随着数组元素的增加，冒泡排序的性能逐渐下降；- 在大数据量下，冒泡排序的性能较差。

微机原理实验报告-冒泡排序

冒泡排序(实验报告)

微机原理实验报告冒泡法对数据排序8页

冒泡排序计算实验报告

微机原理实验报告-冒泡排序

实验报告_冒泡排序法(3篇)

冒泡排序法实验报告

微机原理及接口技术实验——冒泡法

微机原理实验报告冒泡法对数据排序

微机原理 冒泡排序实验报告含源程序

冒泡排序的实验报告

冒泡排序实习报告

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

微机实验排序实验报告

实验一 冒泡排序原理验证(1)

四川大学微机原理冒泡法排序实验报告

冒泡排序和快速排序实验报告

实验06 冒泡排序实验报告

川大微机上机实验报告(冒泡排序法)

冒泡排序代码实验报告

微机原理冒泡排序实验报告含源程序

实验一冒泡排序原理验证(1)