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

    2021-08-04 19:40:41
    冒泡排序 思路:例如:a b c d----->abcd代表位置 第一次:a的位置与b的位置比较大小 然后b的位置与c的位置比较大小 再然后c的位置与d的位置比较大小 第二次:a的位置与b的位置比较大小 然后b的位置与c的位置比较...

    冒泡排序

    思路:例如:a b c d----->abcd代表位置
    第一次:a的位置与b的位置比较大小 然后b的位置与c的位置比较大小 再然后c的位置与d的位置比较大小

    第二次:a的位置与b的位置比较大小 然后b的位置与c的位置比较大小 因为d的位置已经是最大或最小了所以无需再比较 后面都如此

    代码

      public class Demo_work_2 {
        public static void main(String[] args) {
            //冒泡排序
            Random rand = new Random();
            int[] nums = new int[10];
            for (int i = 0; i < nums.length; i++) {
                nums[i] = rand.nextInt(100) + 1;
            }
            //排序前遍历输出
            print(nums);
            //开始冒泡
            for (int i = 0; i <nums.length ; i++) {
                for (int j = 0; j <nums.length-1-i ; j++) {
                    if (nums[j]<nums[j+1]){
                        int a=nums[j+1];
                        nums[j+1]=nums[j];
                        nums[j]=a;
                    }
                }
            }
            //排序后
            print(nums);
        }
        //数组遍历输出
        public static void print(int[] a) {
            for (int i : a) {
                System.out.printf("%d ", i);
            }
            System.out.println();
        }
    }
    
    
    展开全文
  • java实现冒泡排序算法,java冒泡算法冒泡排序的算法分析与改进交换排序的基本思想是:两两比较待排序记录的关键字,发现两个记录的次序相反时即进行交换,直到没有反序的记录为止。应用交换排序基本思想的主要排序...

    用java实现冒泡排序算法,java冒泡算法

    冒泡排序的算法分析与改进

    交换排序的基本思想是:两两比较待排序记录的关键字,发现两个记录的次序相反时即进行交换,直到没有反序的记录为止。

    应用交换排序基本思想的主要排序方法有:冒泡排序和快速排序。

    复制代码 代码如下:

    public class BubbleSort implements SortUtil.Sort{

    public void sort(int[] data) {

    int temp;

    for(int i=0;i

    for(int j=data.length-1;j>i;j--){

    if(data[j]

    SortUtil.swap(data,j,j-1);

    }

    }

    }

    }

    冒泡排序

    1、排序方法

    将被排序的记录数组R[1..n]垂直排列,每个记录R看作是重量为R.key的气泡。根据轻气泡不能在重气泡之下的原则,从下往上扫描数组R:凡扫描到违反本原则的轻气泡,就使其向上"飘浮"。如此反复进行,直到最后任何两个气泡都是轻者在上,重者在下为止。

    (1)初始

    R[1..n]为无序区。

    (2)第一趟扫描

    从无序区底部向上依次比较相邻的两个气泡的重量,若发现轻者在下、重者在上,则交换二者的位置。即依次比较(R[n],R[n-1]),(R[n-1],R[n-2]),…,(R[2],R[1]);对于每对气泡(R[j+1],R[j]),若R[j+1].key

    第一趟扫描完毕时,"最轻"的气泡就飘浮到该区间的顶部,即关键字最小的记录被放在最高位置R[1]上。

    (3)第二趟扫描

    扫描R[2..n]。扫描完毕时,"次轻"的气泡飘浮到R[2]的位置上……

    最后,经过n-1 趟扫描可得到有序区R[1..n]

    注意:第i趟扫描时,R[1..i-1]和R[i..n]分别为当前的有序区和无序区。扫描仍是从无序区底部向上直至该区顶部。扫描完毕时,该区中最轻气泡飘浮到顶部位置R上,结果是R[1..i]变为新的有序区。

    2、冒泡排序过程示例

    对关键字序列为49 38 65 97 76 13 27 49的文件进行冒泡排序的过程

    3、排序算法

    (1)分析

    因为每一趟排序都使有序区增加了一个气泡,在经过n-1趟排序之后,有序区中就有n-1个气泡,而无序区中气泡的重量总是大于等于有序区中气泡的重量,所以整个冒泡排序过程至多需要进行n-1趟排序。

    若在某一趟排序中未发现气泡位置的交换,则说明待排序的无序区中所有气泡均满足轻者在上,重者在下的原则,因此,冒泡排序过程可在此趟排序后终止。为此,在下面给出的算法中,引入一个布尔量exchange,在每趟排序开始前,先将其置为FALSE。若排序过程中发生了交换,则将其置为TRUE。各趟排序结束时检查exchange,若未曾发生过交换则终止算法,不再进行下一趟排序。

    (2)具体算法

    复制代码 代码如下:

    void BubbleSort(SeqList R)

    { //R(l..n)是待排序的文件,采用自下向上扫描,对R做冒泡排序

    int i,j;

    Boolean exchange; //交换标志

    for(i=1;i

    exchange=FALSE; //本趟排序开始前,交换标志应为假

    for(j=n-1;j>=i;j--) //对当前无序区R[i..n]自下向上扫描

    if(R[j+1].key

    R[0]=R[j+1]; //R[0]不是哨兵,仅做暂存单元

    R[j+1]=R[j];

    R[j]=R[0];

    exchange=TRUE; //发生了交换,故将交换标志置为真

    }

    if(!exchange) //本趟排序未发生交换,提前终止算法

    return;

    } //endfor(外循环)

    } //BubbleSort

    4、算法分析

    (1)算法的最好时间复杂度

    若文件的初始状态是正序的,一趟扫描即可完成排序。所需的关键字比较次数C和记录移动次数M均达到最小值:

    Cmin=n-1

    Mmin=0。

    冒泡排序最好的时间复杂度为O(n)。

    (2)算法的最坏时间复杂度

    若初始文件是反序的,需要进行n-1趟排序。每趟排序要进行n-i次关键字的比较(1≤i≤n-1),且每次比较都必须移动记录三次来达到交换记录位置。在这种情况下,比较和移动次数均达到最大值:

    Cmax=n(n-1)/2=O(n2)

    Mmax=3n(n-1)/2=O(n2)

    冒泡排序的最坏时间复杂度为O(n2)。

    (3)算法的平均时间复杂度为O(n2)

    虽然冒泡排序不一定要进行n-1趟,但由于它的记录移动次数较多,故平均时间性能比直接插入排序要差得多。

    (4)算法稳定性

    冒泡排序是就地排序,且它是稳定的。

    5、算法改进

    上述的冒泡排序还可做如下的改进:

    (1)记住最后一次交换发生位置lastExchange的冒泡排序

    在每趟扫描中,记住最后一次交换发生的位置lastExchange,(该位置之前的相邻记录均已有序)。下一趟排序开始时,R[1..lastExchange-1]是有序区,R[lastExchange..n]是无序区。这样,一趟排序可能使当前有序区扩充多个记录,从而减少排序的趟数。具体算法【参见习题】。

    (2) 改变扫描方向的冒泡排序

    ①冒泡排序的不对称性

    能一趟扫描完成排序的情况:

    只有最轻的气泡位于R[n]的位置,其余的气泡均已排好序,那么也只需一趟扫描就可以完成排序。

    【例】对初始关键字序列12,18,42,44,45,67,94,10就仅需一趟扫描。

    需要n-1趟扫描完成排序情况:

    当只有最重的气泡位于R[1]的位置,其余的气泡均已排好序时,则仍需做n-1趟扫描才能完成排序。

    【例】对初始关键字序列:94,10,12,18,42,44,45,67就需七趟扫描。

    ②造成不对称性的原因

    每趟扫描仅能使最重气泡"下沉"一个位置,因此使位于顶端的最重气泡下沉到底部时,需做n-1趟扫描。

    ③改进不对称性的方法

    在排序过程中交替改变扫描方向,可改进不对称性。

    JAVA代码:

    复制代码 代码如下:

    package Utils.Sort;

    /**

    *@author Linyco

    *利用冒泡排序法对数组排序,数组中元素必须实现了Comparable接口。

    */

    public class BubbleSort implements SortStrategy

    {

    /**

    *对数组obj中的元素以冒泡排序算法进行排序

    */

    public void sort(Comparable[] obj)

    {

    if (obj == null)

    {

    throw new NullPointerException("The argument can not be null!");

    }

    Comparable tmp;

    for (int i = 0 ;i < obj.length ;i++ )

    {

    //切记,每次都要从第一个开始比。最后的不用再比。

    for (int j = 0 ;j < obj.length - i - 1 ;j++ )

    {

    //对邻接的元素进行比较,如果后面的小,就交换

    if (obj[j].compareTo(obj[j + 1]) > 0)

    {

    tmp = obj[j];

    obj[j] = obj[j + 1];

    obj[j + 1] = tmp;

    }

    }

    }

    }

    }

    展开全文
  • package javase; import java.util.Arrays; public class Demo{ public static void main(String[] args){ ... System.out.println("冒泡排序前:"); for (int Array:arr){ System.out.print(Array+" ");.
    package javase;
    
    import java.util.Arrays;
    
    public class Demo{
        public static void main(String[] args){
           int[] arr={11,58,1,66,13,55,77,7};
    
           System.out.println("冒泡排序前:");
            for (int Array:arr){
                System.out.print(Array+" ");
    
            }
    
           for(int a=1;a<arr.length;a++){
               for(int b=0;b<arr.length-a;b++){
    
                   if (arr[b]>arr[b+1]){
                       int tmp=arr[b];  //把第一个元素保存在临时变量
                       arr[b]=arr[b+1];  //把第二个元素保存在第一个元素单元中
                       arr[b+1]=tmp;    //把临时的变量(即第一个元素)保存在第二个元素中
    
                   }
    
               }
    
    
    
            }
            System.out.println();
            System.out.println("冒泡排序后:");
            for (int Array:arr){
                System.out.print(Array+" ");
    
            }
        }
    
    }
    
    展开全文
  • 本文实例讲述了java利用冒泡排序对数组进行排序的方法。分享给大家供大家参考。具体如下:一、冒泡排序:利用冒泡排序对数组进行排序二、基本概念:依次比较相邻的两个数,将小数放在前面,大数放在后面。即在第一趟...

    本文实例讲述了java利用冒泡排序对数组进行排序的方法。分享给大家供大家参考。具体如下:

    一、冒泡排序:

    利用冒泡排序对数组进行排序

    二、基本概念:

    依次比较相邻的两个数,将小数放在前面,大数放在后面。即在第一趟:首先比较第1个和第2个数,将小数放前,大数放后。然后比较第2个数和第3个数,将小数放前,大数放后,如此继续,直至比较最后两个数,将小数放前,大数放后。至此第一趟结束,将最大的数放到了最后。在第二趟:仍从第一对数开始比较(因为可能由于第2个数和第3个数的交换,使得第1个数不再小于第2个数),将小数放前,大数放后,一直比较到倒数第二个数(倒数第一的位置上已经是最大的),第二趟结束,在倒数第二的位置上得到一个新的最大数(其实在整个数列中是第二大的数)。如此下去,重复以上过程,直至最终完成排序。

    三、实现思路:

    用二重循环实现,外循环变量设为i,内循环变量设为j。假如有n个数需要进行排序,则外循环重复n-1次,内循环依次重复n-1,n-2,...,1次。每次进行比较的两个元素都是与内循环j有关的,它们可以分别用a[j]和a[j+1]标识,i的值依次为1,2,...,n-1,对于每一个i,j的值依次为0,1,2,...n-i 。

    设数组长度为N:

    1.比较相邻的前后二个数据,如果前面数据大于后面的数据,就将二个数据交换。

    2.这样对数组的第0个数据到N-1个数据进行一次遍历后࿰

    展开全文
  • 冒泡排序:就是按索引逐次比较相邻的两个元素,如果大于/小于(取决于需要升序排还是降序排),则置换,否则不做改变这样一轮下来,比较了n-1次,n等于元素的个数;n-2, n-3 ... 一直到最后一轮,比较了1次所以比较...
  • java实现冒泡排序算法

    2021-03-08 00:38:35
    介绍冒泡排序是一种算法,比较相邻元素,如果他们处在错误的位置上,那么交换他们的位置。排序可以进行升序或者降序。原理从第一个元素开始,比较第一个元素和第二个元素,如果第一个元素大于第二个元素,那么交换...
  • 冒泡排序定义 冒泡排序(Bubble Sort)也是一种简单直观的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是...
  • java冒泡排序

    千次阅读 2021-03-05 17:57:41
    经典算法——冒泡排序(Bubble Sort)一、示例代码(伸手党看这里)1.示例一importjava.util.Arrays;public classBubbleSort {public static void bubbleSort(int[] arr){int temp; /*临时变量,交换数据时使用*/int ...
  • 冒泡排序的算法分析与改进交换排序的基本思想是:两两比较待排序记录的关键字,发现两个记录的次序相反时即进行交换,直到没有反序的记录为止。应用交换排序基本思想的主要排序方法有:冒泡排序和快速排序。冒泡排序...
  • java实现冒泡排序 一、冒泡排序: 利用冒泡排序对数组进行排序 二、基本概念: 依次比较相邻的两个数,将小数放在前面,大数放在后面。即在第一趟:首先比较第1个和第2个数,将小数放前,大数放后。然后比较第2个数...
  • java实现冒泡排序

    2021-03-05 16:08:03
    我们今天来实现冒泡排序。现在有这样一个需求:在数组中含有七个int类型的元素, 分别为 34,21,18,6,1,42,0;设计出一个算法完成从该数组的排序功能。我们知道排序,关键点在顺序上,可以从小到大,也可以从大到小。...
  • Java程序实现冒泡排序

    2021-03-18 10:41:47
    气泡排序是一种简单的排序算法。该排序算法是基于比较的算法,其中比较每对相邻元素,如果元素顺序不正确,则将其交换。该算法不适用于大型数据集,因为其平均和最坏情况下的复杂度为〇(n2),其中n是项数。示例...
  • 程序排序:public class TestDmo {public static void main(String[] args) {List list=getData();PaixuData [] paixuDataArr=new PaixuData[list.size()];list.toArray(paixuDataArr);PaixuData[] paixuData = ...
  • Java实现冒泡排序

    2021-03-12 20:02:01
    Java实现冒泡排序Java实现冒泡排序冒泡排序是一种不断交换相邻的元素的排序,一些元素在不断得被交换中,就像水中冒泡一样,因此得名冒泡排序。1.比较相邻的元素,如果前面元素比后面元素要小,那么则交换这两个元素...
  • 一、算法原理比较相邻的元素。如果第一个比第二个大,就交换他们两个。对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。...假如有n个数需要进行排序,则外循环重复n-1次,内循环依次...
  • public class Test { //创建主方法 public static void main(String[] args) { //创建变量,用来暂时接收数组内的数字 ... //写出程序需要从头到尾需要运行几趟 for (int i = 0; i <arr.length-1;
  • java实现数组冒泡排序的方法发布时间:2020-06-24 09:21:42来源:亿速云阅读:82作者:Leah本篇文章展示了java实现数组冒泡排序的具体操作,代码简明扼要容易理解,绝对能让你眼前一亮,通过这篇文章的详细介绍希望...
  • 1、 选择排序:把第一个数与他后面的数进行比较,如果顺序则继续与后面比较,如果逆序则两数交换位置,继续将第一个数与交换位置后的数进行比较,这样就完成了第一轮排序。同理将第二位与其后的数比较,直到数组有序...
  • 冒泡排序 编程思想 假设现在要对一组数{3,9,5,6,2,7}做从大到小排序,当然从小到大排序也是一样的,这里只是举例说明其思想。 我们首先要清楚这组数在计算机的存储情况: 数据截图 这个过程就好比是比武招亲,...
  • 新手小白学JAVA 冒泡排序

    万次阅读 多人点赞 2021-04-30 08:39:13
    3 冒泡排序bubble 3.1 概念 冒泡排序(Bubble Sort),是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的元素列,依次比较两个相邻的元素,如果他们的顺序(如从大到小、首字母从A到Z)错误就把他们...
  • 本文实例讲述了Java排序算法总结之冒泡排序。分享给大家供大家参考。具体分析如下:前言:冒泡排序(BubbleSort)就是依次比较相邻的两个数,将小数放在前面,大数放在后面。下面让我们一起 来看冒泡排序Java中的...
  • Java冒泡排序入门详解

    2021-03-06 20:19:22
    冒泡排序(Bubble Sort)是计算机编程开发技术中一种较为简单的排序方法。为了更好地理解其算法原理,我们先来看这样一个例子:在操场上从左到右一字排开地站着A(181)、B(169)、C(187)、D(172)、E(163) 5名运动员(括号...
  • 排序算法的历史:排序算法的发展历史几乎和计算机的发展历史一样悠久,而且直到今天,世界范围内依然有计算机科学家正在研究着排序的算法,由此可见排序算法的强大魅力. 我们现在介绍的排序算法都是前任研究的经典成果,...
  • 一、冒泡排序根据数组的长度循环遍历,并判断如果前一个值小于后一个值,那么就把“后一个值”排列到“当前前一个值”的前面。代码实现如下:// 定义一个无序的整形数组int arr[] = {25,29,13,10,12,14,41};// 进行...
  • 例如:将数组 int[ ] arr = {5,3,8,7,2} 从小到大排序。 思路:依次比较数组中相邻的两个数,小数放在前面,大数放在右面,即第一次遍历:将第1个数和第2个数比较,大数放在后面,小数放在前面。然后第2个数和第...
  • 一、算法原理比较相邻的元素。如果第一个比第二个大,就交换他们两个。对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。...假如有n个数需要进行排序,则外循环重复n-1次,内循环依次...
  • java 可视化冒泡排序

    2021-04-10 01:05:34
    绘图程序3. 主方法 1. 效果 (清除原有内容时会有闪屏 后面看看怎么搞) 1. gif (录到结束的) 2. 开始 3. 结束 2. 代码 2.1 定制数组 (会触发数组元素变更的事件) 继承自ArrayList 重载 set 方法 当调用 set ...
  • 1.冒泡排序法原理: 将序列当中的左右元素,依次比较,如果左边的元素大于右边元素则交换位置,保证右边的元素始终大于左边的元素;( 第一轮结束后,序列最后一个元素一定是当前序列的最大值;)对序列当中剩下的n-1个...
  • 冒泡排序(1)基本思想:在要排序的一组数中,对当前还未排好序的范围内的全部数,自上而下对相邻的两个数依次进行比较和调整,让较大的数往下沉,较小的往上冒。即:每当两相邻的数比较后发现它们的排序与排序要求...
  • /*** 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....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 36,777
精华内容 14,710
关键字:

java编程冒泡排序

java 订阅