冒泡排序

1.简单描述冒泡排序 1.1什么是冒泡排序？ 冒泡排序是一种简单的排序方法，它的基本思想是：通过相邻两个元素之间的比较和交换，使较大的元素逐渐从前面移向后面（升序），就像水底下的气泡一样逐渐向上冒泡，所以被称为“冒泡”排序。 1.2逻辑图表示 1.3算法逻辑实现 2.简单描述快速排序 2.1什么是快速排序？ 快速排序(Quick Sort) 是对冒泡排序的一种改进方法，在冒泡排序中，进行元素的比较和交换是在相邻元素之间进行的，元素每次交换只能移动一个位置，所以比较次数和移动次数较多，效率相对较低。而在快速排序中，元素的比较和交换是从两端向中间进行的，较大的元素一轮就能够交换到后面的位置，而较小的元素一轮就能交换到前面的位置，元素每次移动的距离较远，所以比较次数和移动次数较少，速度较快，故称为“快速排序”。 2.2快速排序实现过程 2.3代码实现 来源： CSDN 作者： 迷茫小胖子 链接： https://blog.csdn.net/weixin_46102896/article/details/103785101

归并排序是冒泡排序的一种升级版排序，其灵魂是分治思想，在二分的基础上进行排序，可以将原来时间复杂度为O(n^2)的冒泡排序降低为O(nlogn)的归并排序。 下面我们先来看归并排序，之后再来讲归并排序的应用—求逆序数 归并排序 前面提到，归并排序采用的是二分思想，我们先把一段需要排序的序列分成两半，是不是每一段的交换次数就会变少，然后我们又将分成的两段，继续分成四段，以此类推，直到分到每一段只有一个数的时候，就可以停止，接下来就是分治的–“治” 我们把它们拆开之后，就依次合上来，原来一个数合成两个数，在合的时候又进行比较大小，这样效率会提高很多，最终实现整个序列的排序。 看这张图，可以更好的理解： 下面看一下具体的代码实现 int gb [ 100001 ] ; //临时数组 void mers ( int * a , int s , int mid , int end ) //治（合） { int k = s ; int i = s , j = mid + 1 ; while ( i <= mid && j <= end ) { if ( a [ i ] <= a [ j ] ) { gb [ k ++ ] = a [ i ] ; i ++ ; } else { gb [ k ++ ] = a [ j ] ; j ++ ; } } while ( i <= mid ) { gb

例1，输出最大值 #include <iostream> #include <iomanip> using namespace std; int main(void) { int a[2][3] = { { 15,34,23 },{ 54,27,65 } }; // 二维数组 int i, j, k; int row, col; int max = 0; for (i = 0; i <= 1; i++) for (j = 0; j <= 2; j++) { cout << setw(4) << a[i][j]; if (j == 2) cout << endl; } cout << " *********************** " << endl; for (i = 0; i <= 1; i++) for (j = 0; j <= 2; j++) { if (max < a[i][j]) { max = a[i][j]; row = i+1; col = j+1; } } cout << "The bigger number is:" << max << endl; cout << "row=" << row << "," << "col=" << col << endl; return 0; } ---------------------------------------

首先我们要理解排序的定义： 冒泡排序（Bubble sort）：相邻的两个数逐个的做比较，如果前一个数比后一个数小那么就交换过来，当第一轮比较完毕之后 最小的值 一定在 末尾 我们可以先画出以一张图： 数组两个相邻的值去比较后面的数大于前面的数就会去交换，因此每轮比较后最小值都会出现在这次比较的最后一位 第二次比较： 第三次比较： 第四次比较： 好了，上面就是我们模拟计算机去比较一个数组；既然我们知道了如何去比较数组 那么我们该如何去编写代码，让计算机会自动去比较呢？ 这就要发挥我们自己的创造能力以及独特的思维，言归正传，我们到底该如何写出这个冒泡排序呢？ 接下来就由我就来简单的演示一下吧！ 例子1： 这个就是最简单的交换方法 我们看到这个方法： Q：第一个for循环为什么从1开始，以及为什么是这个循环条件？ A：从1开始是因为外层循环代表的是比较轮数，不可能有第0轮这个东西把 循环条件是由上面的表格观察而出来的，比较轮数是小于这个数组的长度的 Q：第二个for循环从为什么从0开始，以及这个循环条件 A：因为第二个循环代表的是每一轮比较的次数，从0开始是也代表要交换的索引 既然我们知道了这个循环代表的是比较次数，从上面的表格中可以得出这么一个结论 交换次数 = 数组长度 - 当前轮数 因为是从0开始的所以就要小于这个值，这就是我们的循环条件

所谓数组，就是相同数据类型的元素按一定的顺序排列的集合，就是把有限个数据类型相同的变量用一个名字命名，然后用编号区分她们的变量的集合，这个名称就叫数组名，编号称为下标。 组成数组的各个变量称为数组的分量或元素。 数组中元素的索引是从0开始的，也就是a【0】，a【1】。。。。。。。 引用一下：冒泡排序 冒泡排序算法的运作如下： 　　比较相邻的元素 。如果第一个比第二个大，就 交换 他们两个。 　　对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。 　　针对所有的 元素 重复以上的步 骤，除了最后一个。 　　持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。 例子为从小到大排序, 原始待排序数组| 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 |

bubble sort ,一种基础的交换排序。 思想 ：相邻元素两两比较，当一个元素大于右侧相邻元素时，交换它们的位置；当一个元素小于或等于右侧相邻元素时，位置不变。 using System; namespace CSharpTest01 { class Program { /// <summary> /// 冒泡排序 /// sortBorder 有序区标记 /// </summary> static void BubbleSort(int[] array) { // 记录最后一次交换的位置 int lastExchangeIndex = 0; // 无序数列的边界，每次比较只需要比到这里为止 int sortBorder = array.Length - 1; for (int i = 0; i < array.Length-1; i++) { // 有序标记，每一轮的初始值都是true bool isSorted = true; for (int j = 0; j < sortBorder; j++) { int temp = 0; if(array[j] > array[j + 1]) { temp = array[j]; array[j] = array[j + 1]; array[j + 1] = temp; // 因为有元素进行交换，所以不是有序的，标记为false

本周情况 本周学习了Java中的数组,主要学习了一维数组,包括其定义,初始化格式以及动态赋值数组,同时学习利用数组进行查找,冒泡排序以及选择排序 学习内容 1.一维数组的查找 在Java中一维数组的定义格式通常为: 变量类型[] 变量名 = new 变量类型[数组长度] 与C语言不同的是,在Java中当初始化数组时不能直接写出数组长度,如 int array[5]={0,1,2,3,4}; 则会报错,正确的应写作: int[] array = new int[5]; array[]={0,1,2,3,4}; 通过利用 final 变量类型 N = 数值 对数组长度进行定义(有点类似C语言中的宏定义),例如: final int N = 10; int[] array = new int[N]; 这样定义可以使得当我们改变整个代码中的N值变得更加方便,且使得代码更具专业性 同时掌握了产生随机数的方法,如产生0-1000的随机数,** (int)(Math.random() 1000 *,通过随机数可以产生随机数组 下面是查找随机数组中元素的最大值与最小值的一个练习: 代码部分: 运行结果: 代码中searcharray.length表示数组的长度,这样写显得更加专业(哈哈,虽然是初学者,但这样写感觉确实很6…) 另一个练习,用户输入并在数组中查找该元素,且输出该元素的下标

冒泡排序（Selection Sort） 原理 ：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。 工具类 public class Utils { //打印数组 static void printArr ( int [ ] arrs ) { for ( int x : arrs ) { System . out . print ( x + " " ) ; } } //用于交换数组两个下标的位置 static void swap ( int [ ] arrs , int x , int y ) { int temp = arrs [ x ] ; arrs [ x ] = arrs [ y ] ; arrs [ y ] = temp ; } } 逻辑代码 public class BubbleSort { public static void main ( String [ ] args ) { int [ ] arrs = { 3 , 44 , 38 , 5 , 47 , 15 , 36 , 26 , 27 , 2 , 46 , 4 , 19 , 50 , 48 } ; int len = arrs . length ; for (

复习选择排序法： https://blog.csdn.net/tq_1999/article/details/99437935 参考： https://blog.csdn.net/chao_shine/article/details/88380597 冒泡排序基本思想： 两两交换，每次排序将最大值放后面，最小值放前面。 当i=1时，要两两比较7次，即n-1次。才能8个数中取出最大值。 数值 8 7 6 5 4 3 2 1 7 8 6 5 4 3 2 1 7 6 8 5 4 3 2 1 7 6 5 8 4 3 2 1 7 6 5 4 8 3 2 1 7 6 5 4 3 8 2 1 7 6 5 4 3 2 8 1 7 6 5 4 3 2 1 8 当i=2时，要两两比较6次，即n-2次。才能7个数种取出最大值。 数值 7 6 5 4 3 2 1 6 7 5 4 3 2 1 6 5 7 4 3 2 1 6 5 4 7 3 2 1 6 5 4 3 7 2 1 6 5 4 3 2 7 1 6 5 4 3 2 1 7 依次类推，一共要遍历8会，即n回。 #include<stdio.h> void bubble(int a[ ],int n); //a是等待排序的整形数组名，n数组a待处理的数组元素的数量。 int main() { int n,a[8]; int i; printf(

$arr = [4,6,11,22222,125,123,555]; $len = count($arr); for ($i=0;$i<$len;$i++) { for ($j=$i;$j<$len-1;$j++){ if ( $arr[$j] > $arr[$j+1] ) { $val = $arr[$j]; $arr[$j] = $arr[$j+1]; $arr[$j+1] = $val; } } } print_r($arr); $arr = [4,6,11,22222,125,123,555]; $len = count($arr); for ($i=0;$i<$len;$i++) { $flag = false; for ($j=$i;$j<$len-1;$j++){ if ( $arr[$j] > $arr[$j+1] ) { $val = $arr[$j]; $arr[$j] = $arr[$j+1]; $arr[$j+1] = $val; //如果发生交换 则改变为true $flag = true; } } //如果没有改变 则说明是一个有序的数组 直接跳出循环就好 if ( $flag == false ) { break; } } print_r($arr); 冒泡排序本质是比较相邻的两个数字，看是否满足大小关系，如果不满足，则进行互换