精华内容
下载资源
问答
  • java冒泡排序代码

    2018-08-06 21:28:52
    java冒泡排序代码,亲测能用,控制台输入数据,自动排序
  • Java冒泡排序代码

    2019-03-05 11:07:29
    //测试冒泡排序 /********************* * int[] num = {23,45,76,78,98,54,}; 第一次 23 45 76 78 54 98 第二次 23 45 76 54 78 98 第三次 23 45 54 76 78 98 输出 :23 45 54 76 78 98 当判断为正确时就退出...
  • JAVA冒泡排序代码

    2021-01-30 15:44:23
    * 冒泡排序:最基础(简单)的排序 * 比较两个相邻的元素,将较大值的元素交换至(左)右端 * <p> * 第一次比较n-1次 * 第二次比较n-2次 * 。。。。 * <p> * 平均时间复杂度 最好情况 最坏情况 空间...

    冒泡算法学习使用代码如下

    import untils.AlgorithmUtils;
    
    import java.util.Arrays;
    
    /**
     * 冒泡排序:最基础(简单)的排序
     * 比较两个相邻的元素,将较大值的元素交换至(左)右端
     * <p>
     * 第一次比较n-1次
     * 第二次比较n-2次
     * 。。。。
     * <p>
     * 平均时间复杂度	最好情况	最坏情况	空间复杂度
     * O(n²)	O(n)	O(n²)	O(1)
     */
    public class Bubble {
        public static int[] studyBubbleSort(int[] arr) {
            int len = arr.length;
            System.out.println("传入的原数组长度为: " + len);
            System.out.println("传入的原数组为: " + Arrays.toString(arr));
            //外层循环控制比较的次数
            for (int i = 0; i < len - 1; i++) {
                System.out.println("----第 " + (i + 1) + " 轮排序开始----");
                //内层循环控制到达位置
                for (int j = 0; j < len - i - 1; j++) {
                    if (arr[j] > arr[j + 1]) {
                        AlgorithmUtils.swap(arr, j, j + 1);
                        System.out.println("    数组的第 " + j + " 位置与第 " + (j + 1) + "进行交换,交换后结果为: ");
                        System.out.println("    " + Arrays.toString(arr));
                    }
    
                }
                System.out.println("----第 " + (i + 1) + " 轮排序完毕----");
            }
            return arr;
        }
    
    }
    
    
    package untils;
    
    public class AlgorithmUtils {
    
        public static void swap(int[] arr, int a, int b) {
    
            int temp = arr[a];
            arr[a] = arr[b];
            arr[b] = temp;
    
            /* 不常用
    
            arr[a] = arr[a] + arr[b];
            arr[b] = arr[a] - arr[b];
            arr[a] = arr[a] - arr[b];
            */
    
        }
    
    }
    
    

    冒泡算法作为工具类使用代码如下

    public class Bubble {
    
        /**
         * 
         * @param arr 传入数组
         * @return 排序后的数组
         */
        public static int[] bubbleSort(int[] arr) {
            int len = arr.length;
            for (int i = 0; i < len - 1; i++) {
                for (int j = 0; j < len - i - 1; j++) {
                    if (arr[j] > arr[j + 1]) {
                        AlgorithmUtils.swap(arr, j, j + 1);
                    }
                }
            }
            return arr;
        }
    }
    
    
    展开全文
  • java 冒泡排序代码

    2019-09-23 17:09:34
    //冒泡排序 public static boolean bubbleSort(int[] arr){ if(null == arr || arr.length == 0){ System.out.println("Input parameter is invalid!"); return false; } ...

    //冒泡排序
        public static boolean bubbleSort(int[] arr){
            if(null == arr || arr.length == 0){
                System.out.println("Input parameter is invalid!");
                return false;
            }
            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;
                    }
                }
            }
            return true;
        }

    展开全文
  • Java冒泡排序代码示例代码如下:↓package com.coding.learn;import java.util.Arrays;/*** @author 老菜鸟* @version 1.1* @Description 冒泡排序* @date 3/19/21*/public class BubbleSort {public static void ...

    Java冒泡排序代码示例

    代码如下:↓

    package com.coding.learn;

    import java.util.Arrays;

    /**

    * @author 老菜鸟

    * @version 1.1

    * @Description 冒泡排序

    * @date 3/19/21

    */

    public class BubbleSort {

    public static void main(String[] args) {

    //定义示例数组

    int[] intArray = {1, 3, 7, 2, 9, 6, 5, 4};

    System.out.println(Arrays.toString(intArray));

    //调用冒泡排序

    bubbleSort(intArray);

    System.out.println(Arrays.toString(intArray));

    }

    /**

    * 功能描述:冒泡排序

    * @param array

    * @return void

    * @date 3/19/21 8:12 PM

    * @author 老菜鸟

    */

    public static void bubbleSort(int[] array) {

    for (int i = 0; i < array.length; i++) {

    for (int j = i + 1; j < array.length; j++) {

    //依次比较两个数字,如果前面的数字比后面的数字大,则交换位置

    int temp = array[i];

    if (temp > array[j]) {

    array[i] = array[j];

    array[j] = temp;

    }

    }

    }

    }

    }

    运行结果:↓

    e28fdc0a67347628d9a14941864629e4.png

    展开全文
  • 一、冒泡排序:利用冒泡排序对数组进行排序二、基本概念:依次比较相邻的两个数,将小数放在前面,大数放在后面。即在第一趟:首先比较第1个和第2个数,将小数放前,大数放后。然后比较第2个数和第3个数,将小数放前...

    b8bace3696ccae0e4adb89d9ac28e34d.png

    11fe95a92715b7ed4bd18304b86c0ee8.png

    一、冒泡排序:

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

    二、基本概念:

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

    3d28b2d25d3fafc86ba6d4a92919d77b.png

    三、实现思路:

    用二重循环实现,外循环变量设为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 冒泡排序;

    import java.util.Arrays;

    /**

    * 冒泡排序

    * @author chen

    *

    */

    public class BubbleSort {

    public static void BubbleSort(int[] arr) {

    int temp;//定义一个临时变量

    for(int i=0;i<arr.length-1;i++){//冒泡趟数

    for(int j=0;j<arr.length-i-1;j++){

    if(arr[j+1]<arr[j]){

    temp = arr[j];

    arr[j] = arr[j+1];

    arr[j+1] = temp;

    }

    }

    }

    }

    public static void main(String[] args) {

    int arr[] = new int[]{1,6,2,2,5};

    BubbleSort.BubbleSort(arr);

    System.out.println(Arrays.toString(arr));

    }

    }

    五、性能分析:

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

    六、算法优化:

    冒泡排序法存在的不足及改进方法:

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

    package 冒泡排序;

    import java.util.Arrays;

    /**

    * 冒泡排序改进版

    * @author chen

    *

    */

    public class BubbleSort1 {

    public static void BubbleSort(int[] arr) {

    boolean flag = true;

    while(flag){

    int temp;//定义一个临时变量

    for(int i=0;i<arr.length-1;i++){//冒泡趟数,n-1趟

    for(int j=0;j<arr.length-i-1;j++){

    if(arr[j+1]<arr[j]){

    temp = arr[j];

    arr[j] = arr[j+1];

    arr[j+1] = temp;

    flag = true;

    }

    }

    if(!flag){

    break;//若果没有发生交换,则退出循环

    }

    }

    }

    }

    public static void main(String[] args) {

    int arr[] = new int[]{1,6,2,2,5};

    BubbleSort.BubbleSort(arr);

    System.out.println(Arrays.toString(arr));

    }

    }

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

    0d4397144ef9b32cd02a381f188047b8.png
    展开全文
  • Java冒泡排序代码实现

    万次阅读 多人点赞 2018-03-04 21:58:26
    Java冒泡排序代码实现原理:比较两个相邻的元素,将值大的元素交换至右端。思路:依次比较相邻的两个数,将小数放在前面,大数放在后面。即在第一趟:首先比较第1个和第2个数,将小数放前,大数放后。然后比较第2个...
  • JAVA 冒泡排序代码

    2016-05-11 08:38:00
    int[] a = {2,5,3,6,3,2,4,4,8,9,3,2}; for(int z: a) { for(int i=0;i<a.length-1;i++) { if(a[i]<a[i+1]) { int A=a[i]; a[i]=a[i+1]; a[i+1]=A; } } } for(int b:a) { ....
  • 恰饭广告先贴出代码(从小到大排序):public class BubbleSort {public static void main(String args[]){double[] a={0,1,5,9,10,2,4,6,3,7,8,-3,0.4,-2.5};for (int i=0;ifor (int j=0;jif (a...
  • 算法描述:对于给定的n个记录,从第一个记录开始依次对相邻的...冒泡排序是非常好理解的,以从小到大排序为例,每一轮排序就找出未排序序列中最大值放在最后。设数组的长度为N:(1)比较前后相邻的二个数据,如果前面...
  • java算法-冒泡排序练习所谓冒泡就是一堆数据相邻的互相比较,把大的数据往后移,小的数据往前移。百度上找了张图大家自己想一想这个逻辑想明白了,直接看代码。public class Two {public static void main(String[] ...
  • 冒泡排序是数组查找算法中最为简单的算法冒泡排序原理:假设一个数组长度为k(最高索引k-1),遍历前k - 1个(最高索引k-2)元素,若数组中的元素a[i]都与相邻的下一个元素a[i+1]进行比较,若a[i] > a[i+1] ,则这两个...
  • Java冒泡排序代码详解

    千次阅读 多人点赞 2017-05-28 14:08:38
    java冒泡排序
  • 冒泡排序的概念冒泡排序(英语:Bubble Sort)是一种简单的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是...
  • 如何优化冒泡排序?一、冒泡排序(BubbleSort)基本思想:从左到右使用相邻两个元素进行比较,如果第一个比第二个大,则交换两个元素。这样会使较大数下沉到数组的尾端,即较小数像泡泡一样冒到数组首端。排序过程:...
  • Java冒泡排序代码整理

    2010-05-28 14:26:09
    Java冒泡排序代码整理: [code="java"]package boke.sort; /** * 冒泡排序 * * @since jdk1.5及其以上 * @author 毛正吉 * @version 1.0 * @date 2010.05.24 * */ public class ...
  • 冒泡排序:我对冒泡排序的理解就是相邻两个数进行比较,确定其大小后让他们交换位置,交换后他们中的一个在和另外一个相邻的数比较,依次进行就可以确定一个最大或者最小的数,并且其位置在最后.在依次进行这样的操作直到...
  • java冒泡排序代码实现

    2021-03-04 16:21:31
    冒泡排序 就像我们烧水时候大的气泡会往上冒,小的水泡会沉在底下哈 这里采用双层循环来写哈 升序 双层循环 外循环控制循环次数 例如3个数的话,只循环2次即可比较出大小 内循环比较时候只比较没有进行比较得数即可 ...
  • 简介排序可能是所有的算法中最最基础和最最...冒泡排序的原理冒泡排序的原理很简单,我们想象一下一个一个的气泡上浮的过程。假设我们有八个数字 29,10,14,37,20,25,44,15 要进行排序。我们先用一个动画图来直观的...
  • 冒泡排序:是一种非常经典的排序算法,这种算法的核心在于从第一个元素开始,第一个元素跟后面相邻的元素进行两两比较。如果前面的元素比后面的元素大,则交换位置,否则元素位置不变,从下一个元素进行两两比较,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,739
精华内容 1,495
关键字:

java冒泡排序代码

java 订阅