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

    2020-11-05 22:29:38
    java冒泡排序算法

    ## 数组之冒泡排序

    1、算法思想

        对比相邻的元素,如果满足条件就交换位置,把较小的值放在数组的前面,大的放在数组后面,这样较小的元素就像气泡一样
    从底部上升到顶部。
    

    2、算法实例

    	冒泡排序由双层循环实现,外层循环控制排序的轮数,一般为要排序的数组长度减1,因为最后一次循环只剩一下一个元素,不
    需要再进行相邻元素比较,即可完成排序;内层循环则用于对比相邻两个元素的大小,来确定是否需要交换位置。对比的次数也随
    着轮数的增加而减少,因为每一轮的冒泡会把最大的放在最后面。
    	数组有5个元素的排序过程如图所示:
    

    第一轮循环把最大的31放在了最后面,比31小的元素向前移动,类似于气泡上升,第二轮循环31就不再进行比较,因为它已经被确认为最大,其他元素依次跟相邻的元素进行比较,最后得到除了31之外的最大值23放在31的前一个位置。其他循环将以此类推,继续排序。

    3、程序实现

    public class Bubblesort {
        public static void main(String[] args) throws Exception {
            //冒泡排序
            int[] array = {15,4,31,23,7};
            //创建冒泡排序的对象
            Bubblesort sorter = new Bubblesort();
            //调用排序方法将数组排序
            sorter.sort(array);
        }
        /**
         * 冒泡排序
         * @param array  要排序的数组
         */
        public void sort(int[] array){
            for(int i = 1;i<array.length;i++){
                //比较相邻两个元素,较大的数往后冒泡
                for(int j = 0;j<array.length-i;j++){
                    if(array[j]>array[j+1]){
                        int temp = array[j];
                        array[j] = array[j+1];
                        array[j+1] = temp;
                    }
                }
            }
            System.out.println("从小到大排序后的结果为:");
            showArray(array);
        }
        /**
         * 显示数组中的所有元素
         *@param 要显示的数组
         */
        public void showArray(int[] array){
            for(int i:array){
                System.out.print(" "+i);
            }
            System.out.println();
        }
    }
    

    4、结果

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

    2015-08-30 11:59:21
    java冒泡排序,简洁而优雅的实现了冒泡排序的算法
  • JAVA冒泡排序算法

    2017-10-17 17:19:54
    冒泡排序算法详细分析那还等hi实地阿基hihi大UI一及对阿迪年hiue一群
  • java 冒泡排序法

    2010-06-18 16:52:40
    java 冒泡排序法 java 冒泡排序法
  • java冒泡排序算法代码

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

    2020-11-20 19:38:25
    基于java实现冒泡排序算法 算法描述: 比较相邻的两个元素,如果前面的比后面的大,则交换两个元素; 对每每相邻的元素都进行这样的比较操作,从开始的一对到最后一对,这样最后的元素会是本次遍历完剩下的最大的...

    基于java实现冒泡排序算法

    算法描述:

    • 比较相邻的两个元素,如果前面的比后面的大,则交换两个元素;
    • 对每每相邻的元素都进行这样的比较操作,从开始的一对到最后一对,这样最后的元素会是本次遍历完剩下的最大的元素;
    • 针对所有的元素执行以上步骤,除了已经指派出来的最大的元素(或序列,序列排在了最末尾)
    • 重复以上步骤直至排序完成。

    冒泡算法进行升序排列:

    public static void main(String[] args) {
            // 使用冒泡法进行升序排列
            int [] number = {1,3,4,2,5,9,6,8,7};
            for (int i = 0; i <number.length ; i++) {
                for (int j = i+1; j <number.length ; j++) {
                    if (number[i]>number[j]){
                        int change1 = number[j];
                        number[j] = number[i];
                        number[i] = change1;         //交换双方的值
                    }
                }
            }
            for (int i : number) {
                System.out.print(i);
            }
      }
    

    冒泡算法进行降序排列

    public static void main(String[] args) {
            // 使用冒泡法进行升序排列
            int [] number = {1,3,4,2,5,9,6,8,7};
            for (int i = 0; i <number.length ; i++) {
                for (int j = i+1; j <number.length ; j++) {
                    if (number[i]<number[j]){
                        int change1 = number[j];
                        number[j] = number[i];
                        number[i] = change1;         //交换双方的值
                    }
                }
            }
            for (int i : number) {
                System.out.print(i);
            }
      }
    

    使用java中的sort方法进行进行升序降序

    public static void main(String[] args) {
            // 使用sort方法进行升序
            int [] number3 = {1,3,4,2,5,9,6,8,7};
            Arrays.sort(number3);
            for (int i : number3) {
                System.out.print(i);
            }
            System.out.println();
    
            // 进行降序
            for (int i = number3.length-1; i >=0 ; i--) {
                System.out.print(number3[i]);
            }
        }
    

    展开全文
  • Java冒泡排序法

    2013-06-17 11:25:23
    Java冒泡排序法,非常实用,企业用人最爱考的问题
  • 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冒泡排序算法(最基础版本) 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冒泡排序法

    2016-10-09 16:21:51
    JAVA冒泡排序的简单用法

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 53,509
精华内容 21,403
关键字:

java冒泡排序法

java 订阅