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

一、实验目的和要求理解和掌握冒泡排序技术，使用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页
实验目的：通过对冒泡法进行实现，了解算法的实际应用，并且掌握编程语言的基本
技巧。

实验原理：
冒泡排序是一种简单的排序方法，它的基本思想就是通过不断交换相邻的元素，将较
小的元素交换到前面，较大的元素交换到后面，从而将整个数列按从小到大（或从大到小）的顺序进行排列。

实验步骤：
（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篇一、实验目的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 三种语言的实现进行测试。

一、实验目的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. 性能分析通过多次运行冒泡排序函数，并记录排序所需的时间，可以得出以下结论：- 在数组元素较少的情况下，冒泡排序的性能较好；- 随着数组元素的增加，冒泡排序的性能逐渐下降；- 在大数据量下，冒泡排序的性能较差。

微机原理实验报告班级：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)。

南京邮电大学通达学院实验报告实验名称: 冒泡排序原理验证课程名称：微型计算机原理与接口技术姓名班级学号: ________________________________________________实验时间：_____________________冒泡排序一、实验原理：经典排序算法- 冒泡排序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()函数。

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

微机原理实验报告——冒泡法实现数据排序姓名：XXX学号：1043031467专业：电气工程及其自动化一、实验内容用“冒泡“法对一组数300，250，280，240，260，按从小到大的顺序排列。

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

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

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

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

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

外循环的次数为CX=4次(N-1)，内循环的次数为4，3，2，1(DEC CX)排序遍数本遍排序前第一次排序后第二次排序后第三次排序后第四次排序后1 300，250，280，240，260 250，300，280，240，260250，280，300，240，260250，280，240，300，260250，280，240，260，3002 250，280，240，260，300250，280，240，260，300250，240，280，260，300250，240，260，280，3003 250，240，260，280，300250，240，260，280，300240，250，260，280，3004 240，250，260，280，300240，250，260，280，300实验要求：1.编制程序，对这组数进行排序，并输出原数据及排序后数据；2.利用DEBUG调试工具，用D0命令，查看排序前后，内存数据的变化；3. 去掉最大和最小的两个值，求出其余值的平均值，并输出最大值，最小值和平均值；4. 用学过的压栈PUSH和出栈POP指令，将平均值按位逐个输出(即输出263)；5将平均值263转化为二进制串，并将这组二进制串输出。

6.所有数据输出前要用字符串的输出指令，进行输出提示（如：zui da zhi shi : 300等），所有数据结果能清晰地显示在屏幕上。

冒泡排序的实验报告冒泡排序的实验报告一、引言冒泡排序是一种简单但效率较低的排序算法。

它的基本思想是通过相邻元素的比较和交换来将最大（或最小）的元素逐渐“冒泡”到数列的末尾。

本实验旨在通过编写冒泡排序的程序，验证其排序效果和时间复杂度。

二、实验过程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、复习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运行结果:心得体会：本次实验编程比较复杂，在编这个程序之前自己先将前面三个练习编了一下，然后参考了书上的一个冒泡排序法的程序，之后才开始动手编该程序。