java利用冒泡排序对数组进行排序

本文实例讲述了java利用冒泡排序对数组进行排序的方法。分享给大家供大家参考。具体如下：

一、冒泡排序：

利用冒泡排序对数组进行排序

二、基本概念：

依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。至此第一趟结束，将最大的数放到了最后。在第二趟：仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第2个数），将小数放前，大数放后，一直比较到倒数第二个数（倒数第一的位置上已经是最大的），第二趟结束，在倒数第二的位置上得到一个新的最大数（其实在整个数列中是第二大的数）。如此下去，重复以上过程，直至最终完成排序。

三、实现思路：

用二重循环实现，外循环变量设为i，内循环变量设为j。假如有n个数需要进行排序，则外循环重复n-1次，内循环依次重复n-1，n-2，...，1次。每次进行比较的两个元素都是与内循环j有关的，它们可以分别用a[j]和a[j+1]标识，i的值依次为1,2,...,n-1，对于每一个i，j的值依次为0,1,2,...n-i 。

设数组长度为N：
1．比较相邻的前后二个数据，如果前面数据大于后面的数据，就将二个数据交换。
2．这样对数组的第0个数据到N-1个数据进行一次遍历后，最大的一个数据就“沉”到数组第N-1个位置。
3．N=N-1，如果N不为0就重复前面二步，否则排序完成。

四、java代码实现：

package ArrayDemo;
/**
 * @author pplsunny
 * @category .21
 */
public class ArrayDemo {
  /**
   * 用增强for循环输出排序结果
   */
  public static void main(String[] args) {
   int[] a = { 2, 4, 76, 12, 34, 23, 86 };
   ArrayDemo.bubbleSort(a);
   for (int b : a) {
    System.out.print(b + " ");
   }
  }
  /*
   * 冒泡排序函数，定义为静态的方便使用，
 * 也是开发中定义工具类的一个方法
   */
  public static void bubbleSort(int a[]) {
   for (int i = 1; i < a.length; i++) {
   //这是控制趟数
    for (int j = 0; j < a.length - i; j++) {
    //j < a.length - i,比较元素的个数
     if (a[j] > a[j + 1]) {
      int temp = a[j];
      a[j] = a[j + 1];
      a[j + 1] = temp;
     }
    }
   }
  }
}

五、性能分析：

若记录序列的初始状态为"正序"，则冒泡排序过程只需进行一趟排序，在排序过程中只需进行n-1次比较，且不移动记录；反之，若记录序列的初始状态为"逆序"，则需进行n(n-1）/2次比较和记录移动。因此冒泡排序总的时间复杂度为O(n*n)。

六、算法优化：

冒泡排序法存在的不足及改进方法：
第一，在排序过程中，执行完最后的排序后，虽然数据已全部排序完备，但程序无法判断是否完成排序，为了解决这一不足，可设置一个标志位flag，将其初始值设置为非0，表示被排序的表是一个无序的表，每一次排序开始前设置flag值为0，在进行数据交换时，修改flag为非0。在新一轮排序开始时，检查此标志，若此标志为0，表示上一次没有做过交换数据，则结束排序；否则进行排序；

/*
* 冒泡排序函数改进版
*/
public static void BubbleSort(int[] a) {
  boolean flag = true;
  while (flag) {
   flag = false;
   for (int i = 0; i < a.length - 1; i++) {
    for (int j = 0; j < a.length - i ; j++) {
     if (a[j] > a[j + 1]) {
      int temp = a[j];
      a[j] = a[j + 1];
      a[j + 1] = temp;
      flag = true;
     }
    }
    if (!flag)
     break; // 如果没有发生交换，则退出循环
   }
  }
}

第二、在冒泡排序中，一趟扫描有可能无数据交换，也有可能有一次或多次数据交换，在传统的冒泡排序算法及近年来的一些改进的算法中，只记录一趟扫描有无数据交换的信息，对数据交换发生的位置信息则不予处理。为了充分利用这一信息，可以在一趟全局扫描中，对每一反序数据对进行局部冒泡排序处理，称之为局部冒泡排序。局部冒泡排序与冒泡排序算法具有相同的时间复杂度，并且在正序和逆序的情况下，所需的关键字的比较次数和移动次数完全相同。由于局部冒泡排序和冒泡排序的数据移动次数总是相同的，而局部冒泡排序所需关键字的比较次数常少于冒泡排序，这意味着局部冒泡排序很可能在平均比较次数上对冒泡排序有所改进，当比较次数较少的优点不足以抵消其程序复杂度所带来的额外开销，而当数据量较大时，局部冒泡排序的时间性能则明显优于冒泡排序。对于N个无序数据，我们在进行一趟冒泡排序时，如果第k个数据和第k+1个数据逆序，那么对第k+1个数据进行一趟向前的冒泡排序，使其移动到合适的位置，也就是说让前面k+1个数据调节为正序。因为这种冒泡法只对前k+1个数据冒泡处理，所以我们称它为——局部冒泡

希望本文所述对大家的java程序设计有所帮助。

赞 (0)

相关推荐

  • java数组排序示例(冒泡排序、快速排序、希尔排序、选择排序)

    快速排序法主要是运用了Arrays中的一个方法Arrays.sort()实现. 冒泡法是运用遍历数组进行比较,通过不断的比较将最小值或者最大值一个一个的遍历出来. 选择排序法是将数组的第一个数据作为最大或者最小的值,然后通过比较循环,输出有序的数组. 插入排序是选择一个数组中的数据,通过不断的插入比较最后进行排序. 复制代码 代码如下: package com.firewolf.sort; public class MySort { /**  * @param args  */ public s

  • java简单冒泡排序实例解析

    一.算法原理 比较相邻的元素.如果第一个比第二个大,就交换他们两个. 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对.在这一点,最后的元素应该会是最大的数. 针对所有的元素重复以上的步骤,除了最后一个. 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较. 二.实现思路 用二重循环实现,外循环变量设为i,内循环变量设为j.假如有n个数需要进行排序,则外循环重复n-1次,内循环依次重复n-1,n-2,...,1次.每次进行比较的两个元素都是与内循环j有关的,它们可以分

  • 冒泡排序算法原理及JAVA实现代码

    冒泡排序法:关键字较小的记录好比气泡逐趟上浮,关键字较大的记录好比石块下沉,每趟有一块最大的石块沉底. 算法本质:(最大值是关键点,肯定放到最后了,如此循环)每次都从第一位向后滚动比较,使最大值沉底,最小值上升一次,最后一位向前推进(即最后一位刚确定的最大值不再参加比较,比较次数减1) 复杂度: 时间复杂度 O(n2) ,空间复杂度O(1) JAVA源代码(成功运行,需要Date类) 复制代码 代码如下: public static void bubbleSort(Date[] days) { 

  • 深入Java冒泡排序与选择排序的区别详解

    冒泡排序它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来.走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成.代码如下: 复制代码 代码如下: public class nums {     public static void main(String[] args){         int []nums = {5,4,3,2,1};         for(int i = 0; i < nums.length; i++){        

  • java 合并排序算法、冒泡排序算法、选择排序算法、插入排序算法、快速排序算法的描述

    算法是在有限步骤内求解某一问题所使用的一组定义明确的规则.通俗点说,就是计算机解题的过程.在这个过程中,无论是形成解题思路还是编写程序,都是在实施某种算法.前者是推理实现的算法,后者是操作实现的算法. 一个算法应该具有以下五个重要的特征: 1.有穷性: 一个算法必须保证执行有限步之后结束: 2.确切性: 算法的每一步骤必须有确切的定义: 3.输入:一个算法有0个或多个输入,以刻画运算对象的初始情况: 4.输出:一个算法有一个或多个输出,以反映对输入数据加工后的结果.没有输出的算法是毫无意义的:

  • Java中的数组排序方式(快速排序、冒泡排序、选择排序)

    1.使用JavaApi文档中的Arrays类中的sort()进行快速排序 复制代码 代码如下: import java.util.Arrays; public class TestOne{ public static void main(String [] args){ int [] array={2,0,1,4,5,8}; Arrays.sort(array);//调用Arrays的静态方法Sort进行排序,升序排列 for(int show:array){ System.out.printl

  • java冒泡排序算法代码

    复制代码 代码如下: /** * 原理: * 进行n次循环,每次循环从后往前对相邻两个元素进行比较,小的往前,大的往后 *  * 时间复杂度: * 平均情况:O(n^2) * 最好情况:O(n) * 最坏情况:O(n^2) * * 稳定性:稳定 **/public class 冒泡排序 { public int[] bubbleSort(int[] a, int n) {        for (int i = 0; i < n; i++) {            int flag = 0; 

  • Java冒泡排序（Bubble Sort）实例讲解

    举个例子:int[] array = {2,4,9,7,6,5}; 第一轮2和4进行比较,2<4,位置不变.再4和9进行比较,4<9,位置不变.再9和7进行比较,9>7,9和7的位置互换.再9和6进行比较,9>6,9和6的位置互换.再9和5进行比较,9>5,位置互换.第一轮比较的结果就是2 4 7 6 5 9. 第二轮2和4进行比较,2<4,位置不变.再4和7进行比较,4<7,位置不变.再7和5进行比较,7>6,7和6的位置互换.再7和5进行比较,7>

  • 用java实现冒泡排序算法

    冒泡排序的算法分析与改进 交换排序的基本思想是:两两比较待排序记录的关键字,发现两个记录的次序相反时即进行交换,直到没有反序的记录为止. 应用交换排序基本思想的主要排序方法有:冒泡排序和快速排序. 复制代码 代码如下: public class BubbleSort implements SortUtil.Sort{ public void sort(int[] data) { int temp; for(int i=0;i<data.length;i++){ for(int j=data.le

  • java利用冒泡排序对数组进行排序

    本文实例讲述了java利用冒泡排序对数组进行排序的方法.分享给大家供大家参考.具体如下: 一.冒泡排序: 利用冒泡排序对数组进行排序 二.基本概念: 依次比较相邻的两个数,将小数放在前面,大数放在后面.即在第一趟:首先比较第1个和第2个数,将小数放前,大数放后.然后比较第2个数和第3个数,将小数放前,大数放后,如此继续,直至比较最后两个数,将小数放前,大数放后.至此第一趟结束,将最大的数放到了最后.在第二趟:仍从第一对数开始比较(因为可能由于第2个数和第3个数的交换,使得第1个数不再小于第2个数

  • Java中集合和数组的排序方式小结

    根据约定,在使用java编程的时候应尽可能的使用现有的类库,当然你也可以自己编写一个排序的方法,或者框架,但是有几个人能写得比JDK里的还要好呢?使用现有的类的另一个好处是代码易于阅读和维护,这篇文章主要讲的是如何使用现有的类库对数组和各种Collection容器进行排序,(文章中的一 部分例子来自<Java Developers Almanac 1.4>) 首先要知道两个类:java.util.Arrays和java.util.Collections(注意和Collection的区 别)Co

  • Java数组常用排序算法实例小结

    本文实例讲述了Java数组常用排序算法.分享给大家供大家参考,具体如下: 1.冒泡排序法 SortArray_01.java public class SortArray_01 { public static void main(String args[]) { int[] array = { 14, 5, 86, 4, 12, 3, 21, 13, 11, 2, 55, 66, 22 }; // 创建一个初始化的一维数组array System.out.println("未排序的数组:&quo

  • Java实现八个常用的排序算法：插入排序、冒泡排序、选择排序、希尔排序等

    Java实现八个常用的排序算法：插入排序、冒泡排序、选择排序、希尔排序等

    本文实现了八个常用的排序算法:插入排序.冒泡排序.选择排序.希尔排序 .快速排序.归并排序.堆排序和LST基数排序 首先是EightAlgorithms.java文件,代码如下: import java.util.Arrays; /* * 实现了八个常用的排序算法:插入排序.冒泡排序.选择排序.希尔排序 * 以及快速排序.归并排序.堆排序和LST基数排序 * @author gkh178 */ public class EightAlgorithms { //插入排序:时间复杂度o(n^2) p

  • java实现6种字符串数组的排序(String array sort)

    注意,本文不是字符串排序,是字符串数组的排序. 方法分别是: 1.低位优先键索引排序 2.高位优先建索引排序 3.Java自带排序(经过调优的归并排序) 4.冒泡排序 5.快速排序 6.三向快速排序 时间复杂度: 最慢的肯定是冒泡,O(n的平方) 最快的是快速排序,平均 O(nlogn) 低位优先,O(nW),W是字符串长度,在字符串长度较短情况下和快速排序时间应该很接近 高位优先,O(n) - O(nW) 三向快速排序,O(n) - O(nW) 本文中使用的例子是一个5757行的随机字符串数组

  • java String[]字符串数组自动排序的简单实现

    如下所示: import java.util.Arrays; public class xulie { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub String []str = {"abc","bca","cab","cba","aaa","111&

  • java对数组进行排序的方法

    本文实例讲述了java对数组进行排序的方法.分享给大家供大家参考.具体如下: public class Test1 { public static void showArray(int[] array) { for (int n = 0; n < array.length; n++) { System.out.print(array[n]); System.out.print(" "); } System.out.println(); } public static int[]

  • java利用数组随机抽取幸运观众

    java利用数组随机抽取幸运观众

    本文实例为大家分享了java利用数组随机抽取幸运观众的具体代码,供大家参考,具体内容如下 思想: 首先将所有观众姓名生成数组,然后获取数组元素的总数量,再在数组元素中随机抽取元素的下标,根据元素的下标得到幸运观众的名字. import java.awt.BorderLayout; import java.awt.EventQueue; import javax.swing.JFrame; import javax.swing.JPanel; import javax.swing.border.E

  • Java中冒泡排序的原生实现方法(正序与逆序)

    需求: 给定数组,ary=[2,4,5,3,1], 如何升序或逆序排列? 提示: Arrays.sort只能升序排列, 先用双重for循环,原生方法实现. public class T02 { public static void main(String[] args) { //冒泡升序 int [] ary = {1,4,5,6,7,8,3,2}; for (int i = 0; i <ary.length ; i++) { for (int j = (i+1); j <ary.length

随机推荐