精华内容
下载资源
问答
  • import java.util.Arrays; public class BubbleAndSelectSort { public static void main(String[] args) { int[] array = {43,2,33,12,1,45,88,21,91,3,28}; System.out.println(Arrays.toString(bubbleSort...
    package test1;
    
    import java.util.Arrays;
    
    public class BubbleAndSelectSort {
        public static void main(String[] args) {
            int[] array = {43,2,33,12,1,45,88,21,91,3,28};
            System.out.println(Arrays.toString(bubbleSort(array)));
            System.out.println(Arrays.toString(selectSort(array)));
        }
        //冒泡排序
        public static int[] bubbleSort(int[] array){
            for(int i = 0;i<array.length-1;i++){
                for(int j = 0;j<array.length-i-1;j++){
                    int tep ;
                    if(array[j]>array[j+1]){
                        tep = array[j+1];
                        array[j+1] = array[j];
                        array[j] = tep;
                    }
                }
            }
            return array;
        }
    
        //选择排序
        public static int[] selectSort(int[] array){
            for(int i = 0;i<array.length-1;i++){
                for(int j = i+1;j<array.length;j++){
                    int tep;
                    if(array[i]>array[j]){
                        tep = array[j];
                        array[j] = array[i];
                        array[i] = tep;
                    }
                }
            }
            return array;
        }
    }
    
    
    
    
    展开全文
  • Java编程冒泡排序

    基本介绍

    冒泡排序(Bubble Sorting)的基本思想是:通过对待排序序列从前向后(从下标较小的元素开始),依次比较相邻元素的值,若发现逆序则交换,使值较大的元素逐渐从前移向后部,就象水底下的气泡一样逐渐向上冒。

    优化

    因为排序的过程中,各元素不断接近自己的位置,如果一趟比较下来没有进行过交换,就说明序列有序,因此要在排序过程中设置一个标志flag判断元素是否进行过交换。从而减少不必要的比较。

    演示冒泡过程的例子(图解)

    在这里插入图片描述

    选择式排序也属于内部排序法,是从欲排序的数据中,按指定的规则选出某一元素,再依规定交换位置后达到排序的目的。

    代码

    package sort;
    
    import java.lang.reflect.Array;
    import java.text.SimpleDateFormat;
    import java.util.Arrays;
    import java.util.Date;
    
    public 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("第一趟排序后的数组:");
            System.out.println(Arrays.toString(arr));
            // 第二趟排序,就是把第二大的数排在倒数第二位
            for (int i = 0; i < arr.length - 1 - 1; i++) {
                // 如果前面的数比后面的数大,则交换
                if (arr[i] > arr[i + 1]) {
                    temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                }
            }
            System.out.println("第二趟排序后的数组:");
            System.out.println(Arrays.toString(arr));
            // 第三趟排序,就是把第三大的数排在倒数第三位
            for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {
                // 如果前面的数比后面的数大,则交换
                if (arr[i] > arr[i + 1]) {
                    temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                }
            }
            System.out.println("第三趟排序后的数组:");
            System.out.println(Arrays.toString(arr));
            // 第四趟排序,就是把第三大的数排在倒数第四位
            for (int i = 0; i < arr.length - 1 - 1 - 1 - 1; i++) {
                // 如果前面的数比后面的数大,则交换
                if (arr[i] > arr[i + 1]) {
                    temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                }
            }
            System.out.println("第四趟排序后的数组:");
            System.out.println(Arrays.toString(arr));*/
            int[] arr = new int[80000];
            for (int i = 0; i < 80000; i++) {
                arr[i] = (int) (Math.random() * 80000);// 生成一个0-80000的数据
            }
            Date date1 = new Date();
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String date1Str = simpleDateFormat.format(date1);
            System.out.println("排序前的时间为:" + date1Str);
            BetterBubbleSortByAsc(arr);
            Date date2 = new Date();
            String date2Str = simpleDateFormat.format(date2);
            System.out.println("排序后的时间为:" + date2Str);
        }
    
        /**
         * 冒泡排序的事件复杂度 O(n²)
         *
         * @param arr 待排序数组
         */
        public static void BubbleSortByAsc(int[] arr) {
            int temp = 0;
            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]) {
                        temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
                }
            }
        }
    
        /**
         * 冒泡排序优化
         *
         * @param arr 待优化数组
         */
        public static void BetterBubbleSortByAsc(int[] arr) {
            int temp = 0;
            boolean flag = 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]) {
                        flag = true;    // 只要在排序中发生了交换,就将flag置为true
                        temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
                }
                if (!flag) {
                    // 如果flag人为false,即一次都没发生
                    break;
                } else {
                    flag = false;   // 重置flag,进行下次判断
                }
            }
        }
    }
    
    

    结论

    80000个数据耗费时间大概15-17秒。

    展开全文
  • /*** java编程题:用Java实现一个冒泡排序算法*/public class Test12 {public static void main(String[] args) {int[] sortNum = {12,33,28,86,15,62,9,38};//定义数组bubbleSort3(sortNum);//开始排序System.out....

    /**

    * java编程题:用Java实现一个冒泡排序算法

    */

    public class Test12 {

    public static void main(String[] args) {

    int[] sortNum = {12,33,28,86,15,62,9,38};//定义数组

    bubbleSort3(sortNum);//开始排序

    System.out.println(Arrays.toString(sortNum));//打印结果

    }

    /**

    * 写法一:从小到大顺序进行排列,从[前面]开始比较。。。容易理解。

    *

    * @param sortNum

    */

    private static void bubbleSort(int[] sortNum){

    int temp = 0;

    for (int i = 0; i < sortNum.length-1; i++) {//第一个for循环控制排序要走多少趟,最多做n-1趟排序

    for (int j = 0; j < sortNum.length-1-i; j++) {//第2个for循环控制每趟比较多少次

    if(sortNum[j+1]

    temp = sortNum[j];

    sortNum[j] = sortNum[j+1];

    sortNum[j+1] = temp;

    }

    }

    }

    }

    /**

    * 写法二:从小到大顺序进行排列,从[后面]开始比较。。。不按常规套路出牌。

    *

    * @param sortNum

    */

    private static void bubbleSort2(int[] sortNum){

    int temp = 0;

    for (int i = 0; i < sortNum.length-1; i++) {//第一个for循环控制排序要走多少趟,最多做n-1趟排序

    for (int j = sortNum.length-1; j > i; j--) {//第2个for循环控制每趟比较多少次

    if(sortNum[j-1]>sortNum[j]){//大的往后面排

    temp = sortNum[j-1];

    sortNum[j-1] = sortNum[j];

    sortNum[j] = temp;

    }

    }

    }

    }

    /**

    * 写法三:从小到大顺序进行排列,从[前面]开始比较。。。改进优化版。

    *

    * @param sortNum

    */

    private static void bubbleSort3(int[] sortNum){

    boolean flag = true;

    while(flag){

    flag = false;

    int temp = 0;

    for (int i = 0; i < sortNum.length-1; i++) {//第一个for循环控制排序要走多少趟,最多做n-1趟排序

    for (int j = 0; j < sortNum.length-1-i; j++) {//第2个for循环控制每趟比较多少次

    if(sortNum[j+1]

    temp = sortNum[j];

    sortNum[j] = sortNum[j+1];

    sortNum[j+1] = temp;

    flag = true;

    }

    }

    //优化判断

    if(!flag){// 若没有交换则排序完成,直接跳出

    break;

    }

    }

    }

    }

    }

    打印结果:

    [9, 12, 15, 28, 33, 38, 62, 86]

    参考地址:

    http://www.cnblogs.com/shen-hua/p/5422676.html

    http://blog.csdn.net/donggua3694857/article/details/56959553

    http://blog.csdn.net/ouyang_peng/article/details/46540497

    http://blog.csdn.net/jq_ak47/article/details/46743613

    http://blog.csdn.net/feng2qing/article/details/53860685

    http://blog.csdn.net/qy1387/article/details/7752973

    展开全文
  • 首先我们了解下什么是冒泡排序冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较,交换也发生在这两个元素之间。所以,如果两个元素相等,我想你是不会再无聊地把他们俩交换一下的;...

    首先我们了解下什么是冒泡排序:

    冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较,交换也发生在这两个元素之间。所以,如果两个元素相等,我想你是不会再无聊地把他们俩交换一下的;如果两个相等的元素没有相邻,那么即使通过前面的两两交换把两个相邻起来,这时候也不会交换,所以相同元素的前后顺序并没有改变,所以冒泡排序是一种稳定排序算法。

    冒泡排序的时间复杂度是n^2;

    当有N个数需要排列时,按照冒泡排序的思想,需要进行N-1的排序,每次排序将最大或最小的数放到数组的尾部(每次内部排序完后那么下次只需比较除最后一个数外的数组的其他的数,因为最后一个数已经符合最大或最小的要求)

    public static void main(String[] args) {

    //定义一个数组,长度为10

    int arr[] = new int[10];

    //随机生成0到20的随机数填充数组

    for(int i = 0;i

    arr[i] =(int)( Math.random()*20);

    }

    //输出未排序前的数组

    for(int i = 0;i

    System.out.print(arr[i]+" ");

    }

    //换行

    System.out.println();

    //进行冒泡排序

    for(int i =0;i

    //第二层循环,最大的数排到数组底部

    for(int j = 0;j

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

    int temp;

    temp = arr[j];

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

    arr[j+1] = temp;

    }

    }

    //输出查看结果

    for(int i = 0;i

    System.out.print(arr[i]+" ");

    }

    }

    展开全文
  • java实现数组冒泡排序的方法发布时间:2020-06-24 09:21:42来源:亿速云阅读:82作者:Leah本篇文章展示了java实现数组冒泡排序的具体操作,代码简明扼要容易理解,绝对能让你眼前一亮,通过这篇文章的详细介绍希望...
  • /*** 功能:冒泡排序法* 思想:通过对待排序序列从后向前(从下标较大的元素开始),依次比较相邻元素的排序码,* ,若发现逆序这交换,使得排序码较小的元素逐渐从后部移向前部(从下标较大的单元移向下标)* 较小的...
  • /*冒泡排序算法:比较相邻的元素。如果第一个比第二个大,就交换它们两个。对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。最后的元素应该会是最大的数。针对除了最后一个元素以外所有的元素重复以上...
  • 我们今天来实现冒泡排序。现在有这样一个需求:在数组中含有七个int类型的元素, 分别为 34,21,18,6,1,42,0;设计出一个算法完成从该数组的排序功能。我们知道排序,关键点在顺序上,可以从小到大,也可以从大到小。...
  • 冒泡排序flash.java Eclipse 冒泡排序编程语法
  • 编写一个方法实现冒泡排序。输入10整数,利用冒泡排序将这些整数按由小到大的顺序输出。 二、实验代码 package fighting; import java.util.Scanner; public class fighting { public static void sort(int a[]) ...
  • //创建一个数组,这个数组的元素是乱序的,然后编程解决将这个数组从小到大打印出来。public class Work6 {public static void main(String[] args)...//冒泡排序/*for (int i = 0; i < arr.length-1; i++) {for ...
  • JAVA编程冒泡排序

    2019-09-16 10:16:17
    题目: 实现冒泡排序法 源码:
  • 我们今天来实现冒泡排序。现在有这样一个需求:在数组中含有七个int类型的元素, 分别为 34,21,18,6,1,42,0;设计出一个算法完成从该数组的排序功能。我们知道排序,关键点在顺序上,可以从小到大,...
  • 冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。这个算法的名字...
  • C语言和Java冒泡排序编程、分析 名字由来: 冒泡排序(Bubble Sort),是一种计算机科学领域的较简单的排序算法。 它重复地走访过要排序的元素列,依次比较两个相邻的元素,如果顺序(如从大到小、首字母从Z到A)...
  • 前言前天刚结束了六级考试,休息了一天的状态继续回归java编程练习当中。自己想明白了一个经典的冒泡排序,这个冒泡排序一开始就是自己不能理解,总感觉自己的逻辑思维不行,然后用笔在纸上演练了一下这个过程,才...
  • java编写冒泡排序

    千次阅读 多人点赞 2020-12-14 21:27:17
    前天刚结束了六级考试,休息了一天的状态继续回归java编程练习当中。自己想明白了一个经典的冒泡排序,这个冒泡排序一开始就是自己不能理解,总感觉自己的逻辑思维不行,然后用笔在纸上演练了一下这个过程,才慢慢的...
  • 12,45,9,67,455,用冒泡排序实现升序排列...public class Test05 {public static void main(String[] args) {// 12,45,9,67,455,用冒泡排序实现升序排列。int[] arr = { 12, 45, 9, 67, 455 };for (int i = 0; i <...
  • 冒泡排序不同, 选择排序使用标记最值所在位置的方式, 查找最值过程中不移动数位置, 只是在最后将最值置换到顶端. function selectionSort(arr) { var len = arr.length; var minIndex, temp; for (var i = 0; ...
  • Java冒泡排序

    2018-11-14 14:49:58
    排序在编程中大家经常遇到,而冒泡排序是大家常用算法之一,冒泡排序实则是将数据从第一个进行循环,和其后面每一个数比较大小,如果从小到大进行排序,如果一个数比第二个数大,则两者进行交换。(从小到大进行排序...
  • java实现冒泡排序

    2020-09-19 05:33:30
    冒泡排序 概述 冒泡排序(Bubble Sorting) 的基本思想就是通过对待排序序列从前向后,依次比较相邻元素的值,如果出现逆序则交换。如果是从小到大排序,则每一轮冒泡就能将序列的最大值交换到序列的尾部,从而确定...
  • 冒泡排序,相信接触过计算机编程的同学都熟悉,由于冒泡排序简洁的特点,它通常被用来对于计算机程序设计入门的学生介绍算法的概念。现在我们来看看另外一种快速排序的方法,首先看下,冒泡排序算法与快速排序算法的...
  • 冒泡排序(Bubble Sort)是计算机编程开发技术中一种较为简单的排序方法。为了更好地理解其算法原理,我们先来看这样一个例子:在操场上从左到右一字排开地站着A(181)、B(169)、C(187)、D(172)、E(163) 5名运动员(括号...
  • 本文实例讲述了Java排序算法总结之冒泡排序。分享给大家供大家参考。具体分析如下:前言:冒泡排序(BubbleSort)就是依次比较相邻的两个数,将小数放在前面,大数放在后面。下面让我们一起 来看冒泡排序Java中的...
  • 冒泡排序算法详解一、算法的设计思想:就是将第一个记录的关键字和第二个记录的关键字进行比较,如果后面的比前面的小则交换,然后比较第二个和第三个,依次类推。比完一趟,最大的那个已经放到了最后的位置,这样就...
  • java编程基础(三)冒泡排序

    千次阅读 2020-07-13 16:41:56
    文章目录冒泡排序运算逻辑分析代码冒泡排序优化代码 冒泡排序运算逻辑分析 从上面的演示看到,排序运算主要依靠j向前递减来完成,j递减过程做两件事: 较小值向前移动 最小值移动到i位置 代码 package demo3; ...
  • 怎么用JAVA实现冒泡排序  分享| 2014-01-02 16:38匿名 | 浏览 2426 次  java编程编程语言 2014-01-03 21:05网友采纳 热心网友 static void BubbleSort(int a []){  int temp=0;  ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 556
精华内容 222
关键字:

java编程冒泡排序

java 订阅