冒泡排序

快速排序算法 想必大多数程序员接触的第一种排序算法是冒泡排序，冒泡排序的特点是：逻辑简单，实现起来也不难，但在数据量比较大的时候性能比较低。 以数字由大到小的排序为例，写一个简单的冒泡排序。 /** * 冒泡排序 * Created by Administrator on 2017/4/4. */ public class BubblingSortArithmetic { /** * 冒泡排序实现 * @param array */ public static void bubblingSort(int[] array){ int temp; for (int i = 0; i < array.length-1; i++) { for (int j = 0; j < array.length-i-1; j++) { if(array[j] > array[j+1]){ temp = array[j]; array[j] = array[j+1]; array[j+1] = temp; } } } } } 我们看到，冒泡排序就是两个for循环嵌套，内层循环再加一个if语句做逻辑判断。 通俗点解释冒泡排序就是：外层循环控制冒泡的趟数（数组长度-1），内层循环控制一趟冒泡过程中数组相邻两个元素的比较次数及最大索引位，并且一趟冒泡把这次排序中最大的那个数放到最大索引位处。

# BubbleSort冒泡排序 def bubble_sort(li): for i in range(len(li) - 1): # len为个数, range_len为所有元素下标 range(len-1)为冒泡次数,冒泡次数为元素个数-1 for j in range(len(li) - i - 1): # 此处-i 能够避免继续遍历已经排列好的次序 if li[j] >= li[j + 1]: li[j], li[j + 1] = li[j + 1], li[j] return li list = [1, 55, 98984, 65, 165, 356, 54, 3, 645, 74, 64, 32, 15, 22, 7481, 4, 65] li = bubble_sort(list) print(li) 　　 冒泡排序的特征: 双遍历. 遍历i , 对比i 和 i+1 的值 如果前者大于后者则交换两者位置 第一次遍历后, 最大的排在最后. 下次遍历时候, 总位数减去已排列位数.在剩余的位数中找最大放在最后. 冒泡排序不需要定义变量 来源： https://www.cnblogs.com/jrri/p/12099914.html

数组是一种复合类型，声明形如a[x]，a是数组名，x是数组维度。数组的特性是内存连续，类型相同，它的类型基本涵盖c++大部分类型，其数组名既是内存首地址又是数组标识符，而长度表达式要求是常量，这在形参作表达式时很关键。 int a[1]; 一维数组一维数组是由数字组成的以单纯的排序结构排列的结构单一的数组。 一维数组是计算机程序中最基本的数组。 格式一维数组的的三种定义方式： 数据类型 数组名[数组长度] 数据类型 数组名[数组长度] = {值1， 值2， 值3} 数组类型 数组名[] = {值1， 值2， 值3…}数据类型 数组名[数组长度]int arr[5];arr[0] = 10;arr[1] = 20;arr[2] = 30;arr[3] = 40;// 访问数组元素cout << arr[0] << endl;cout << arr[0] << endl; 4.引用若 i， j均为int型变量，则a[i],a[j],a[i+j],a[i*j],a[j++]等都是合法元素。数组不可以一次引用一整个数组，如int a[100],b[100]; a=b;这是不合法的引用方式。若要将数组a每一个元素的值赋值给b数组的对应元素，可以利用循环。for(int i=0){b[i]=a[i];} 5.越界问题注意a[100]的下标为0-99，定义时最好定义大一些，通常比要用的多一个

$arr = [100,3,5,6,90,10]; for($i=0;$i<count($arr)-1;$i++){ for($j=0;$j<count($arr)-$i-1;$j++){ if($arr[$j] > $arr[$j+1]){ $tmp = $arr[$j]; $arr[$j]=$arr[$j+1]; $arr[$j+1]=$tmp; } } } print_r($arr); 　　 来源： https://www.cnblogs.com/zh718594493/p/12089223.html

冒泡排序 一、画图理解 二、代码实现 #include<stdio.h> #include<Windows.h> void BubbleSort(int *a, int num) { int i = 0; for (i = 0; i < num - 1; i++)//num-1轮 { int j = 0; for (j = 0; j <num - 1 - i; j++)//每轮中有num-1-i趟 { if (a[j] > a[j + 1])//升序，若是想降序，变成<即可 { int temp = a[j]; a[j] = a[j + 1]; a[j + 1] = temp; } } } for (int k = 0; k < num; k++) { printf("%d ", a[k]); } printf("\n"); } int main() { int a[] = { 23, 45, 5, 7, 98, 6, 34, 98, 45 }; int num = sizeof(a) / sizeof(a[0]); BubbleSort(a, num); system("pause"); return 0; } 三、代码优化 问题：若是输入的数据是有序的时候，代码也会从头到尾执行一遍，但是这样的话，代码的效率就不高，那么，有没有什么办法可以改变这种现象呢？ 原理

一、介绍 冒泡排序(Bubble Sort)，又被称为气泡排序或泡沫排序。 它是一种较简单的排序算法。它会遍历若干次要排序的数列，每次遍历时，它都会从前往后依次的比较相邻两个数的大小；如果前者比后者大，则交换它们的位置。这样，一次遍历之后，最大的元素就在数列的末尾！ 采用相同的方法再次遍历时，第二大的元素就被排列在最大元素之前。重复此操作，直到整个数列都有序为止！ 二、图文说明 下面以数列{20,40,30,10,60,50}为例，演示它的冒泡排序过程(如下图)。 我们先分析第1趟排序 当i=5,j=0时，a[0]<a[1]。此时，不做任何处理！ 当i=5,j=1时，a[1]>a[2]。此时，交换a[1]和a[2]的值；交换之后，a[1]=30，a[2]=40。 当i=5,j=2时，a[2]>a[3]。此时，交换a[2]和a[3]的值；交换之后，a[2]=10，a[3]=40。 当i=5,j=3时，a[3]<a[4]。此时，不做任何处理！ 当i=5,j=4时，a[4]>a[5]。此时，交换a[4]和a[5]的值；交换之后，a[4]=50，a[3]=60。 于是，第1趟排序完之后，数列{20,40,30,10,60,50}变成了{20,30,10,40,50,60}。此时，数列末尾的值最大。 根据这种方法： 第2趟排序完之后，数列中a[5...6]是有序的。 第3趟排序完之后

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。 说明： 你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？ 示例 1: 输入: [2,2,1] 输出: 1 示例 2: 输入: [4,1,2,1,2] 输出: 4 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/single-number 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 int singleNumber ( int * nums , int numsSize ) { int i , j , t = 0 ; unsigned int count = 0 ; unsigned char finish_flag = 0 ; for ( i = 0 ; i < numsSize ; i ++ ) { finish_flag = 0 ; for ( j = numsSize - 1 ; j > i ; j -- ) { count ++ ; if ( nums [ j ] < nums [ j - 1 ] ) { t = nums [ j ] ; nums [ j ] = nums [ j - 1 ] ; nums [ j - 1 ] = t ; finish_flag = 1 ;

# include <stdio.h> void sort(int * a, int len) { 　　int i, j, t; 　　//进行len次循环，实现len次比较。 　　for (i=0; i<len-1; ++i) 　　{ 　　　　//在len次循环中实现len-1次比较。 　　　　for (j=0; j<len-1-i; ++j) 　　　　{ 　　　　　　// >表示升序 <表示降序，对相邻两个数字进行比较。 　　　　　　if (a[j] > a[j+1]) 　　　　　　{ 　　　　　　　　t = a[j]; 　　　　　　　　a[j] = a[j+1]; 　　　　　　　　a[j+1] = t; 　　　　　　} 　　　　} 　　} } int main(void) { 　　//定义整形变量 i 和整形数组 a。 　　int i; 　　int a[20]; 　　printf("请随即输入20个数字\r\n"); 　　//通过循环实现给数组赋值。 　　for (i=0; i<20; i++) 　　{ 　　　　scanf("%d", &a[i]); 　　} 　　//调用 sort 函数。 　　sort(a, 20); 　　printf("排序后输出结果\r\n"); 　　//对已经排好序的数字进行输出。 　　for (i=0; i<20; ++i) 　　{ 　　　

冒泡 排序算法 的原理如下： 比较相邻的元素。如果第一个比第二个大，就交换他们两个。 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。 针对所有的元素重复以上的步骤，除了最后一个。 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。 代码实现： public class BubbleSort { public static void main(String[] args) { int arr[] = { 32, 2, 34, 41, 25, 5, -9 }; System.out.println("排序前：" + Arrays.toString(arr)); for (int i = 0; i < arr.length; i++) { boolean flag = false; for (int j = 0; j < arr.length - 1 - i; j++) { int temp = 0; if (arr[j] > arr[j + 1]) { temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; flag = true; } } if (flag == false) { break; } } System.out.println("排序后：" +

Java面试中一般都会遇到让你手写三大排序伪代码的场景。 java排序分四类 1、插入排序 直接插入排序 希尔排序 2、交换排序 冒泡排序 快速排序 3、选择排序 简单选择排序 堆排序 快速排序 4、归并排序 面试中，我们面得最多的应该要数冒泡排序了，我们就先来讲讲冒泡排序。 正常情况下，我们进行伪代码的编写，或者需要在电脑上敲出来，冒泡排序是比较经典的排序：下面我们简单实现一下： 我将时间运行时间打印了出来，可能是由于数据量比较少的原因，时间ms显示不出来，我选择单位为ns，可以直观的看出来排序算法效率对比。 publicstaticvoidmain(String[] args){ int[] arr = {1,3,4,2,6,7,8,0,5}; inti =0; inttmp =0; longstartTime = System.nanoTime();// 获取开始时间 for(i =0; i < arr.length -1; i++) { // 确定排序趟数 intj =0; for(j =0; j < arr.length -1- i; j++) { // 确定比较次数 if(arr[j] > arr[j +1]) { // 交换 tmp = arr[j]; arr[j] = arr[j +1]; arr[j +1] = tmp; } } } longendTime =