15数组(冒泡排序)

python对数组进行排序的方法Python是一种功能强大的编程语言，它提供了许多方法来对数组进行排序。

在本文中，我们将介绍几种常用的排序算法，并给出相应的Python代码示例，帮助读者理解和使用这些算法。

一、冒泡排序算法冒泡排序是一种简单直观的排序算法，它重复地遍历要排序的数组，比较相邻的元素，并按照规定的顺序交换它们。

该算法的基本思想是通过多次遍历来将最大（或最小）的元素逐渐“冒泡”到数组的一端。

下面是使用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]```二、选择排序算法选择排序是一种简单直观的排序算法，它通过每次选择最小（或最大）的元素，并将其放置在已排序的部分末尾。

该算法的基本思想是通过多次遍历来选择最小（或最大）的元素，并将其放置在已排序的部分的末尾。

下面是使用Python实现选择排序的代码：```pythondef selection_sort(arr):n = len(arr)for i in range(n):min_idx = ifor j in range(i+1, n):if arr[j] < arr[min_idx]:min_idx = jarr[i], arr[min_idx] = arr[min_idx], arr[i]```三、插入排序算法插入排序是一种简单直观的排序算法，它将数组分为已排序和未排序两部分，每次从未排序部分取出一个元素，并将其插入到已排序部分的正确位置。

该算法的基本思想是通过多次遍历来选择未排序部分的元素，并将其插入到已排序部分的正确位置。

下面是使用Python实现插入排序的代码：```pythondef insertion_sort(arr):n = len(arr)for i in range(1, n):key = arr[i]j = i-1while j >= 0 and arr[j] > key:arr[j+1] = arr[j]j -= 1arr[j+1] = key```四、快速排序算法快速排序是一种高效的排序算法，它通过选择一个基准元素，将数组分为小于基准元素和大于基准元素的两部分，并对这两部分分别进行递归排序。

数组排序c语言数组排序方法在C语言中，可以使用多种排序算法对数组进行排序。

常见的排序算法包括冒泡排序、选择排序、插入排序、快速排序、归并排序、堆排序等。

下面将详细介绍这些排序算法的原理、实现以及时间复杂度。

1. 冒泡排序（Bubble Sort）：冒泡排序是一种简单的排序算法，其基本思想是重复地在相邻的元素之间进行比较和交换，将最大的元素逐渐“浮”到数组的尾部。

具体实现过程如下：cvoid bubbleSort(int arr[], int n) {for (int i = 0; i < n-1; i++) {for (int j = 0; j < n-1-i; j++) {if (arr[j] > arr[j+1]) {交换相邻元素int temp = arr[j];arr[j] = arr[j+1];arr[j+1] = temp;}}}}冒泡排序的时间复杂度为O(n^2)，其中n为数组长度。

2. 选择排序（Selection Sort）：选择排序也是一种简单的排序算法，其基本思想是每次从未排序的部分中选取最小（或最大）的元素，放到已排序部分的末尾。

具体实现过程如下：cvoid selectionSort(int arr[], int n) {for (int i = 0; i < n-1; i++) {int minIndex = i;for (int j = i+1; j < n; j++) {if (arr[j] < arr[minIndex]) {minIndex = j;}}将最小元素交换到已排序部分的末尾int temp = arr[i];arr[i] = arr[minIndex];arr[minIndex] = temp;}选择排序的时间复杂度为O(n^2)。

3. 插入排序（Insertion Sort）：插入排序的基本思想是将数组分为已排序和未排序两部分，每次从未排序部分选择一个元素，插入到已排序部分的正确位置。

冒泡排序的原理for循环冒泡排序的原理for循环 1原理：比较两个相邻的元素，将值大的元素交换至右端。

思路：依次比较相邻的两个数，将小数放在前面，大数放在后面。

即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。

然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。

重复第一趟步骤，直至全部排序完成。

第一趟比较完成后，最后一个数一定是数组中最大的一个数，所以第二趟比较的时候最后一个数不参与比较；第二趟比较完成后，倒数第二个数也一定是数组中第二大的数，所以第三趟比较的时候最后两个数不参与比较；依次类推，每一趟比较次数-1；……举例说明：要排序数组：int[] arr={6,3,8,2,9,1};第一趟排序：第一次排序：6和3比较，6大于3，交换位置： 3 6 8 2 9 1第二次排序：6和8比较，6小于8，不交换位置：3 6 8 2 9 1第三次排序：8和2比较，8大于2，交换位置： 3 6 2 8 9 11第五次排序：9和1比较：9大于1，交换位置： 3 6 2 8 1 9总共进行了5次比较，排序结果： 3 6 2 8 1 9第二趟排序：第一次排序：3和6比较，3小于6，不交换位置：3 6 2 8 1 9第二次排序：6和2比较，6大于2，交换位置： 3 2 6 8 1 9第三次排序：6和8比较，6大于8，不交换位置：3 2 6 8 1 9第四次排序：8和1比较，8大于1，交换位置： 3 2 6 1 8 9总共进行了4次比较，排序结果： 3 2 6 1 8 9第三趟排序：第一次排序：3和2比较，3大于2，交换位置： 2 3 6 1 8 9第二次排序：3和6比较，3小于6，不交换位置：2 3 6 1 8 99总共进行了3次比较，排序结果： 2 3 1 6 8 9第四趟排序：第一次排序：2和3比较，2小于3，不交换位置：2 3 1 6 8 9第二次排序：3和1比较，3大于1，交换位置： 2 1 3 6 8 9总共进行了2次比较，排序结果： 2 1 3 6 8 9第五趟排序：第一次排序：2和1比较，2大于1，交换位置： 1 2 3 6 8 9总共进行了1次比较，排序结果： 1 2 3 6 8 9最终结果：1 2 3 6 8 96 个数。

冒泡排序法教案第一篇：冒泡排序法教案数据结构——冒泡排序（第19讲，第9章）一、复习回顾什么是排序：排序是把一个无序的数据元素序列整理成有规律的按排序关键字递增（或递减）排列的有序序列的过程。

/************************************************（已经学过的排序方法有：直接插入排序、希尔排序、直接插入排序：顺序的把待排序序列中的各个记录按其关键字的大小，插入到已排序的序列的适当位置。

希尔排序：（缩小增量排序），不断把待排序的记录分成若干个小组，对同一组内的记录进行排序，在分组时，始终保持当前组内的记录个数超过前面分组排序时组内的记录个数。

）************************************************/二、第一小节（目标：理解掌握冒泡思想）1、给出冒泡排序的定义（25分钟）将待排序序列中第一个记录的关键字R1.key与第二个记录的关键字R2.key作比较，如果R1.key>R2.key，则交换记录R1和R2在序列中的位置，否则不交换；然后继续对当前序列中的第二个记录和第三个记录作同样的处理，依此类推，知道序列中倒数第二个记录和最后一个记录处理完为止，我们称这样的过程为一次冒泡排序。

2、请学生上台做排序练习（15分钟做题+10分钟讲解）（巩固排序思想的掌握）第一题： 38 5 19 26 49 97 1 66 第一次排序结果：5 19 26 38 49 1 66 [97] 第二次排序结果：5 19 26 38 1 49 [66 97] 第三次排序结果：5 19 26 1 38 [49 66 97] 第四次排序结果：5 19 1 26 [38 49 66 97] 第五次排序结果：5 1 19 [26 38 49 66 97] 第六次排序结果：1 5 [19 26 38 49 66 97] 第七次排序结果：1 [5 19 26 38 49 66 97] 最后结果序列： 1 5 19 26 38 49 66 97第二题： 8 7 6 5 4 3 2 1数据结构——冒泡排序（第19讲，第9章）答第一次排序： 7 6 5 4 3 2 1 [8] 第二次排序： 6 5 4 3 2 1 [7 8] 第三次排序： 5 4 3 2 1 [6 7 8] 第四次排序： 4 3 2 1 [5 6 7 8] 第五次排序： 3 2 1 [4 5 6 7 8] 第六次排序： 2 1 [3 4 5 6 7 8] 第七次排序：1 [2 3 4 5 6 7 8] 最后结果序列： 1 2 3 4 5 6 7 8第二题： 1 2 3 4 5 6 7 8 第一次排序： 1 2 3 4 5 6 7 [8] 第二次排序： 1 2 3 4 5 6 [7 8] 第三次排序： 1 2 3 4 5 [6 7 8] 第四次排序：1 2 3 4 [5 6 7 8] 第五次排序： 1 2 3 [4 5 6 7 8] 第六次排序： 1 2 [3 4 5 6 7 8] 第七次排序： 1 [2 3 4 5 6 7 8] 最后结果序列： 1 2 3 4 5 6 7 8]从练习题中引出：一次冒泡排序的结果：使关键字最大的记录排在了序列的最后一个位置上。

转发：C51数组的使用讲座数组也是能赋初值的。

在上面介绍的定义方式只适用于定义在内存 DATA 存储器使用的内存，有的时候我们需要把一些数据表存放在数组中，通常这些数据是不用在程序中改变数值的，这个时候就要把这些数据在程序编写时就赋给数组变量。

因为51芯片的片内 RAM 很有限，通常会把RAM 分给参与运算的变量或数组，而那些程序中不变数据则应存放在片内的CODE 存储区，以节省宝贵的RAM。

赋初值的方式如下：数据类型 [存储器类型] 数组名 [常量表达式] = {常量表达式};数据类型[存储器类型] 数组名 [ 常量表达式1]...... [ 常量表达式 N]={{ 常量表达式1}...{常量表达式N}};在定义并为数组赋初值时，开始学习的朋友一般会搞错初值个数和数组长度的关系，而致使编译出错。

初值个数必须小于或等于数组长度，不指定数组长度则会在编译时由实际的初值个数自动设置。

unsigned char LEDNUM[2]={12,35}; //一维数组赋初值int Key[2][3]={{1,2,4},{2,2,1}}; //二维数组赋初值unsigned char IOStr[]={3,5,2,5,3}; //没有指定数组长度，编译器自动设置unsigned char code skydata[]={0x02,0x34,0x22,0x32,0x21,0x12}; //数据保存在code 区下面的一个简单例子是对数组中的数据进行排序，使用的是冒泡法，一来了解数组的使用，二来掌握基本的排序算法。

冒泡排序算法是一种基本的排序算法，它每次顺序取数组中的两个数，并按需要按其大小排列，在下一次循环中则取下一次的一个数和数组中下一个数进行排序，直到数组中的数据全部排序完成。

#include <AT89X51.H>#include <stdio.h>void taxisfun (int taxis2[]){unsigned char TempCycA,TempCycB,Temp;for (TempCycA=0; TempCycA<=8; TempCycA++)for (TempCycB=0; TempCycB<=8-TempCycA; TempCycB++){ //TempCycB<8-TempCycA 比用TempCycB<=8 少用很多循环if (taxis2[TempCycB+1]>taxis2[TempCycB]) //当后一个数大于前一个数{Temp = taxis2[TempCycB]; //前后2 数交换taxis2[TempCycB] = taxis2[TempCycB+1];taxis2[TempCycB+1] = Temp; //因函数参数是数组名调用形参的变动影响实参}}}void main(void){int taxis[] = {113,5,22,12,32,233,1,21,129,3};char Text1[] = {"source data:"}; //"源数据"char Text2[] = {"sorted data:"}; //"排序后数据"unsigned char TempCyc;SCON = 0x50; //串行口方式1,允许接收TMOD = 0x20; //定时器1 定时方式2TCON = 0x40; //设定时器1 开始计数TH1 = 0xE8; //11.0592MHz 1200 波特率TL1 = 0xE8; TI = 1;TR1 = 1; //启动定时器printf("%s\n",Text1); //字符数组的整体引用for (TempCyc=0; TempCyc<10; TempCyc++)printf("%d ",taxis[TempCyc]);printf("\n----------\n");taxisfun (taxis); //以实际参数数组名taxis 做参数被函数调用printf("%s\n",Text2);for (TempCyc=0; TempCyc<10; TempCyc++) //调用后taxis 会被改变printf("%d ",taxis[TempCyc]);while(1);}例子中能看出，数组同样能作为函数的参数进行传递。

有关冒泡排序的总结
冒泡排序是一种简单但效率较低的排序算法，它重复地比较相邻的元素，并按照升序或降序交换位置，直到整个数组排序完成。

以下是对冒泡排序的总结：
1. 基本原理：冒泡排序的基本思想是通过相邻元素的比较和交换来实现排序。

每一轮排序会将未排序部分中的最大（或最小）元素冒泡到最后的位置。

2. 算法步骤：
- 从数组的第一个元素开始，比较相邻的两个元素。

- 如果顺序不正确，交换这两个元素的位置。

- 继续向后遍历，重复上述比较和交换的过程，直到最后一个元素。

- 重复以上步骤，直到所有元素都排好序。

3. 时间复杂度：冒泡排序的时间复杂度为O(n^2)，其中n 是待排序数组的元素个数。

最好情况下，如果待排序数组已经有序，冒泡排序可以通过设置一个标志位来提前结束，此时时间复杂度为O(n)。

4. 空间复杂度：冒泡排序的空间复杂度为O(1)，它只需要一个临时变量用于交换元素的位置。

5. 稳定性：冒泡排序是稳定的，即相等元素的相对位置在排序前后保持不变。

6. 优缺点：
- 优点：冒泡排序的实现简单，易于理解和实现。

- 缺点：冒泡排序的效率较低，尤其在处理大规模数据时。

它需要多次比较和交换操作，即使数组已经有序，也需要进行完整的遍历。

总而言之，冒泡排序是一种简单但效率较低的排序算法，适用于小规模的数据排序。

但在实际应用中，通常会选择更高效的排序算法，如快速排序、归并排序等。

c语言冒泡排序函数冒泡排序是常用的一种排序算法，它的原理是通过不断比较相邻的元素，将较大或较小的元素交换到正确的位置上。

在C语言中，我们可以通过编写冒泡排序函数来实现对数组的排序。

冒泡排序的函数一般包括两个参数，一个是待排序的数组，另一个是数组的长度。

函数的实现过程如下：1. 首先，我们需要两个嵌套的循环，外层循环用来控制比较的轮数，内层循环用来比较相邻的元素。

2. 内层循环比较相邻的元素，如果前一个元素比后一个元素大（或小），则交换它们的位置。

3. 每一轮比较结束后，最后一个元素已经排好序，因此下一轮比较时可以不再考虑它。

4. 当所有的比较结束后，数组就被排好序了。

以下是C语言中冒泡排序函数的示例代码：void bubble_sort(int arr[], int len){int i, j, temp;for (i = 0; i < len - 1; i++){for (j = 0; j < len - i - 1; j++){if (arr[j] > arr[j + 1]) // 如果前一个元素比后一个元素大，交换它们的位置{temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}}在上面的代码中，arr[]表示待排序的数组，len表示数组的长度。

我们首先定义了三个变量i、j和temp，分别用来控制循环、比较相邻元素和交换元素位置。

在外层循环中，i表示比较的轮数，循环次数为len-1，因为最后一个元素已经排好序了；在内层循环中，j表示相邻元素的位置，循环次数为len-i-1，因为每轮比较后，最后一个元素已经排好序了，不需要再考虑它。

在比较相邻元素时，如果前一个元素比后一个元素大，就交换它们的位置。

这里我们用temp变量来存储交换时的中间值。

最终，当所有的比较结束后，数组就被排好序了。

在实际使用时，我们可以将上面的冒泡排序函数封装到一个独立的模块中，然后在需要排序的地方引入该模块即可。

常用的c语言排序算法主要有三种即冒泡法排序、选择法排序、插入法排序。

一、冒泡排序冒泡排序：是从第一个数开始，依次往后比较，在满足判断条件下进行交换。

代码实现（以降序排序为例）#include<stdio.h>int main(){int array[10] = { 6,9,7,8,5,3,4,0,1,2 };int temp;for (int i = 0; i < 10; i++){//循环次数for (int j = 0; j <10 - i-1; j++){if (array[j] < array[j+1]){//前面一个数比后面的数大时发生交换temp = array[j];array[j] = array[j+1];array[j + 1] = temp;}}} //打印数组for (int i = 0; i < 10; i++) printf("%2d", array[i]); return 0;}}二、选择排序以升序排序为例：就是在指定下标的数组元素往后（指定下标的元素往往是从第一个元素开始，然后依次往后），找出除指定下标元素外的值与指定元素进行对比，满足条件就进行交换。

与冒泡排序的区别可以理解为冒泡排序是相邻的两个值对比，而选择排序是遍历数组，找出数组元素与指定的数组元素进行对比。

（以升序为例）#include<stdio.h>int main(){int array[10] = { 6,9,7,8,5,3,4,0,1,2 };int temp, index;for (int i = 0; i < 9; i++) {index = i;for (int j = i; j < 10; j++){if (array[j] < array[index])index = j;}if(i != index){temp = array[i]; array[i] = array[index]; array[index] = temp; }for(int i=0;i<10:i++) printf("%2d"array[i]）return 0；}三、快速排序是通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

《冒泡排序》作业一、选择题1. 冒泡排序的基本思想是什么？A. 将最大值放到数组的末尾B. 将最小值放到数组的开始C. 同时找到最大值和最小值并交换它们的位置D. 随机打乱数组元素的顺序答案：A解析：冒泡排序的基本思想是通过重复遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。

这个过程重复进行直到没有元素需要交换，也就是说该数列已经排序完成。

2. 冒泡排序的时间复杂度在最坏情况下是：A. O(1)B. O(log n)C. O(n)D. O(n^2)答案：D解析：冒泡排序在最坏情况下（即数组完全逆序时）的时间复杂度为O(n^2)，因为需要比较并交换相邻元素n(n-1)/2次。

3. 冒泡排序是一种什么类型的排序算法？A. 不稳定的排序算法B. 稳定的排序算法C. 原地排序算法D. 非原地排序算法答案：B解析：冒泡排序是一种稳定的排序算法，因为它不会改变相等元素的相对顺序。

4. 以下哪种情况最适合使用冒泡排序？A. 大规模数据集B. 小规模或基本有序的数据集C. 需要稳定排序的数据集D. A和C都适用答案：C解析：虽然冒泡排序不适用于大规模数据集，但在需要稳定排序的情况下，冒泡排序是一个不错的选择。

5. 冒泡排序在最好情况下的时间复杂度是：A. O(1)B. O(log n)C. O(n)D. O(n^2)答案：A解析：冒泡排序在最好情况下（即数组已经有序时）的时间复杂度为O(1)，因为不需要进行任何交换操作。

6. 冒泡排序的平均时间复杂度是：A. O(1)B. O(log n)C. O(n)D. O(n^2)答案：D解析：冒泡排序的平均时间复杂度为O(n^2)，但具体取决于输入数据的初始顺序。

二、填空题7. 冒泡排序的基本思想是重复地_______相邻的元素，如果它们的顺序错误就把它们交换过来。

答案：比较解析：冒泡排序通过重复地比较相邻的元素并交换它们（如果它们的顺序错误）来实现排序。

一、实验目的1. 熟悉数组的基本概念和操作方法。

2. 掌握数组的初始化、赋值、遍历、排序、查找等基本操作。

3. 培养编程思维和解决问题的能力。

二、实验内容本次实验主要围绕数组展开，包括以下内容：1. 数组的定义与初始化2. 数组元素的赋值与遍历3. 数组的插入与删除4. 数组的排序5. 数组的查找三、实验步骤1. 数组的定义与初始化（1）定义一个整型数组，命名为arr，大小为10。

（2）使用循环初始化数组元素，从0到9。

2. 数组元素的赋值与遍历（1）使用循环遍历数组，打印出每个元素的值。

（2）将数组的第5个元素赋值为20。

3. 数组的插入与删除（1）在数组的第3个位置插入一个新元素，值为15。

（2）删除数组的第6个元素。

4. 数组的排序（1）使用冒泡排序算法对数组进行排序。

（2）使用选择排序算法对数组进行排序。

5. 数组的查找（1）使用线性查找算法查找数组中值为15的元素。

（2）使用二分查找算法查找数组中值为15的元素。

四、实验结果与分析1. 数组的定义与初始化实验结果：成功定义了一个大小为10的整型数组arr，并使用循环初始化了数组元素。

分析：通过定义数组并初始化，我们可以存储一组有序或无序的数据，方便后续操作。

2. 数组元素的赋值与遍历实验结果：成功遍历了数组，并修改了数组的第5个元素。

分析：通过赋值和遍历操作，我们可以对数组元素进行修改和查询，满足实际应用需求。

3. 数组的插入与删除实验结果：成功在数组中插入了一个新元素，并删除了指定位置的元素。

分析：插入和删除操作可以改变数组的大小和元素顺序，满足实际应用场景。

4. 数组的排序实验结果：使用冒泡排序和选择排序算法对数组进行了排序。

分析：排序操作可以使数组元素按照特定顺序排列，便于后续查找和操作。

5. 数组的查找实验结果：使用线性查找和二分查找算法成功找到了数组中值为15的元素。

分析：查找操作可以快速定位到指定元素的位置，提高程序效率。

五、实验总结通过本次实验，我们掌握了数组的基本概念和操作方法，包括定义、初始化、赋值、遍历、插入、删除、排序和查找等。

计算机常见的32种算法在计算机科学领域，算法是指解决问题的一系列步骤和规则。

计算机常见的32种算法涵盖了不同领域的计算问题，包括排序、搜索、图算法和动态规划等。

以下是对这32种算法的简要介绍：1. 冒泡排序算法（Bubble Sort）：通过比较相邻元素并交换位置来排序一个数组。

2. 选择排序算法（Selection Sort）：依次从未排序部分选择最小元素，并将其放在已排序部分的末尾。

3. 插入排序算法（Insertion Sort）：将数组分为已排序和未排序两部分，依次将未排序元素插入已排序部分的正确位置。

4. 希尔排序算法（Shell Sort）：通过比较相距一定间隔的元素并进行交换来排序一个数组，最终逐渐减小间隔直至1。

5. 归并排序算法（Merge Sort）：将数组递归地拆分为较小的子数组，然后将这些子数组合并成有序数组。

6. 快速排序算法（Quick Sort）：选择一个基准元素，将数组分为比基准小和比基准大的两部分，然后递归地对这两部分进行排序。

7. 堆排序算法（Heap Sort）：构建一个二叉堆，并依次将堆顶元素与最后一个元素交换，然后重新调整堆。

8. 计数排序算法（Counting Sort）：统计数组中小于某个值的元素个数，并根据统计结果进行排序。

9. 桶排序算法（Bucket Sort）：将元素根据某个特征值放入不同的桶中，然后对每个桶中的元素进行排序。

10. 基数排序算法（Radix Sort）：按照每个元素的个位、十位、百位等进行排序，从最低有效位到最高有效位。

11. 二分搜索算法（Binary Search）：在有序数组中查找某个特定元素的位置。

12. 线性搜索算法（Linear Search）：顺序遍历数组，逐个比较元素直到找到目标元素。

13. 插值搜索算法（Interpolation Search）：根据目标元素在有序数组中的分布情况，通过估算目标元素的位置来进行搜索。

js中常见的数组排序算法-冒泡排序和选择排序reverse( ) 数组逆序// reverse() 数组逆序var arr = ["边境牧⽺⽝", "德国牧⽺⽝", "⾦⽑", "贵宾⽝", "柯基⽝"];arr.reverse();alert(arr);//柯基⽝,贵宾⽝,⾦⽑,德国牧⽺⽝,边境牧⽺⽝reverse 直接修改原数组。

sort() 排序按照字符串排序。

var arr = [5, 4, 1, 2, 3];var arr = [1, 20, 15, 10, 2];arr.sort();alert(arr); //1,10,15,2,20 按字符串排序（ASCLL码）还是从右往左⽐/*【注】排序，尽量⾃⼰去封装排序的⽅法，不要⽤官⽅给定的⽅法。

冒泡排序选择排序*/排序算法：1、冒泡排序// var arr = [9, 8, 7, 6, 5, 4];/*将上述数组，从⼩到⼤进⾏排序。

冒泡排序规则：前后两两进⾏⽐较，如果符合⽐较的条件，就交换两个数的位置，直到所有的数据，都符合从⼩到⼤条件，结束排序。

规律：每⼀轮⽐较，都会找出⼀个较⼤的数，放在正确的位置。

第⼀轮：9, 8, 7, 6, 5, 48, 9, 7, 6, 5, 48, 7, 9, 6, 5, 48, 7, 6, 9, 5, 48, 7, 6, 5, 9, 48, 7, 6, 5, 4, 9第⼆轮：8, 7, 6, 5, 47, 8, 6, 5, 47, 6, 8, 5, 47, 6, 5, 8, 47, 6, 5, 4, 8第三轮：7, 6, 5, 46, 7, 5, 46, 5, 7, 46, 5, 4, 7第四轮：6, 5, 45, 6, 45, 4, 6第五轮：5, 44, 5总结：⽐较的轮数 = 数组长度 - 1;每⼀轮⽐较的次数 = 数组长度 - 当前轮数根据总结写代码：1//决定⽐较⼏轮2for(var i = 0; i < arr.length - 1; i++){3//决定每⼀轮⽐较多少次4for(var j = 0; j < arr.length - i - 1; j++){5if(arr[j] > arr[j + 1]){6var tmp = arr[j];7 arr[j] = arr[j + 1];8 arr[j + 1] = tmp;9 }10 }11 }1213 alert(arr);//4,5,6,7,8,9我们在⽤的时候可以你把这段代码封装成函数，这样以后直接通过script标签的src属性调⽤，就可以了。