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

    2015-07-28 20:28:13
    冒泡排序算法,Java语言写的,里面附了运行截图,分享给大家。
  • 交换排序之冒泡排序 Java代码: 算法思想:将要排序的序列,在序列内部的相邻序列进行两两比较,如果为逆序(A【d】》A【d+1】)就交换。 实列: 这就是一次冒泡的过程,在重复冒泡过程(如果序列长度为n,那么...

    交换排序之冒泡排序  Java代码:

    算法思想:将要排序的序列,在序列内部的相邻序列进行两两比较,如果为逆序(A【d】》A【d+1】)就交换。

    实列:

    这就是一次冒泡的过程,在重复冒泡过程(如果序列长度为n,那么需要冒泡的次数应该就是n-1次)

    特点:由于冒泡的过程可以从前往后进行冒泡(每次冒泡都会找到该序列的最大值)也可以从后往前冒泡两种方式(每次冒泡都会找到该序列的最小值

    Java代码:

    public static void bubbleInsort(int[] arr) {
        int i,j; //循环变量
        int temp = 0; //用于交换的第三方变量
        boolean flag; //判断序列是否完成了冒泡排序(就是序列是否已经有序)
        for (i=0;i<arr.length-1;i++){ //冒泡次数
            flag = false;
            for (j=arr.length-1;j>i;j--){ //从后往前比较相邻元素
                if (arr[j-1]>arr[j]){ //交换条件
                    temp = arr[j-1];
                    arr[j-1] = arr[j];
                    arr[j] = temp;
                }
                flag = true;
            }
            if (flag == false){
                return;
            }
        }
    }
    
    public static void main(String[] args) {
        int [] arr = {3,7,2,8,6,9,1,4,5};
        bubbleInsort(arr);
        for (int i =0;i<arr.length;i++){ //升序输出序列
            System.out.print(arr[i]+" ");
        }
        System.out.println("-----------------------------------");
        for (int i =arr.length-1;i>=0;i--){ //逆序输出序列
            System.out.print(arr[i]+" ");
        }
    }

     

     

     

    展开全文
  • 我的冒泡排序java代码+简单优化测试

    千次阅读 2019-11-29 04:04:26
    关于冒泡排序是什么怎么排序的我就不多赘述了,基本简单查找翻阅一下资料都可以...(1)下面是一般的冒泡排序java代码: int arry[] = { 3, 2, 6, 8, 1, 9, 5 }; for (int i = 0; i < arry.length; i++) { ...

    关于冒泡排序是什么怎么排序的我就不多赘述了,基本简单查找翻阅一下资料都可以弄明白,我这里是用冒泡排序的算法编写简单的java代码以及进行一些优化和之间的性能小评测。
    一、代码+讲解
    (1)下面是一般的冒泡排序java代码:

    		int arry[] = { 3, 2, 6, 8, 1, 9, 5 };
    		for (int i = 0; i < arry.length-1; i++) {
    			for (int j = 0; j < arry.length - 1 - i; j++) {
    				if (arry[j] > arry[j + 1]) {
    					int temp;
    					temp = arry[j + 1];
    					arry[j + 1] = arry[j];
    					arry[j] = temp;
    				}
    			}
    		}
    

    (2)下面是优化1的冒泡排序java代码:

    		int arry[] = { 3, 2, 6, 8, 1, 9, 5 };
    		boolean flag;//是否可以提前收工呢
    		for (int i = 0; i < arry.length-1; i++) {
    			flag = true;
    			for (int j = 0; j < arry.length - 1 - i; j++) {
    				if (arry[j] > arry[j + 1]) {
    					int temp;
    					temp = arry[j + 1];
    					arry[j + 1] = arry[j];
    					arry[j] = temp;
    					flag = false;//还在交换数据呀
    				}
    			}
    			if (flag) {
    				break;//提前收工咯
    			}
    		}
    

    上面代码比前面的多了一个变量flag,这个变量是用来在每次排完序(这里的每次是指内层for循环完毕)判断是否所有数据都排好序了(意思就是内层整个循环完都没发现有数据交换位置),既然都排好序了,那么就可以提前收工了呗。为了更直观看到什么时候收工,我只好放图了:
    fsq-0
    fsq-1
    上面第一个图是普通的冒泡排序,第二个图是优化1的冒泡排序过程图。用中括号括起来的表示已经排好序的数据,箭头以左表示排序区域,以右是不做处理区域。对比普通冒泡排序,优化1在第5次循环的时候已经提前收工了,因为它知道都排好序了。当然数据错乱情况不同排序的次数也会有所不同,但起码优化1有提前收工的机会,而普通冒泡则是老实儿干到最后。
    (3)还没完呢,我先放代码,这是我的优化2代码:

    		int swapIndex = 0;// 记录每次交换位置的下标
    		int sortedLength = 0;// 每一轮已经排好序的长度
    		for (int i = 0; i < arry.length-1; i++) {
    			for (int j = 0; j < arry.length - 1 - sortedLength; j++) {
    				if (arry[j] > arry[j + 1]) {
    					int temp;
    					temp = arry[j + 1];
    					arry[j + 1] = arry[j];
    					arry[j] = temp;
    					swapIndex = j;//打开小本本记录本次排序排到哪了
    				}
    			}
    			if (swapIndex == 0) {//查看小本本
    				break;//如果完事就直接走人。
    			}
    			//根据小本本自己算一下哪些工作量不用再做了
    			sortedLength = (arry.length - 1 - swapIndex);
    			
    		}
    

    这个对比优化1呢更精明一些,还懂得自己记录每次排完序的情况,然后根据上次的情况减少无谓的工作量,不是很直观?那我再放图咯:
    fsq-1
    fsq-2
    看到了吧,第二图优化后是不是跟我们人的思维符合,知道数据都有序了直接收工下班,因为时间很宝贵,不过呢对比优化1呢会浪费一点点资源,毕竟记小本本是需要花费一些力气的嘛。那到底3种冒泡排序的性能如何?下面有请我的简单小测为大家展现一下好了。

    一、测试+总结
    直接上测试图(说了简单测试当然是简单点来咯:每种冒泡方法循环一万次)
    (1)普通冒泡排序
    fsq-3
    (2)优化1冒泡排序
    fsq-4
    (3)优化2冒泡排序
    fsq-5
    看完上图想必大家都能看出孰优孰略了,优化2无疑是速度最快的,普通版则资源消耗最少,优化1折中。但是对于一般情况使用肯定是快比较宝贵,快代表效率,代表快乐嘛,咳咳,扯远了。其实上面系统资源消耗的量以及差距很小,可以不做重要参考,反正快就对了,咱不差那点消耗。后面再补充一个之前看到的一小段代码,然后自己测试了一下,代码如下:

    				if (arry[j] > arry[j + 1]) {
    					arry[j + 1] ^= arry[j];
    					arry[j] ^= arry[j + 1];
    					arry[j + 1] ^= arry[j];
    				}
    

    就是冒泡排序中交换位置的那部分的另一版代码,它是通过减少使用中间变量+使用位运算的方式优化,我原本以为会有不错的优化效果,通过跟上面相同测试发现没有任何的变化,我想可能是优化效果太微小看不出来,也可以从另一个角度发现,之前的那种使用中间变量相互赋值的交换方式没有造成冒泡排序的性能短板(Maybe)。总之呢,上面位运算容易记错又看不出来啥效果,就没必要去深究了,不过用来装装B我看是可以的!
    好了愉快的分享时间总是短暂的,不过我的学习之路还很漫长,欢迎大家点评指点一下我这个第一次发表文章的小白程序猿,请多多指教-O(∩_∩)O-嘤嘤嘤~

    最后把所有代码整合一下放后面好了:

    
    public class test{
    
    	// 冒泡排序1:从小到大
    	public static void bubbleSort01(int[] arry) {
    		for (int i = 0; i < arry.length-1; i++) {
    			for (int j = 0; j < arry.length - 1 - i; j++) {
    				if (arry[j] > arry[j + 1]) {
    					int temp;
    					temp = arry[j + 1];
    					arry[j + 1] = arry[j];
    					arry[j] = temp;
    				}
    			}
    		}
    	}
    
    	// 冒泡排序2:从小到大
    	public static void bubbleSort02(int[] arry) {
    		boolean flag;
    		for (int i = 0; i < arry.length-1; i++) {
    			flag = true;
    			for (int j = 0; j < arry.length - 1 - i; j++) {
    				if (arry[j] > arry[j + 1]) {
    					int temp;
    					temp = arry[j + 1];
    					arry[j + 1] = arry[j];
    					arry[j] = temp;
    					flag = false;
    				}
    			}
    			if (flag) {
    				break;
    			}
    		}
    	}
    
    	// 冒泡排序3:从小到大
    	public static void bubbleSort03(int[] arry) {
    		int swapIndex = 0;// 记录每次交换位置的下标
    		int sortedLength = 0;// 每一轮已经排好序的长度
    		for (int i = 0; i < arry.length-1; i++) {
    			for (int j = 0; j < arry.length - 1 - sortedLength; j++) {
    				if (arry[j] > arry[j + 1]) {
    					int temp;
    					temp = arry[j + 1];
    					arry[j + 1] = arry[j];
    					arry[j] = temp;
    					swapIndex = j;
    				}
    //				if (arry[j] > arry[j + 1]) {
    //					arry[j + 1] ^= arry[j];
    //					arry[j] ^= arry[j + 1];
    //					arry[j + 1] ^= arry[j];
    //					swapIndex = j;
    //				}
    			}
    			sortedLength = (arry.length - 1 - swapIndex);
    			if (swapIndex == 0) {
    				break;
    			}
    		}
    	}
    
    	public static void main(String[] args) {
    		int arry[] = { 3, 2, 6, 8, 1, 9, 5 };
    		bubbleSort01(arry);
    //		bubbleSort02(arry);// 优化1
    //		bubbleSort03(arry);// 优化2
    		for (int i = 0; i < arry.length; i++) {
    			System.out.print(arry[i] + " ");
    		}
    	}
    
    }
    
    
    展开全文
  • 冒泡排序: 这是学编程后都会遇到的一种排序算法,简单来说就是两两比较,如果前面大于后面,交换,否则不交换,之后指针向前移动,继续判断。 代码部分也很简单,一看就能明白其原理,这里不再进行赘述。 java代码...

    冒泡排序:

    这是学编程后都会遇到的一种排序算法,简单来说就是两两比较,如果前面大于后面,交换,否则不交换,之后指针向前移动,继续判断。
    代码部分也很简单,一看就能明白其原理,这里不再进行赘述。

    java代码:

    public void toBubbleSort(int []arr) {
    	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;
    			}
    		}
    	}
    }
    

    函数调用,输出结果:

    在这里插入图片描述
    在这里插入图片描述

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

    万次阅读 多人点赞 2019-05-31 20:36:29
    冒泡排序 冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如果它们的顺序错误就把它们交换过来。 走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。 ...

    冒泡排序

    冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如果它们的顺序错误就把它们交换过来。

    走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。

    这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

    算法描述

    1. 比较相邻的元素。如果第一个比第二个大,就交换它们两个;
    2. 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对,这样在最后的元素是最大的数;
    3. 针对所有的元素重复以上的步骤,除了最后一个;
    4. 重复步骤1~3,直到排序完成。

    算法分析

    • 时间复杂度
      • 最好情况:O(n)
      • 最坏情况:O(n2)
      • 平均情况:O(n2)
    • 空间复杂度:O(1)
    • 稳定性:稳定

    代码实现

    public class BubbleSort {
        public static void bubbleSort(int[] arr) {
            // 空数组 或 只有一个元素的数组,则什么都不做。
            if (arr == null || arr.length == 1) return;
    
            // 外层循环表示趟数。
            for (int i = 0; i < arr.length - 1; i++) {
    
                // 默认有序,如果发生交换说明无序。
                boolean isSorted = true;
    
                // j 表示 要比较元素对的第一个。
                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;
                        // 发生交换了,说明无序。
                        isSorted = false;
                    }
                }
    
                // 如果没有发生交换,则数组已经有序,结束冒泡。
                if (isSorted)   return;
    
                // 把每一趟排序的结果也输出一下。
                System.out.print("第 "+ (i+1) + " 趟: ");
                print(arr);
            }
        }
    
        public static void main(String[] args) {
            int[] arr = {6, 9, 1, 4, 5, 8, 7, 0, 2, 3};
    
            System.out.print("排序前:  ");
            print(arr);
    
            bubbleSort(arr);
    
            System.out.print("排序后:  ");
            print(arr);
        }
    
        // 打印数组
        public static void print(int[] arr) {
            if (arr == null)    return;
    
            for(int i : arr) {
                System.out.print(i + " ");
            }
            System.out.println();
        }
    }
    /*
    排序前:  6 9 1 4 5 8 7 0 2 3 
    第 1 趟: 6 1 4 5 8 7 0 2 3 9 
    第 2 趟: 1 4 5 6 7 0 2 3 8 9 
    第 3 趟: 1 4 5 6 0 2 3 7 8 9 
    第 4 趟: 1 4 5 0 2 3 6 7 8 9 
    第 5 趟: 1 4 0 2 3 5 6 7 8 9 
    第 6 趟: 1 0 2 3 4 5 6 7 8 9 
    第 7 趟: 0 1 2 3 4 5 6 7 8 9 
    排序后:  0 1 2 3 4 5 6 7 8 9
    */

     

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

    万次阅读 2019-01-10 16:20:42
    public class BubbleSort { public static int[]sort(int[] array){ for (int i = 1; i ; i++) { boolean flag=true;... System.out.println("经过冒泡排序后的数组顺序为:"); display(array); } }  
  • class Bubble{ //冒泡排序 static void BubbleSort(int[] a){ for(int i=0;i;i++){ for(int j=0;j;j++){ if(a[j]>a[j+1]){
  • java冒泡排序算法代码

    2020-09-04 23:44:44
    介绍了java冒泡排序算法代码,有需要的朋友可以参考一下
  • 主要介绍了java List 排序之冒泡排序实例代码的相关资料,需要的朋友可以参考下
  • java冒泡排序 代码为排序源代码 简洁明了 无其他
  • java代码-冒泡排序-Java

    2021-07-16 13:27:26
    java代码-冒泡排序-Java
  • 今天小编就为大家分享一篇关于Java算法之冒泡排序实例代码,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
  • java冒泡排序代码

    2018-08-06 21:28:52
    java冒泡排序代码,亲测能用,控制台输入数据,自动排序
  • 冒泡和选择排序Java代码实现,简单的算法,适合新手入门级程序。
  • 冒泡排序 java

    2013-05-24 09:34:03
    冒泡排序java代码实现 ,附带注释等详细介绍
  • 主要介绍了java 数据结构 冒泡排序的相关资料,并附实例代码,有需要的小伙伴可以参考下
  • 文章目录冒泡排序源码实现单元测试优化快速排序源码实现单元测试 冒泡排序 源码实现 package csdn.dreamzuora.sort; import java.util.List; /** * Title: 冒泡排序 * Description: * 冒泡排序思想是把相邻的...
  • 主要介绍了Java实现冒泡排序与双向冒泡排序算法的代码示例,值得一提的是所谓的双向冒泡排序并不比普通的冒泡排序效率来得高,注意相应的时间复杂度,需要的朋友可以参考下
  • 冒泡排序(Bubble Sorting)的基本思想是:通过对待 排序序列从前向后(从下标较小的元素开始),依次比较 相邻元素的值,若发现逆序则交换,使值较大 的元素逐渐从前移向后部,就象水底下的气泡一样逐渐 向上冒 ...
  • 主要介绍了Java 冒泡排序、快速排序实例代码,需要的朋友可以参考下
  • JAVA冒泡排序-代码

    千次阅读 2018-03-27 15:11:58
    冒泡排序刚开始学习循环,之后接触到数组的排序,知道了这个冒泡排序这是代码//冒泡  int[] arr = {5,4,3,2,1};  for(int i = 0;i&lt;arr.length-1;i++){   for(int j = 0;j&lt;arr.length-1-i;j++){ .....
  • java 代码实例 冒泡排序 直接插入排序 数组中插入数据
  • 本文主要介绍了java冒泡排序和快速排序的实例代码。具有很好的参考价值。下面跟着小编一起来看下吧
  • java代码-冒泡排序算法

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 42,840
精华内容 17,136
关键字:

冒泡排序java代码

java 订阅