冒泡排序

No.1 冒泡排序 冒泡排序无疑是最为出名的排序算法之一，从序列的一端开始往另一端冒泡（你可以从左往右冒泡，也可以从右往左冒泡，看心情），依次比较相邻的两个数的大小（到底是比大还是比小也看你心情）。 冒泡排序动图演示 图解冒泡排序 以 [ 8，2，5，9，7 ] 这组数字来做示例，上图来战： 从左往右依次冒泡，将小的往右移动 冒泡排序1 首先比较第一个数和第二个数的大小，我们发现 2 比 8 要小，那么保持原位，不做改动。位置还是 8，2，5，9，7 。 指针往右移动一格，接着比较： 冒泡排序2 比较第二个数和第三个数的大小，发现 2 比 5 要小，所以位置交换，交换后数组更新为：[ 8，5，2，9，7 ]。 指针再往右移动一格，继续比较： 冒泡排序3 比较第三个数和第四个数的大小，发现 2 比 9 要小，所以位置交换，交换后数组更新为：[ 8，5，9，2，7 ] 同样，指针再往右移动，继续比较： 冒泡排序4 比较第 4 个数和第 5 个数的大小，发现 2 比 7 要小，所以位置交换，交换后数组更新为：[ 8，5，9，7，2 ] 下一步，指针再往右移动，发现已经到底了，则本轮冒泡结束，处于最右边的 2 就是已经排好序的数字。 通过这一轮不断的对比交换，数组中最小的数字移动到了最右边。 接下来继续第二轮冒泡： 冒泡排序5 冒泡排序6 冒泡排序7 由于右边的 2 已经是排好序的数字

1.1 原始人冒泡排序 function bubbleSort(arr) { 　　var len = arr.length; 　　for (var i = 0; i < len; i++) { 　　　　for (var j = 0; j < len - 1 - i; j++) { 　　　　　　if (arr[j] > arr[j+1]) { //相邻元素两两对比 　　　　　　　　var temp = arr[j+1]; //元素交换 　　　　　　　　arr[j+1] = arr[j]; 　　　　　　　　arr[j] = temp; 　　　　　　} 　　　　} 　　} 　　return arr; } var arr=[3,44,38,5,47,15,36,26,27,2,46,4,19,50,48]; console.log(bubbleSort(arr));//[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50] ； 这种算法不多说，有点变成基础的人都能看明白，可以说是“傻瓜排序” 1.2进化版冒泡排序 function bubbleSort2(arr) { 　　console.time('改进后冒泡排序耗时'); 　　var i = arr.length-1; //初始时,最后位置保持不变　　 　　while ( i>

一、冒泡排序 所谓的冒泡排序，其实指的是对数组中的数据进行排序，按照从小到大的顺序来进行排列. 它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果他们的顺序（如从大到小、首字母从A到Z）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。 void main() { int i,j,temp=0; int a[8] = {6,4,8,2,5,3,7,1}; int arrysize = sizeof(a)/sizeof(a[0]); for(i=0;i<arrysize;i++) { for(j=0;j<arrysize-i-1;j++) { if(a[j] > a[j+1]) { temp = a[j]; a[j] = a[j+1]; a[j+1] = temp; } } } for(i=0;i<arrysize;i++) { printf("%d ",a[i]); } } 二、 选择排序（Selection Sort） 算法原理 选择排序(Selection-sort)是一种简单直观的排序算法。 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。 void SelectionSort(int

冒泡排序的概念： 冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。 它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。 这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。 冒泡排序算法的原理如下： 比较相邻的元素。如果第一个比第二个大，就交换他们两个。 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。 针对所有的元素重复以上的步骤，除了最后一个。 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较 冒泡排序流程图： 冒泡排序动态图： 时间复杂度 若文件的初始状态是正序的，一趟扫描即可完成排序。所需的关键字比较次数 和记录移动次数 均达到最小值： 所以，冒泡排序最好的时间复杂度为 O(n) 。 若初始文件是反序的，需要进行 趟排序。每趟排序要进行 次关键字的比较(1≤i≤n-1)，且每次比较都必须移动记录三次来达到交换记录位置。在这种情况下，比较和移动次数均达到最大值： 冒泡排序的最坏时间复杂度为 O(n^2) 。 综上

冒泡排序||Bubble Sort 自我学习总结之冒泡排序(bubble sort) what？ 这个算法的名字由来是因为越小/大的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序” 摆原理 1、从第一个元素开始，比较相邻的元素。如果第一个比第二个大，就交换他们两个。 2、对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。此时，最后的元素应该会是最大的数。 3、针对所有的元素重复以上的步骤，除了最后排好的元素。 4、重复以上步骤，知道所有元素有序。 假如现有数组： int [ ] array = new int [ ] { 9 , 8 , 7 , 6 , 5 , 4 , 3 , 2 , 1 , 0 } ; 经过冒泡排序： 第 0 次排序 : 9 8 7 6 5 4 3 2 1 0 第 1 次排序 : 8 7 6 5 4 3 2 1 0 9 第 2 次排序 : 7 6 5 4 3 2 1 0 8 9 第 3 次排序 : 6 5 4 3 2 1 0 7 8 9 第 4 次排序 : 5 4 3 2 1 0 6 7 8 9 第 5 次排序 : 4 3 2 1 0 5 6 7 8 9 第 6 次排序 : 3 2 1 0 4 5 6 7 8 9 第 7 次排序 : 2 1 0 3 4 5 6 7 8 9 第 8

文章目录 1. 冒泡排序介绍 2. 冒泡排序规则 3. 基本冒泡排序实例 4. 冒泡排序优化 1. 冒泡排序介绍 2. 冒泡排序规则 3. 基本冒泡排序实例 冒泡排序原理： ublic class BubbleSort { public static void main ( String [ ] args ) { int arr [ ] = { 3 , 9 , - 1 , 10 , - 2 } ; //第一趟排序就是把最大的数排在后面 int temp = 0 ; for ( int i = 0 ; i < arr . length - 1 ; i ++ ) { //如果前面的数比后面的数大就交换 if ( arr [ i ] > arr [ i + 1 ] ) { temp = arr [ i ] ; arr [ i ] = arr [ i + 1 ] ; arr [ i + 1 ] = temp ; } } System . out . println ( "第一趟排序后的数组：" + Arrays . toString ( arr ) ) ; //第二趟排序就是把第二大的数据排在倒数第二位 for ( int i = 0 ; i < arr . length - 1 - 1 ; i ++ ) { //如果前面的数比后面的数大就交换 if ( arr [ i ] > arr [

最常用的排序——快速排序 假设我们现在对“6 1 2 7 9 3 4 5 10 8”这 10个数进行排序。首先在这个序列中随 便找一个数作为 基准数 （不要被这个名词吓到了，这就是一个用来参照的数，待会儿你就知 道它用来做啥了）。为了方便，就让第一个数 6 作为基准数吧。接下来，需要将这个序列中 所有比基准数大的数放在 6的右边，比基准数小的数放在 6的左边，类似下面这种排列。 3 1 2 5 4 6 9 7 10 8 在初始状态下，数字 6在序列的第 1位。我们的目标是将 6挪到序列中间的某个位置， 假设这个位置是 k。现在就需要寻找这个 k，并且以第 k位为分界点，左边的数都小于等于 6， 右边的数都大于等于 6。想一想，你有办法可以做到这点吗？ 给你一个提示吧。请回忆一下冒泡排序是如何通过“交换”一步步让每个数归位的。此时你也可以通过“交换”的方法来达到目的。具体是如何一步步交换呢？方法其实很简单：分别从初始序列“6 1 2 7 9 3 4 5 10 8”两端开始“探测”。先从 右往左找一个小于 6的数，再从左往右找一个大于 6的数，然后交换它们。这里可以用两个 变量 i和 j，分别指向序列左边和右边。我们为这两个变量起个好听的名字“哨兵 i”和 “哨兵 j”。刚开始的时候让哨兵 i指向序列的左边（即 i=1），指向数字 6。让哨兵 j指向序 列的右边（即 j=10）

冒泡排序基础用法 　　 import java.util.Arrays; public class BubbleSort { public static void main(String[] args) { int[] array = new int[] {5,8,6,3,9,2,1,7}; sort(array); System.out.println(Arrays.toString(array)); } public static void sort(int array[]){ for (int i = 0; i < array.length-1; i++) { for (int j = 0; j < array.length - i - 1; j++) { int tmp=0; if (array[j]>array[j+1]){ tmp=array[j]; array[j]=array[j+1]; array[j+1]=tmp; } } } } } 冒泡排序优化第二版 　　与第一版代码相比，第二版代码做了小小的改动，利用一个Boolean作为标记。如果在本轮排序中，元素有交换，则说明数列无序；如果没有元素交换，则说明数列已经有序，然后直接跳出大循环。 import java.util.Arrays; public class GoodBubbleSort { public

冒泡排序：废话不多说，直接上代码，注意2中冒泡方法的不同。 package com.sqtds.algorithm.sort;/** * User: sqtds * Date: 13-1-15 * Time: 下午3:03 */public class Bubble { public static void sort(int[] array){ int i ,j ; for (i =0 ; i< array.length ; i++){ for(j=i ; j<array.length ; j++){ if(array[i]>array[j]){ swap(array,i,j); } } } } public static void swap(int[] array , int left , int right){ int temp = array[left]; array[left] = array[right]; array[right] = temp; } public static void BubbleSort(int[] array) { //R（l..n)是待排序的文件，采用自下向上扫描，对R做冒泡排序 int i,j,t; Boolean exchange; //交换标志 for(i=0;i<array.length;i++){ //最多做n-1趟排序

一.冒泡排序： 外层循环控制排序躺数： n个数需要跑n-1躺， 一个数组的长度为length，那么下标为length-1，那么最大趟数为length-2，即写为<length-1 //因为比较剩下最后一个数时，无需比较。 内层循环控制每一趟的比较次数： 每一趟需要比较n-i次 /* * 冒泡排序 */ public class BubbleSort { 　　public static void main(String[] args) { 　　　　int[] arr={6,3,8,2,9,1}; 　　　　System.out.println("排序前数组为："); 　　　　for(int num:arr){ 　　　　　　System.out.print(num+" "); 　　　　} 　　　　for(int i=0;i<arr.length-1;i++){//外层循环控制排序趟数 　　　　　　for(int j=0;j<arr.length-1-i;j++){//内层循环控制每一趟排序多少次 　　　　　　　　if(arr[j]>arr[j+1]){ 　　　　　　　　　　int temp=arr[j]; 　　　　　　　　　　arr[j]=arr[j+1]; 　　　　　　　　　　arr[j+1]=temp; 　　　　　　　　} 　　　　　　} 　　　　} 　　　　System.out