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

    2017-03-10 10:02:41
    java实现冒泡排序

    java实现冒泡排序:

    public class BubbleSort {
        public static void main(String[] args) {
            int array[] = bubbleSort(new int[]{1,3,2,4,6,1});
            for (int a : array){
                System.out.println(a);
            }
        }
        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++)
                    if(array[j] > array[j+1]){
                        int temp = array[j];
                        array[j] = array[j+1];
                        array[j+1] = temp;
                    }
            }
            return array;
        }
    }
    运行结果如下:
    

    这里写图片描述

    展开全文
  • java 实现冒泡排序

    2021-02-24 21:12:19
    java 实现冒泡排序 冒泡排序的重点是用两层循环 第一层循环 遍历所有元素 第二层 替换所有元素 代码如下: public class demo { public static void main(String[] args) { int[] array = { 10, 9, 8, 7, 6, 5, 4, ...

    java 实现冒泡排序

    冒泡排序的重点是用两层循环
    第一层循环 遍历所有元素
    第二层 替换元素
    代码如下:

    public class demo {
    public static void main(String[] args) {
        int[] array = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
        System.out.println("冒泡排序");
        int[] order = Order(array);
        for (int i = 0; i <order.length ; i++) {
            System.out.print(order[i]);
        }
    }
    
    public static int[] Order(int [] nums) {
        for (int i = 0; i <nums.length-1 ; i++) {
            for (int j = 0; j <nums.length-1 ; j++) {
                if (nums[j]>nums[j+1]){
                    int value = nums[j];
                    nums[j]=nums[j+1];
                    nums[j+1]=value;
                }
            }
        }
        return nums;
    }
    

    }

    展开全文
  • Java实现冒泡排序

    2020-10-21 10:20:54
    (一)Java实现冒泡排序 代码实现: package com.wllarl.suanfa.sort; import java.util.Arrays; //冒泡排序 public class BubbleSort { public static void main(String[] args) { int[] array = {1,2,4,77,2...

    (1)Java实现冒泡排序

    代码实现:

    package com.wllarl.suanfa.sort;
    
    import java.util.Arrays;
    
    //冒泡排序
    public class BubbleSort {
        public static void main(String[] args) {
            int[] array = {1,2,4,77,2,12};
            BubbleSort bubbleSort = new BubbleSort();
            System.out.println("+++++==============================================++++++++++++");
            bubbleSort.bubbleOne(array);
           // System.out.println("+++++==============================================++++++++++++");
            // bubbleSort.bubbleTwo(array);
            // System.out.println("+++++==============================================++++++++++++");
           // bubbleSort.bubbleThree(array);
        }
    
        //冒泡排序第一个版本···
        public void bubbleOne(int[] array){
            int temp = 0;
            for (int i=0; i < array.length-1; i++){
                System.out.println("第"+i+"趟结果:");
                for (int j=0; j<array.length -1 ; j++){
                    if (array[j] > array[j+1]) {
                        temp = array[j+1];
                        array[j+1] = array [j];
                        array[j] = temp;
                    }
                    System.out.println(Arrays.toString(array));
                }
    
            }
        }
    
    
        //冒泡排序第二个版本
        public void bubbleTwo(int[] array){
            int temp = 0;
            for (int i=0; i < array.length-1; i++){
                System.out.println("第"+i+"趟结果:");
                for (int j=0; j<array.length -1-i ; j++){//改动,将前面已经排好的顺序给排除掉
                    if (array[j] > array[j+1]) {
                        temp = array[j+1];
                        array[j+1] = array [j];
                        array[j] = temp;
                    }
                    System.out.println(Arrays.toString(array));
                }
    
            }
        }
    
        //冒泡排序第三个版本
        public void bubbleThree(int[] array){
            int temp = 0;
            boolean flag = false;//标识符
            for (int i=0; i < array.length-1; i++){
                System.out.println("第"+i+"趟结果:");
                for (int j=0; j<array.length -1-i ; j++){
                    if (array[j] > array[j+1]) {
                        temp = array[j+1];
                        array[j+1] = array [j];
                        array[j] = temp;
                        flag = true;//表示有交换
                    }
                    System.out.println(Arrays.toString(array));
                }
                if (!flag){
                    break;//表示已经有序
                }else {
                    flag = false;
                }
    
            }
        }
    }
    
    

    实验截图:
    第一版
    第0趟结果:
    [19, 199, 4, 77, 2, 12]
    [19, 4, 199, 77, 2, 12]
    [19, 4, 77, 199, 2, 12]
    [19, 4, 77, 2, 199, 12]
    [19, 4, 77, 2, 12, 199]
    第1趟结果:
    [4, 19, 77, 2, 12, 199]
    [4, 19, 77, 2, 12, 199]
    [4, 19, 2, 77, 12, 199]
    [4, 19, 2, 12, 77, 199]
    [4, 19, 2, 12, 77, 199]
    第2趟结果:
    [4, 19, 2, 12, 77, 199]
    [4, 2, 19, 12, 77, 199]
    [4, 2, 12, 19, 77, 199]
    [4, 2, 12, 19, 77, 199]
    [4, 2, 12, 19, 77, 199]
    第3趟结果:
    [2, 4, 12, 19, 77, 199]
    [2, 4, 12, 19, 77, 199]
    [2, 4, 12, 19, 77, 199]
    [2, 4, 12, 19, 77, 199]
    [2, 4, 12, 19, 77, 199]
    第4趟结果:
    [2, 4, 12, 19, 77, 199]
    [2, 4, 12, 19, 77, 199]
    [2, 4, 12, 19, 77, 199]
    [2, 4, 12, 19, 77, 199]
    [2, 4, 12, 19, 77, 199]
    第二版:
    第0趟结果:
    [19, 199, 4, 77, 2, 12]
    [19, 4, 199, 77, 2, 12]
    [19, 4, 77, 199, 2, 12]
    [19, 4, 77, 2, 199, 12]
    [19, 4, 77, 2, 12, 199]
    第1趟结果:
    [4, 19, 77, 2, 12, 199]
    [4, 19, 77, 2, 12, 199]
    [4, 19, 2, 77, 12, 199]
    [4, 19, 2, 12, 77, 199]
    第2趟结果:
    [4, 19, 2, 12, 77, 199]
    [4, 2, 19, 12, 77, 199]
    [4, 2, 12, 19, 77, 199]
    第3趟结果:
    [2, 4, 12, 19, 77, 199]
    [2, 4, 12, 19, 77, 199]
    第4趟结果:
    [2, 4, 12, 19, 77, 199]
    第三版:
    第0趟结果:
    [19, 199, 4, 77, 2, 12]
    [19, 4, 199, 77, 2, 12]
    [19, 4, 77, 199, 2, 12]
    [19, 4, 77, 2, 199, 12]
    [19, 4, 77, 2, 12, 199]
    第1趟结果:
    [4, 19, 77, 2, 12, 199]
    [4, 19, 77, 2, 12, 199]
    [4, 19, 2, 77, 12, 199]
    [4, 19, 2, 12, 77, 199]
    第2趟结果:
    [4, 19, 2, 12, 77, 199]
    [4, 2, 19, 12, 77, 199]
    [4, 2, 12, 19, 77, 199]
    第3趟结果:
    [2, 4, 12, 19, 77, 199]
    [2, 4, 12, 19, 77, 199]
    第4趟结果:
    [2, 4, 12, 19, 77, 199]

    展开全文
  • Java实现冒泡排序算法

    2021-03-23 15:31:00
    Java实现冒泡排序
  • JAVA实现冒泡排序

    2020-01-14 17:11:24
    目录 前言 第壹节 冒泡排序JAVA实现 1、1 代码实现 1.2 测试结果 第贰节 冒泡排序概念 ...学习本章你将学会---如何使用JAVA的实现冒泡排序! 第壹节 冒泡排序JAVA实现 1、1 代码实现 pac...

    目录

     

    前言

    第壹节 冒泡排序JAVA实现

    1、1 代码实现

    1.2 测试结果

    第贰节 冒泡排序概念

    第叄节 算法原理 

    第肆节 实现原理图

    第伍节 时间复杂度。

    第陆节 冒泡排序的优化

    结果

    结语

    参考文献 


    前言

    本章用于冒泡排序的代码分析。学习本章你将学会---如何使用JAVA的实现冒泡排序!

    第壹节 冒泡排序JAVA实现

    1、1 代码实现

    package test01;
    
    public class TestSort {
        public static void bubbleSort(int[] arrary){
            //从第一个元素开始,向后依次成对比较,逆序则交换。
            //对所有的元素都进行这一操作 。
            int temp ;
            for(int i = 0 ; i < arrary.length-1; i++){
                for(int j = 0; j <arrary.length-1;j++){
                    //1、比较第一对相邻的元素。判断第一个元素是否大于第二个元素如果是则交换.
                    //2、此时要比较的是第J-1个元素。要不停的向后移动
                    if(arrary[j]>arrary[j+1]){
                        temp = arrary[j];
                        arrary[j] = arrary[j+1];
                        arrary[j+1] = temp;
                    }
                }
                System.out.print("第"+(i+1)+"轮");
                for(int j:arrary) {
                    System.out.print(j + ",");
                }
                System.out.println();
            }
        }
        public static void main(String[]args){
            int [] arrary = {3,5,1,-7,4,9,-6,8,10,4};;
            TestSort.bubbleSort(arrary);
        }
    }

    1.2 测试结果

    第贰节 冒泡排序概念

    1、冒泡排序(Bubble Sort),是一种计算机科学领域的较简单的排序算法

    2、它重复地走访过要排序的元素列,依次比较两个相邻的元素,如果顺序(如从大到小、首字母从从Z到A)错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换,也就是说该元素列已经排序完成。

    3、这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端(升序或降序排列),就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样,故名“冒泡排序”。来自百度百科。

    第叄节 算法原理 

    1. 比较相邻的元素。如果第一个比第二个大,就交换他们两个。 

    2. 对每一对相邻元素做同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的数。

    3. 针对所有的元素重复以上的步骤,除了最后一个。 

    4. 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。

    第肆节 实现原理图

     

    第伍节 时间复杂度。

    • 时间复杂度:
      两层循环,第1次遍历n次(n个元素),第二次遍历n-1次,... 依次类推。因此,表达式如下:
    • N+(N-1)+(N-2)+...+1 = N*(N+1)/2=O(n2)
    • 空间复杂度:
      没有利用新的数组来帮助完成排序算法,我们认为其空间复杂度为
    • O(1)

    时间复杂度产生的原因。

    若文件的初始状态是正序的,一趟扫描即可完成排序。所需的关键字比较次数

     和记录移动次数

     均达到最小值:

     ,

     

    所以,冒泡排序最好的时间复杂度


      若初始文件是反序的,需要进行

     趟排序。每趟排序要进行

     次关键字的比较(1≤i≤n-1),且每次比较都必须移动记录三次来达到交换记录位置。在这种情况下,比较和移动次数均达到最大值: [1] 

    冒泡排序的最坏时间复杂度为

     

    综上,因此冒泡排序总的平均时间复杂度为

     

    再次先说明排序稳定与不稳定的区别。

    说明:

    稳定:如果a原本在b前面,而a=b,排序之后a仍然在b的前面;

    不稳定:如果a原本在b的前面,而a=b,排序之后a可能会出现在b的后面;

    内排序:所有排序操作都在内存中完成;

    外排序:由于数据太大,因此把数据放在磁盘中,而排序通过磁盘和内存的数据传输才能进行;

    第陆节 冒泡排序的优化

    第1轮3,1,-7,4,5,-6,8,9,4,10,
    第2轮3,-7,1,4,-6,5,8,4,9,10,
    第3轮3,-7,1,-6,4,5,4,8,9,10,
    第4轮3,-7,1,-6,4,4,5,8,9,10,

    -----实际上但排序了4次以后我们已经完成了整个数组的排序。后面的5轮都是无意义的。
    第5轮3,-7,1,-6,4,4,5,8,9,10,
    第6轮3,-7,1,-6,4,4,5,8,9,10,
    第7轮3,-7,1,-6,4,4,5,8,9,10,
    第8轮3,-7,1,-6,4,4,5,8,9,10,
    第9轮3,-7,1,-6,4,4,5,8,9,10,

    从以上结果我们可以看出,当我们第4轮排序以后我们就已经不在进行了排序,因此我们可以确定当元素不在进行交换的时候我们就能确定整个排序实际上已经完成了。

    优化后代码为:

     public static void bubbleSort(int[] arrary){
            //从第一个元素开始,向后依次成对比较,逆序则交换。
            //对所有的元素都进行这一操作 。
            int temp ;
            boolean success ;
            for(int i = 0 ; i < arrary.length-1; i++){
                //一开始就是成功了
                success=true;
                for(int j = 0; j <arrary.length-1 ;j++){
                    //1、比较第一对相邻的元素。判断第一个元素是否大于第二个元素如果是则交换.
                    //2、此时要比较的是第J-1个元素。要不停的向后移动
                    if(arrary[j]>arrary[j+1]){
                        temp = arrary[j];
                        arrary[j] = arrary[j+1];
                        arrary[j+1] = temp;
                        //进行优化 1、当不在比较失败的时候我们就退出整个循环
                        //证明还在排序
                        success=false;
                    }
                }
                //如果没有排序了我们则认为已经完成了所有的排序
                if(success){
                    break;
                }
                System.out.print("第"+(i+1)+"轮"+success);
                for(int j:arrary) {
                    System.out.print(j + ",");
                }
                System.out.println();
            }
        }

    结果

    结语

    冒泡排序作为8种基础排序之一是必须要掌握的算法,实际工作中使用频率也非常高。其次,本文采用先展示代码,博主个人认为博客因该尽量短小精悍,主要的内容在3分钟内解释完!更多的感悟肯能会出现在结语部分。

     

    参考文献 

    排序-冒泡排序 https://www.jianshu.com/p/1458abf81adf 

    必须掌握的八种基本排序算法:冒泡排序  https://www.jianshu.com/p/88759596c944

    值得收藏的十大经典排序算法 https://www.toutiao.com/a6593273307280179715/?iid=6593273307280179715

    冒泡排序 https://baike.baidu.com/item/%E5%86%92%E6%B3%A1%E6%8E%92%E5%BA%8F/4602306?fr=aladdin

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,338
精华内容 2,535
关键字:

java实现冒泡排序

java 订阅