java之冒泡排序(Bubble sort)

主要内容是摘自别人的,但是发现示例代码有错,故内容复制,代码修改。

原理:临近的数字两两进行比较,按照从小到大(从大到小)进行交换,这样一趟过去后,最大或最小的数字被交换到了最后一位;

   然后再从头开始进行两两比较交换,直到倒数第二位时结束(因为由第一遍排序得知已经把最大(小)数排到末尾了);

   接着再从头开始进行两两比较交换,直到倒数第三位时结束(因为由第一遍排序得知已经把最大(小)数排到末尾了,第二遍把第二大(小)的数排到倒数第二位了);

   循环直到排完序。

   例子为从小到大排序,

   原始待排序数组| 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 | 5 | 9 |

  第四次两两比较,6 > 5交换

   交换前状态| 2 | 4 | 1 | 6 | 5 | 9 |

   交换后状态| 2 | 4 | 1 | 5 | 6 | 9 |

  第五次两两比较,6 < 9不交换

   交换前状态| 2 | 4 | 1 | 5 | 6 | 9 |

   交换后状态| 2 | 4 | 1 | 5 | 6 | 9 |

第二趟排序(外循环)

  第一次两两比较2 < 4不交换

   交换前状态| 2 | 4 | 1 | 5 | 6 | 9 |(已经知道最大)

   交换后状态| 2 | 4 | 1 | 5 | 6 | 9 |

  第二次两两比较,4 > 1交换

   交换前状态| 2 | 4 | 1 | 5 | 6 | 9 | 
   交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

   第三次两两比较,4 < 5不交换

   交换前状态| 2 | 1 | 4 | 5 | 6 | 9 | 
   交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

   第四次两两比较,5 < 6不交换

   交换前状态| 2 | 1 | 4 | 5 | 6 | 9 |

   交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

 第三趟排序(外循环)

  第一次两两比较2 > 1交换

   交换前状态| 2 | 1 | 4 | 5 | 6 | 9 |

   交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |

  第二次两两比较,2 < 4不交换

   交换前状态| 1 | 2 | 4 | 5 | 6 | 9 | 
   交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |

  第三次两两比较,4 < 5不交换

   交换前状态| 1 | 2 | 4 | 5 | 6 | 9 | 
   交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |

第四趟排序(外循环)无交换

   第一次两两比较1<2不交换   

   交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |

   第一次两两比较2<4不交换   

   交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |

第五趟排序(外循环)无交换

  第一次两两比较1<2不交换   

   交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |

原:| 1 | 2 | 4 | 5 | 6 | 9 |

一:| 1 | 2 | 4 | 5 | 6 | 9 |

二:| 1 | 2 | 4 | 5 | 6 | 9 |

三:| 1 | 2 | 4 | 5 | 6 | 9 |

四:| 1 | 2 | 4 | 5 | 6 | 9 |

五:| 1 | 2 | 4 | 5 | 6 | 9 |

排序完毕,输出最终结果1 2 4 5 6 9

 1 /*
 2 By starainDou
 3 */
 4 public class Hello {
 5     public static void main(String args[]){
 6         int []num = {6,2,4,1,5,9};
 7         for(int i = 0;i<num.length - 1;i++){
 8             for(int j = 0; j<num.length-1-i;j++){
 9                     if(num[j]>num[j+1]){
10                         int temp = num[j];
11                         num[j] = num[j+1];
12                         num[j+1] = temp;
13                     }
14             }
15         }
16     for(int n = 0; n < num.length; n ++){
17         System.out.print(num[n]+"\t");
18         }
19     }
20 }

在此感谢原作者

时间: 2024-10-14 06:50:40

java之冒泡排序(Bubble sort)的相关文章

Java中的经典算法之冒泡排序(Bubble Sort)

Java中的经典算法之冒泡排序(Bubble Sort) 原理:比较两个相邻的元素,将值大的元素交换至右端. 思路:依次比较相邻的两个数,将小数放在前面,大数放在后面.即在第一趟:首先比较第1个和第2个数,将小数放前,大数放后.然后比较第2个数和第3个数,将小数放前,大数放后,如此继续,直至比较最后两个数,将小数放前,大数放后.重复第一趟步骤,直至全部排序完成. 举例说明:要排序数组:int[] arr={6,3,8,2,9,1}; 第一趟排序: 第一次排序:6和3比较,6大于3,交换位置:  

java冒泡排序Bubble Sort算法代码

java冒泡排序Bubble Sort算法代码 下载代码地址:http://www.zuidaima.com/share/1550463269096448.htm package com.zuidaima.util; /** *冒泡排序 *@paramsrc待排序数组 *@author www.zuidaima.com */ void doBubbleSort(int[] src) { int len=src.length; for(int i=0;i<len;i++) { for(int j=

经典排序算法 - 冒泡排序Bubble sort

 原文出自于 http://www.cnblogs.com/kkun/archive/2011/11/23/bubble_sort.html 经典排序算法 - 冒泡排序Bubble sort 原理是临近的数字两两进行比较,按照从小到大或者从大到小的顺序进行交换, 这样一趟过去后,最大或最小的数字被交换到了最后一位, 然后再从头开始进行两两比较交换,直到倒数第二位时结束,其余类似看例子 例子为从小到大排序, 原始待排序数组| 6 | 2 | 4 | 1 | 5 | 9 | 第一趟排序(外循环) 第

经典排序算法(1) - 冒泡排序Bubble Sort

冒泡排序(Bubble Sort)是一种简单的排序算法.它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来.走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成.这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端.运作步骤如下: 比较相邻的元素.如果第一个比第二个大,就交换他们两个. 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对.在这一点,最后的元素应该会是最大的数. 针对所有的元素重复以上的步骤,除了最后

冒泡排序(Bubble Sort)

常见的排序算法有Bubble Sort.Merge Sort.Quick Sort 等,所有排序算的基本法思想都是把一个无限大的数据规模通过算法一步步缩小,指导最后完成排序. 这里分享一下Buuble Sort算法,php版本的.冒泡排序不适合在待排序的数据集特别大的情况下,这里只是一个简易的demo,待排序的数据在10以内. 冒泡排序算法有2种极端的情况所导致的算法复杂度是不一样的: 所有的数据集都是有序的,则此时通过算法优化可以是算法的复杂度从 O(n^2) 将至 O(n) 所有的数据集都是

【 python 学习笔记 -- 数据结构与算法 】冒泡排序 Bubble sort

推荐一个可视化的网站 [ Visual Algo ]: URL= 'https://visualgo.net/en/sorting' 这个网站给出了各种排序算法的原理和过程,通过动态形式直观得展现出来.另外还给出了相关的pseudo-code,以及具体执行到code的哪一步. [冒泡排序] 需要重复地走访需要排序的数列.走访过程中比较相邻两个items的大小,如果顺序不对,则交换两个items. 因此,每完成一次走访(pass),需要排序的部分的最大值就会移动到合适的位置. 这个过程看起来就像每

分享知识-快乐自己:Java中的经典算法之冒泡排序(Bubble Sort)

原理:比较两个相邻的元素,将值大的元素交换至右端. 思路:依次比较相邻的两个数,将小数放在前面,大数放在后面.即在第一趟:首先比较第1个和第2个数,将小数放前,大数放后.然后比较第2个数和第3个数,将小数放前,大数放后,如此继续,直至比较最后两个数,将小数放前,大数放后.重复第一趟步骤,直至全部排序完成. 第一趟比较完成后,最后一个数一定是数组中最大的一个数,所以第二趟比较的时候最后一个数不参与比较: 第二趟比较完成后,倒数第二个数也一定是数组中第二大的数,所以第三趟比较的时候最后两个数不参与比

大话数据结构----冒泡排序Bubble sort

冒泡排序是排序算法中最基础的排序算法: 原理是临近的数字两两进行比较,按照从小到大或者从大到小的顺序进行交换 package com.neuedu.java; public class BubbleSort { public static void main(String[] args) { int [] arr=new int[]{0,9,5,45,12,94,56,7}; BubbleSort(arr); for(int i=0;i<arr.length;i++){ System.out.p

快速排序算法回顾 --冒泡排序Bubble Sort和快速排序Quick Sort(Python实现)

冒泡排序的过程是首先将第一个记录的关键字和第二个记录的关键字进行比较,若为逆序,则将两个记录交换,然后比较第二个记录和第三个记录的关键字.以此类推,直至第n-1个记录和第n个记录的关键字进行过比较为止.上述过程称为第一趟冒泡排序,接着第二趟对前面n-1个关键字进行同样操作,…… 快速排序是对冒泡排序的一种改进,通过一趟排序将记录分割成独立的两部分,其中一部分记录的关键字均比另一部分关键字小,可分别对这两部分记录以递归的方法继续进行排序,以达到整个序列有序. 单趟Partition()函数过程请看

排序算法之冒泡排序(Bubble Sort)

基本思想 假如按照从小到大的顺序排序,对待排序数组进行遍历,如果当前值大于其后一个值则进行交换,不断的进行遍历,直到没有交换动作的发生.冒泡排序的最好时间复杂度为O(n),最坏的时间复杂度为O(n2),所以冒泡排序的平均时间复杂度为O(n2),另外冒泡排序不会改变相同元素的前后顺序,故其是一种稳定的排序算法. 实现代码 #include<iostream> using namespace std; int main() { int MyData[10] = { 7,3,12,46,32,64,