冒泡排序算法实验报告

合集下载

冒泡排序(实验报告)

一、实验目的和要求理解和掌握冒泡排序技术，使用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语言编写程序，提高了我的编程能力，受益匪浅。

北航计软实验报告实验三

3）针对所有的元素重复以上的步骤,除了最后一个。
4）持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。
2.快速排序
1）设置两个变量i、j,排序开始的时候: i=0, j=N-1；
2）以第一个数组元素作为关键数据,赋值给key,即key=A[0]；
3）从j开始向前搜索,即由后开始向前搜索(j--),找到第一个小于key的值A[j],将A[j]和A[i]互换；
实验报告
实验名称冒泡排序和快速排序
班级
学号
姓名
成绩
实验概述:
【实验目的及要求】
通过编程程序达到熟悉并掌握教材中所介绍的几种排序方法。
【实验原理】
1.冒泡排序
1）比较相邻的元素。如果第一个比第二个大,就交换他们两个。
2）对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的数。
b[i]=num;
}
printf("随机数产生完成\n");
for (i=0;i<N;i++)
printf("%d ",a[i]);
printf("\n\n");
system("pause");
printf("\n\n");
com=0;
mov=0;
for (i=0;i<N;i++)
{
for (j=0;j<N-1;j++)
{
l++;
com++;
}
b[r]=b[l];
mov++;

程设作业实验报告

实验题目：C语言实现冒泡排序算法实验目的：1. 理解冒泡排序算法的基本原理。

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

3. 通过实验加深对排序算法的理解和应用。

实验环境：1. 操作系统：Windows 102. 编译器：Visual Studio 20193. 编程语言：C语言实验内容：本次实验要求使用C语言实现冒泡排序算法，并对一组随机生成的数据进行排序。

实验步骤：1. 创建一个新的C语言项目，命名为“BubbleSort”。

2. 在主函数中，定义一个整型数组，用于存放待排序的数据。

3. 使用随机数生成函数生成10个随机数，填充到数组中。

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

5. 输出排序前后的数组内容。

6. 保存并编译项目。

实验代码：```c#include <stdio.h>#include <stdlib.h>#include <time.h>// 冒泡排序函数void bubbleSort(int arr[], int n) {int i, j, temp;for (i = 0; i < n - 1; i++) {for (j = 0; j < n - 1 - i; j++) { if (arr[j] > arr[j + 1]) {temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}}// 打印数组函数void printArray(int arr[], int n) {int i;for (i = 0; i < n; i++) {printf("%d ", arr[i]);}printf("\n");}int main() {int arr[10];int i;// 初始化随机数发生器srand(time(NULL));// 生成随机数并填充到数组中for (i = 0; i < 10; i++) {arr[i] = rand() % 100; // 生成0-99之间的随机数}printf("排序前：\n");printArray(arr, 10);// 调用冒泡排序函数bubbleSort(arr, 10);printf("排序后：\n");printArray(arr, 10);return 0;}```实验结果：1. 排序前数组内容为随机生成的10个整数。

冒泡实验报告怎么写

冒泡实验报告怎么写引言冒泡排序是一种简单但效率较低的排序算法，它通过比较相邻元素的大小并根据需要交换位置来逐渐将待排序的数列排序。

本实验旨在通过实际编程实现和运行冒泡排序算法，观察和分析其性能，并比较不同规模数据下冒泡排序的时间复杂度。

实验目的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是数组的长度。

改良冒泡排序实验报告

一、实验背景冒泡排序是一种简单的排序算法，其基本思想是通过比较相邻元素的大小，将较大的元素“冒泡”到数组的末尾，从而实现数组的有序化。

然而，传统的冒泡排序算法存在效率较低的问题，特别是在处理大数据量时，其时间复杂度为O(n^2)，这在实际应用中难以满足需求。

为了提高冒泡排序的效率，本实验针对传统冒泡排序算法进行了改良，通过引入标记变量和剪枝优化，提高了算法的运行速度。

二、实验目的1. 理解冒泡排序算法的原理和基本思路；2. 掌握改良冒泡排序算法的设计方法；3. 分析改良冒泡排序算法的时间复杂度和空间复杂度；4. 对比传统冒泡排序和改良冒泡排序的效率。

三、实验内容1. 实现传统冒泡排序算法；2. 设计改良冒泡排序算法；3. 对比两种算法的效率；4. 分析改良冒泡排序算法的优缺点。

四、实验步骤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. 设计改良冒泡排序算法```cvoid improvedBubbleSort(int arr[], int n) { int i, j, temp, swapped;for (i = 0; i < n - 1; i++) {swapped = 0;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;swapped = 1;}}if (swapped == 0) {break;}}}```3. 对比两种算法的效率通过对比两种算法在相同数据量下的运行时间，可以发现改良冒泡排序算法在大多数情况下具有更高的效率。

冒泡排序实验报告心得(3篇)

第1篇一、实验背景在本次数据结构与算法课程中，我们学习了多种排序算法，其中冒泡排序作为最基础的排序算法之一，引起了我的浓厚兴趣。

通过本次实验，我对冒泡排序的原理、实现过程以及优化方法有了更深入的理解。

二、实验目的1. 理解冒泡排序算法的原理和基本思路。

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

3. 分析冒泡排序的优化方法，提高算法效率。

4. 通过实验加深对排序算法的理解，为以后学习更复杂的排序算法打下基础。

三、实验过程1. 原理学习：首先，我详细学习了冒泡排序的原理。

冒泡排序是一种简单的交换排序算法，通过相邻元素的比较和交换，逐步将数组排序。

基本思路是：比较相邻的两个元素，如果它们的顺序错误（如第一个比第二个大），就交换它们的位置；然后，再对下一对相邻元素进行比较和交换，如此反复，直到没有需要交换的元素，数组就完成了排序。

2. 代码实现：接下来，我动手编写了冒泡排序的代码。

在编写过程中，我注意了以下几点：- 使用双层循环实现冒泡排序，外层循环控制排序的轮数，内层循环控制每一轮中相邻元素的比较和交换。

- 使用一个标志变量记录每一轮是否有元素交换，如果没有交换，则表示数组已经排序完成，可以提前结束排序。

3. 优化方法：为了提高冒泡排序的效率，我尝试了以下优化方法：- 在每一轮排序中，记录最后一次交换的位置，这个位置之后的元素已经是有序的，下一轮排序可以忽略。

- 如果在某一轮排序中没有发生任何交换，则可以认为数组已经排序完成，可以提前结束排序。

4. 实验测试：在编写代码后，我对冒泡排序进行了测试，测试数据包括已排序数组、部分排序数组以及逆序数组。

实验结果表明，冒泡排序可以正确地对这些数据进行排序。

四、实验心得1. 原理理解：通过本次实验，我对冒泡排序的原理有了更加深入的理解。

冒泡排序虽然是一种简单的排序算法，但其思想在许多其他排序算法中都有体现，如快速排序、堆排序等。

2. 代码实现：在编写代码的过程中，我学会了如何将算法原理转化为代码，并注意了代码的可读性和可维护性。

冒泡法排序实验报告

冒泡法排序实验报告一、实验任务实现N个16位无符号整数的排序，核心程序使用汇编语言实现。

二、程序算法冒泡法：若有n个数需要排序，则第一次遍历n个数，将x[0]与x[1]相比，若x[0]>x[1],则两数交换位置，若x[0]<x[1],则不作任何调整；然后将x[0]与x[2]相比较，若x[0]>x[2],则两数交换位置；若x[0]<x[2],则不作任何调整；依此类推，直到x[0]与x[n]比较完毕为止。

接着第二次遍历n-1个数，将x[1]与x[2]相比，若x[1]>x[2],则两数交换位置，若x[0]<x[1],则不作任何调整；一直到x[1]与x[n]比较完毕为止。

最后一直到只需要遍历2个数，比较调整完毕就可以得到数组从小到大的排列次序，算法在每次遍历时使最小的数象气泡一样冒到顶端，在经历n-1次遍历以后即可得到结果。

三、源程序及注释//冒泡排序法#include <iostream.h>int main(int argc, char* argv[]){unsigned short int x[33]; //排序个数上限为33个unsigned short int i,j,n;unsigned short int a,b;//提示输入排序个数cout<<"Please input the count of numbers: \n";cin>>n;//提示输入需要排序的各个数cout<<"Please input the numbers: \n";x[0] = 0;for(i=1;i<n+1;i++) //初始化需要排序的数组x[n]cin>>x[i];for(i=0;i<=n;i++) //冒泡法排序{for(j=n;j>=i+1;j--) //每次遍历n-i个数{a = x[j-1];b = x[j];_asm{mov ax,a //将一个数读入到axcmp ax,b //比较两数大小jc exit //若a小则跳出xchg ax,b //若b小则两数交换次序mov a,axexit: NOP}x[j-1] = a; //保存两数排序结果x[j] = b;}}//输出排序结果，按从小到大排列cout<<"The Result is : \n";for(i=1;i<n+1;i++)cout<<x[i]<<' ';cout<<'\n';return 0;}四、实验结果。

冒泡排序计算实验报告

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

冒泡排序实验报告

2015/2016(1)实验题目冒泡排序实验学生姓名学生学号学生班级任课教师提交日期计算机科学与技术学院作业内容对比数组和向量的使用方法。

使用函数实现冒泡排序算法，传递参数分别为数组和向量，要求数据不被破坏。

设计思路主要介绍如何在不破坏原数组的情况下进行对数组的冒泡排序实现方法，在这里，采用了新建数组记录下标的方式：1、记录方法：代码：int *d = new int[M];//申请空间for (int i = 0; i < M; i++)d[i] = i; //记录下标然后对下标排序：for (int i = 0; i < M - 1; i++)for (int j = 0; j < M - 1 - i; j++)if (c[d[j]]>c[d[j + 1]])swap(d[j], d[j + 1]);//比较大小后互换位置最后输出，并且释放申请的内存：cout << "数组排序后顺序：" << endl;for (int i = 0; i < M; i++)cout << c[d[i]] << ' ';//排序完成，输出数据cout << endl;cout << "数组排序前顺序：" << endl;for (int i = 0; i < M; i++)cout << c[i] << ' ';//输出原数据cout << endl;delete[] d;//释放申请的空间程序代码源.cpp#include <iostream>#include <vector>using namespace std;void Sort(vector<int> &a){vector <int>b;//记录传入数据在a数组中的下标for (int i = 0; i < a.size(); i++)b.push_back(i); //记录a数组中的下标for (int i = 0; i < a.size() - 1; i++)for (int j = 0; j < a.size() - 1 - i; j++) if (a[b[j]]>a[b[j + 1]])swap(b[j], b[j + 1]);//比较大小后互换位置cout << "数组排序后顺序：" << endl;for (int i = 0; i < a.size(); i++)cout << a[b[i]] << ' ';//排序完成，输出数据cout << endl;cout << "数组排序前顺序：" << endl;for (int i = 0; i < a.size(); i++)cout << a[i] << ' ';//输出原数据cout << endl;}//对Vector动态数组进行冒泡排序，并输出void Sort(int c[], int M){int *d = new int[M];//申请空间for (int i = 0; i < M; i++)d[i] = i; //记录下标for (int i = 0; i < M - 1; i++)for (int j = 0; j < M - 1 - i; j++)if (c[d[j]]>c[d[j + 1]])swap(d[j], d[j + 1]);//比较大小后互换位置cout << "数组排序后顺序：" << endl;for (int i = 0; i < M; i++)cout << c[d[i]] << ' ';//排序完成，输出数据cout << endl;cout << "数组排序前顺序：" << endl;for (int i = 0; i < M; i++)cout << c[i] << ' ';//输出原数据cout << endl;delete[] d;//释放申请的空间}//对int数组进行冒泡排序，并输出int main(){vector <int>a;//用于存储传入的数据int N;//vector数组的长度int M;//int数组的长度int Q;//传入的数据while (cin >> N >> M){cout << "请输入" << N << "个向量数据：" << endl;for (int i = 0; i < N; i++){cin >> Q;a.push_back(Q);//存储输入数据}Sort(a);//冒泡排序,并对应输出int *c = new int[M];//申请空间cout << "请输入" << M << "个整数数据：" << endl;for (int i = 0; i < M; i++){cin >> Q;c[i] = Q;//存储输入数据}Sort(c,M);//冒泡排序，并对应输出delete[] c;//释放申请的空间}}测试结果到此为止，冒泡排序都能够正确实现，得到正确的结果。

排序算法实验报告2：冒泡排序及选择排序(分割策略)

排序算法实验报告2：冒泡排序及选择排序(分割策略)1. 引言本实验旨在研究和分析冒泡排序和选择排序算法，并通过对比它们的性能来评估它们在排序过程中的效率和效果。

冒泡排序和选择排序都是经典的排序算法，它们在不同的场景下都有着广泛的应用。

2. 冒泡排序2.1 算法原理冒泡排序是一种通过比较和交换相邻元素来排序的算法。

它的基本思想是重复地遍历待排序序列，每次比较相邻的两个元素，并根据排序规则对它们进行交换，直到整个序列有序。

2.2 算法实现冒泡排序的算法实现可以分为以下几个步骤：1. 遍历待排序序列，从第一个元素开始，依次比较相邻的两个元素。

2. 如果相邻元素的顺序不符合排序规则，则交换它们的位置。

3. 继续遍历序列，重复以上步骤，直到整个序列有序。

2.3 算法性能冒泡排序的时间复杂度为O(n^2)，其中n是待排序序列的长度。

它是一种稳定的排序算法。

3. 选择排序(分割策略)3.1 算法原理选择排序是一种通过选择最小（或最大）元素并将其放置到已排序序列的末尾（或开头）来排序的算法。

它的基本思想是将待排序序列划分为已排序和未排序两部分，每次从未排序部分选择最小（或最大）的元素，并将其加入到已排序部分。

3.2 算法实现选择排序的算法实现可以分为以下几个步骤：1. 遍历待排序序列，先假定第一个元素为最小（或最大）元素。

2. 将该元素与未排序部分的元素依次比较，找到最小（或最大）的元素。

3. 将最小（或最大）元素与未排序部分的第一个元素交换位置，将其加入到已排序部分。

4. 继续遍历未排序部分，重复以上步骤，直到整个序列有序。

3.3 算法性能选择排序的时间复杂度为O(n^2)，其中n是待排序序列的长度。

它是一种不稳定的排序算法。

4. 实验结果与分析通过对冒泡排序和选择排序的实验，我们得到了它们在不同规模的输入数据下的排序时间。

根据实验结果，我们可以发现：- 冒泡排序相对于选择排序来说，其性能较差。

在相同规模的输入数据下，冒泡排序的排序时间要长于选择排序。

冒泡希尔排序实验报告(3篇)

第1篇一、实验目的本次实验旨在通过实际操作，理解冒泡排序和希尔排序的基本原理，掌握这两种排序算法的实现方法，并比较它们在不同数据规模下的性能差异。

二、实验内容1. 冒泡排序冒泡排序是一种简单的排序算法，它通过重复遍历要排序的数列，比较每对相邻元素，并在顺序错误的情况下交换它们。

这个过程会重复进行，直到没有再需要交换的元素为止，这意味着数列已经排序完成。

2. 希尔排序希尔排序是一种基于插入排序的算法，通过比较距离较远的元素，逐渐减少比较的间隔，最终达到一次遍历完成排序的目的。

三、实验步骤1. 数据准备选择一组不同规模的数据集，包括小规模、中等规模和大规模数据集。

2. 冒泡排序实现根据冒泡排序的原理，编写相应的代码实现冒泡排序算法。

3. 希尔排序实现根据希尔排序的原理，编写相应的代码实现希尔排序算法。

4. 性能测试对两组算法在不同规模的数据集上进行测试，记录排序所需时间。

5. 结果分析分析两组算法在不同数据规模下的性能差异，并总结实验结果。

四、实验结果与分析1. 数据准备本次实验选择了以下三组数据集：- 小规模数据集：长度为10的随机整数数组。

- 中等规模数据集：长度为100的随机整数数组。

- 大规模数据集：长度为1000的随机整数数组。

2. 冒泡排序与希尔排序实现根据冒泡排序和希尔排序的原理，分别编写了相应的代码实现。

3. 性能测试对两组算法在不同规模的数据集上进行测试，记录排序所需时间。

- 小规模数据集：冒泡排序平均耗时约0.003秒，希尔排序平均耗时约0.002秒。

- 中等规模数据集：冒泡排序平均耗时约0.015秒，希尔排序平均耗时约0.008秒。

- 大规模数据集：冒泡排序平均耗时约0.8秒，希尔排序平均耗时约0.2秒。

4. 结果分析从实验结果可以看出，在相同的数据规模下，希尔排序的性能优于冒泡排序。

随着数据规模的增大，两者之间的性能差距更加明显。

这是因为希尔排序在排序过程中，通过比较距离较远的元素，减少了比较次数，从而提高了排序效率。

单片机与接口技术实验报告冒泡排序实验

单片机与接口技术实验报告--冒泡排序实验单片机与接口技术实验报告--冒泡排序实验一、实验目的本实验旨在通过单片机实现冒泡排序算法，加深对单片机和接口技术的理解和实践操作能力，提高程序设计和调试的能力。

二、实验设备实验设备包括：单片机开发板、计算机、串口通信设备、LED指示灯等。

三、实验原理冒泡排序是一种简单的排序算法，它重复地遍历要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。

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

这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

四、实验步骤1、硬件连接：将单片机开发板与计算机通过串口通信设备连接，并连接LED指示灯。

2、编写程序：在计算机上使用单片机开发环境编写冒泡排序算法程序，并通过串口通信发送到单片机。

3、调试程序：在单片机上运行程序，观察LED指示灯的变化，对程序进行调试和修改。

4、测试结果：对不同的输入数据进行测试，观察LED指示灯的变化，验证程序的正确性。

五、实验结果通过本实验，我们成功地在单片机上实现了冒泡排序算法，并能够根据不同的输入数据进行正确的排序。

同时，通过LED指示灯的显示，我们可以直观地观察到排序的过程。

六、实验总结通过本次实验，我们深入了解了冒泡排序算法的原理和实现方法，同时也提高了对单片机和接口技术的理解和实践操作能力。

在实验过程中，我们遇到了一些问题，比如如何正确地连接硬件，如何编写和调试程序等，但在老师的指导下，我们都成功地解决了问题。

我们也意识到自己在某些方面还有不足，比如对单片机的了解还不够深入，对程序的调试能力还有待提高等。

在今后的学习和实践中，我们将更加努力，提高自己的能力和水平。

冒泡排序的实验报告

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

冒泡排序实习报告

实习报告实习单位：XX科技有限公司实习岗位：软件开发工程师实习时间：2023年2月1日至2023年2月28日一、实习背景及目的作为一名计算机专业的学生，我一直对算法和数据结构有着浓厚的兴趣。

冒泡排序作为一种基础的排序算法，我一直想亲自动手实现并深入了解其原理。

因此，在本次实习中，我选择了XX科技有限公司，希望能在这里的实际工作中锻炼自己的编程能力，并深入理解冒泡排序算法。

二、实习内容及过程在实习期间，我主要参与了公司的一个小型项目的开发，负责实现一个冒泡排序算法。

在实现过程中，我首先了解了冒泡排序的基本原理，即通过不断比较和交换相邻元素的位置，使得待排序序列中的较大元素逐渐移动到序列的尾部，较小元素逐渐移动到序列的首部。

在实际编程过程中，我首先编写了一个简单的冒泡排序函数，然后将其应用到实际项目中。

在实现过程中，我遇到了一些问题，如如何避免重复比较同一对元素、如何判断序列已经排序完成等。

通过查阅资料和与同事的交流，我逐渐解决了这些问题，并成功实现了冒泡排序算法。

三、实习成果及收获通过本次实习，我成功实现了冒泡排序算法，并将其应用到实际项目中。

在实现过程中，我对冒泡排序的原理有了更深入的理解，同时也锻炼了自己的编程能力。

此外，在实习过程中，我还学会了如何查阅资料、如何与同事沟通合作等实际工作技能。

四、实习总结通过本次实习，我对冒泡排序算法有了更深入的了解，同时也锻炼了自己的编程能力。

同时，我也认识到自己在实际工作中的不足，如对某些算法细节的理解不够深入、编程习惯有待改进等。

在今后的学习和工作中，我将继续努力提高自己的能力，为成为一名优秀的软件开发工程师而努力。

（注：本文为示例文章，实际实习报告应根据个人实习经历和收获进行撰写。

）。

实现排序算法的实验报告

一、实验目的1. 理解排序算法的基本原理和特点。

2. 掌握几种常用的排序算法（冒泡排序、选择排序、插入排序、快速排序、归并排序等）的实现方法。

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

4. 通过实际编程实现排序算法，提高编程能力。

二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.83. 开发工具：PyCharm三、实验内容1. 冒泡排序2. 选择排序3. 插入排序4. 快速排序5. 归并排序四、实验步骤1. 冒泡排序（1）编写冒泡排序函数：def bubble_sort(arr)。