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

    2020-09-04 23:44:44
    介绍了java冒泡排序算法代码,有需要的朋友可以参考一下
  • Java冒泡排序算法

    2013-12-22 22:55:52
    Java语言实现的冒泡排序算法代码里头有详细注释,注释皆为简单英文,这个算法比较经典,欢迎新手下载学习使用,欢迎后期的学习交流!
  • // Java冒泡排序算法(最基础版本) import java.util.Arrays; //研究冒泡排序 public class BubbleSort { public static void main(String[] args) { //arrays自带的排序方法 int[] a = {3,1,4,5,6}; /*...

    最基础的冒泡排序算法

    // Java冒泡排序算法(最基础版本)
    import java.util.Arrays;
    
    //研究冒泡排序
    public class BubbleSort {
    	public static void main(String[] args) {
    		//arrays自带的排序方法
    		int[] a = {3,1,4,5,6};
    		/*Arrays.sort(a);
    		System.out.println(Arrays.toString(a));*/
    		int inner = 0;
    		int outner = 0;
    		
    		for (int j = 0; j < a.length; j++) {
    			for (int i = 0; i < a.length-1; i++) {
    				if (a[i]>a[i+1]) {
    					int temp = a[i];
    					a[i] = a[i+1];
    					a[i+1] = temp;
    				}
    				System.out.println("当前内循环的次数:" + (++inner));
    			}
    			System.out.println("当前外循环的次数为:" + (++outner)+"当前数组的输出为:"+Arrays.toString(a));
    		}
    		
    		System.out.println(Arrays.toString(a));
    		
    	}
    }
    

    算法输出如下:
    在这里插入图片描述

    这是大多数人第一次写出来的冒泡排序算法(为了下面更加直观的表现出来优化算法的好坏,直接在代码里面记录一下内外循环的次数),每一个学习Java的未来程序员,可能都会经历这个最基础的算法,而你想没想过为这个算法做一些优化呢?
    下面我总结出来的算法的两种优化:

    优化算法(一).关于减少每次遍历数组的次数

    // 第一次优化
    import java.util.Arrays;
    
    //研究冒泡排序
    public class BubbleSort {
    	public static void main(String[] args) {
    		//arrays自带的排序方法
    		int[] a = {3,1,4,5,6};
    		/*Arrays.sort(a);
    		System.out.println(Arrays.toString(a));*/
    		int inner = 0;
    		int outner = 0;
    		
    		for (int j = 0; j < a.length-1; j++) {
    			for (int i = 0; i < a.length-1-j; i++) {
    				if (a[i]>a[i+1]) {
    					int temp = a[i];
    					a[i] = a[i+1];
    					a[i+1] = temp;
    				}
    				System.out.println("当前内循环的次数:" + (++inner));
    			}
    			
    			System.out.println("当前外循环的次数为:" + (++outner)+"当前数组的输出为:"+Arrays.toString(a));
    		}
    		
    		System.out.println(Arrays.toString(a));
    		
    	}
    }
    
    

    第一次优化后的输出如下:
    在这里插入图片描述
    整整减少了一半的内循环的次数!!!
    通过每次内循环得到一个最大值放到数组的结尾,第二次遍历直接跳过这个数.得到了第一次的优化!

    利用开闭原则进行提前中断遍历(最终版)

    // 利用闭合原则对算法的二次优化
    import java.util.Arrays;
    
    //研究冒泡排序
    public class BubbleSort {
    	public static void main(String[] args) {
    		//arrays自带的排序方法
    		int[] a = {3,1,4,5,6};
    		/*Arrays.sort(a);
    		System.out.println(Arrays.toString(a));*/
    		int inner = 0;
    		int outner = 0;
    		
    		for (int j = 0; j < a.length-1; j++) {
    			boolean flag = true;
    			for (int i = 0; i < a.length-1-j; i++) {
    				if (a[i]>a[i+1]) {
    					flag = false;
    					int temp = a[i];
    					a[i] = a[i+1];
    					a[i+1] = temp;
    				}
    				System.out.println("当前内循环的次数:" + (++inner));
    			}
    			
    			System.out.println("当前外循环的次数为:" + (++outner)+"当前数组的输出为:"+Arrays.toString(a));
    			if (flag) {
    				System.out.println("提前就结束啦!");
    				break;
    			}
    		}
    		
    		System.out.println(Arrays.toString(a));
    		
    	}
    }
    
    

    算法的输出如下:
    在这里插入图片描述
    又一次的减少了遍历的次数!!!
    通过在外循环定义了一个Boolean类型的变量flag,如果内循环的if语句不执行的话,说明该次循环无元素移动,即此时数组已经排序完成,无须再进行排序.

    结语

    在我们初学Java的时候,不必要为了快而学习,要在学习了每个知识点之后对其进行较深的挖掘,可能你会找到其他不可思议的东西!!!

    展开全文
  • java冒泡排序算法

    2017-07-26 21:54:39
    java实现冒泡排序算法

    【冒泡排序(Bubble Sort)】

    原理

    重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来
    走访数列的工作是重复地进行直到没有再需要交换,即完成排序
    算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端

    运作
    第一轮比较
    1.比较1和2元素,交换或者保持
    2.比较2和3元素,交换或者保持
    3.以此类推

    4.经过第一轮比较,最大的数在最后

    第二轮比较
    步骤同上,但是最后一个数字不用参与比较了,因为已经是最大的了

    例子

    4个元素的数组
    第一轮比较元素1和2、2和3、3和4,最大的数字在第4位,比较了3次
    第二轮比较元素1和2、2和3,最大的数字在第3位,比较了2次
    第三轮比较元素1和2,最大的数字在第2位,比较了1次

    比较几轮(i)

    每轮比较几次(j)

    1

    3

    2

    2

    3

    1

    外层循环i表示几轮,内层循环j表示这一轮一共比较几次

    i+j等于数组的长度


    代码

    public class BubbleSort {
        public static void main(String[] args) {
            int score[] = { 100, 99, 90, 89, 87, 75, 69, 67 };
    	int size = score.length;
    	int temp = 0;
    	System.out.print("原始数据:          ");
    	printData(score);
    
    	// i表示循环几轮
    	for (int i = 0; i < arr.length - 1; i++) {
    	    // j表示每一轮循环中比较的次数
    	    // 随着i的增加,每一轮比较的次数越来越少
    	    for (int j = 0; j < arr.length - i - 1; j++) {
    	        //如果前面的数比较大,则交换相邻两个数
    		if (arr[j] > arr[j + 1]) {
    		    temp = arr[j];
    		    arr[j] = arr[j + 1];
    		    arr[j + 1] = temp;
    		}
    	    }
    	    System.out.print("第" + (i + 1) + "次排序结果:");
    	    printData(arr);
    	}
        }
    
        public static void printData(int score[]) {
            for (int a = 0; a < score.length; a++) {
    	    System.out.print(score[a] + "\t");
    	}
    	System.out.println("");
        }
    }

    结果

    原始数据:        100    99   90   89   87   75   69   67

    第1次排序结果:99     90   89   87   75   69   67   100

    第2次排序结果:90     89   87   75   69   67   99   100

    第3次排序结果:89     87   75   69   67   90   99   100

    第4次排序结果:87     75   69   67   89   90   99   100

    第5次排序结果:75     69   67   87   89   90   99   100

    第6次排序结果:69     67   75   87   89   90   99   100

    第7次排序结果:67 69   75   87   89   90   99   100
    展开全文
  • java冒泡排序算法实现

    2019-03-09 19:25:49
    简单的总结一下冒泡排序的实现: ... * @description java冒泡排序算法 * 原理:比较两个相邻的元素,将值大的元素交换至右端 */ public class BubblingSort { public static void main(String[] args) { ...

    简单的总结一下冒泡排序的实现:

    package arithmetic;
    
    /**
     * @author JasonLee
     * @description java的冒泡排序算法
     * 原理:比较两个相邻的元素,将值大的元素交换至右端
     */
    public class BubblingSort {
        public static void main(String[] args) {
            int arr[] = {5, 3, 1, 7, 9, 6, 2, 8};
            // 排序的次数
            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+1];
                        arr[j+1] = arr[j];
                        arr[j] = temp;
                    }
                }
            }
            for (int num: arr){
                System.out.println(num);
            }
        }
    }
    

     

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

    2020-12-07 16:51:41
    4、冒泡排序的思路 5、代码实现 1.排序的定义 所谓排序:就是使一串记录,按照其中的某个或某些关键字的大小,递增或递减的排列起来的操作。 排序算法,就是如何使得记录按照要求排列的方法。 排序算法,在很多领域...

    简介

    在写冒泡之前,我先简单的说明一些信息,方便同学们学习,比如:
    1、排序的定义
    2、排序的分类
    3、排序的基本情况
    4、冒泡排序的思路
    5、代码实现

    1.排序的定义

    所谓排序:就是使一串记录,按照其中的某个或某些关键字的大小,递增或递减的排列起来的操作。
    排序算法,就是如何使得记录按照要求排列的方法。
    排序算法,在很多领域得到相当地重视,尤其是在大量数据的处理方面。

    一个优秀的算法可以节省大量的资源。在各个领域中考虑到数据的各种限制和规范,要得到一个符合实际的优秀算法,得经过大量的推理和分析。

    2.排序的分类

    排序可以分类:内部排序和外部排序
    内部排序:数据记录在内存中进行排序
    外部排序:排序的数据很庞大,一次性不能容纳或处理全部的数据,在排序过程中需要访问外存
    外部排序就是把集合中的元素按照一定的次序排序在一起。一般来说有升序排列和降序排列2种排序,在算法中有8中基本排序,共计10总:
    (1)冒泡排序;
    (2)选择排序;
    (3)插入排序;
    (4)希尔排序;
    (5)归并排序;
    (6)快速排序;
    (7)基数排序;
    (8)堆排序;
    (9)计数排序;
    (10)桶排序。

    3.排序的基本情况

    这个图只罗列了部分排序,想要完整研究,请参考 / 翻阅其它资料
    在这里插入图片描述

    4.冒泡排序的思路

    > 冒泡排序算法:通过对相邻两个元素进行大小的比较,把较小的元素往前调或者把较大的元素往后调。

    第一步:首先将第1个和第2个记录,进行比较大小,如果是逆序的,就将这两个记录进行交换
    第二步:再对第2个和第3个记录,进行比较,依次类推,重复进行上述计算,直至完成第(n一1)个和第n个记录的之间的比较
    第三步:此后,再按照上述过程进行第2次、第3次排序,直至整个序列有序为止。

    特别注意:排序过程中当相邻两个元素大小一致时,这一步操作就不需要交换位置

    因此也说明冒泡排序是一种严格的稳定排序算法,它不改变序列中相同元素之间的相对位置关系。

    5.代码实现

    /**
     * description: 冒泡排序
     * auth: zengtao
     * time: 2020-12-07 15:45
     **/
    public class Main {
    
        public static void main(String[] args) {
        	// 数据 
            int arr[] = {9, 5, 2, 7, 4};
            // 冒泡
            sortBubble(arr);
      
    
        private static void sortBubble(int[] arr) {
            for (int i = 0; i < arr.length; i++) {
                // 外层循环,遍历次数
                for (int j = 0; j < arr.length - i - 1; j++) {
                    // 内层循环,升序(如果前一个值比后一个值大,则交换)
                    // 内层循环一次,获取一个最大值
                    if (arr[j] > arr[j + 1]) {
                        int temp = arr[j + 1];
                        arr[j + 1] = arr[j];
                        arr[j] = temp;
                        systemArr(arr);
                    }
                }
            }
        }
    
        private static void systemArr(int[] arr) {
            for (int i = 0; i < arr.length; i++) {
                System.out.print(arr[i] + " ");
            }
            System.out.println("");
        }
    }
    

    运行结果:
    在这里插入图片描述
    结论 vs 根据冒泡排序的思路

    1⃣️ 首先将第1个和第2个记录对比
    9, 5, 2, 7, 4 -------> 5, 9, 2, 7, 4
    2⃣️ 直至完成第(n一1)个和第n个记录
    5 2 9 7 4
    5 2 7 9 4
    5 2 7 4 9
    2 5 7 4 9
    2 5 4 7 9
    3⃣️ 最终结果
    2 4 5 7 9

    经过验证,每一个步骤都是按照思路来的,而且都是正确的,so,冒泡排序总结完毕!

    欢迎观看,Thanks !

    展开全文
  • 主要介绍了Java实现冒泡排序与双向冒泡排序算法代码示例,值得一提的是所谓的双向冒泡排序并不比普通的冒泡排序效率来得高,注意相应的时间复杂度,需要的朋友可以参考下
  • Java冒泡排序算法介绍

    2016-09-29 16:31:52
    冒泡排序(Bubble Sort)是一种简单的排序算法。它重复地遍历要排序的数列...1.冒泡排序算法的运作如下: 1. 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的数 2
  • java 冒泡排序算法

    2017-03-29 17:27:11
    import java.util.Scanner; /** * Created by wjz on 2017/3/29. * 冒泡排序 */ public class BubbleSort { public static void main(String[] args) { Scanner sc = new Scanner(System.in); i
  • 这段时间在学习数据结构与算法,看...一、冒泡排序算法的思路:  冒泡排序(Bubble Sort)是一种交换排序,它的基本思想是:两两比较相邻记录的关键字,如果反序则交换,直到没有反序的记录为止。 二、正宗冒泡算法ja
  • 主要介绍了浅析java双向冒泡排序算法,并附上源码,需要的朋友可以参考下
  • java冒泡排序算法,注释超多,跟着注释走就行了 1.话不多说,直接上代码 import java.util.Scanner; /** * 冒泡排序 * 1.冒泡排序的精髓是每次找出最大的,放在数组的最后,怎么找出最大的呢,利用交换位置 * 2....
  • java代码-冒泡排序算法
  • java冒泡排序算法总结

    2018-08-17 09:52:21
    冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。这个算法的...
  • 冒泡排序算法java面试中最常考的考点之一,我们应当熟记于心,理解冒泡排序的思想,那么对于初学者来说,是必要的。本人也是刚工作不到一年,本着学习的态度,将自己的见解与想法表达出来,如果有存在错误的地方,...
  • 本文是小编给大家带来的java各种排序算法知识,包括插入排序、选择排序算法、冒泡排序算法代码简单易懂,需要的朋友可以参考下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 33,644
精华内容 13,457
关键字:

java冒泡排序算法代码

java 订阅