「java冒泡排序代码详解」java代码实现冒泡排序

今天给各位分享java冒泡排序代码详解的知识，其中也会对java代码实现冒泡排序进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

• 1、java 冒泡排序怎么写？
• 2、java冒泡排序代码
• 3、JAVA 冒泡排序法的详细解释是什么？
• 4、JAVA冒泡排序

java 冒泡排序怎么写？

方法一: package basic.javastu; public class NumberTest {

/** * 实现冒泡程序1 */ public static void main(String[] args) { // TODO Auto-generated method stub

int[] numb=new int[]{3,42,57,1,32,24};

int len=numb.length;

int i,j;

int temp;

System.out.println("排序前的数组各个值:");

for(i=0;ilen;i++)

{

System.out.print(numb[i]+"\t");

}

System.out.println("\n");

for(i=1;i=len;i++)

{

for(j=len-1;j=1;j--)

{

if(numb[j]numb[j-1])

{

temp=numb[j];

numb[j]=numb[j-1];

numb[j-1]=temp;

}

}

}

System.out.println("排序后的数组各个值:");

for(i=0;ilen;i++)

{

System.out.print(numb[i]+"\t");

}

}

}

方法二: package basic.javastu; public class NumberTest2 {

/** * 实现冒泡程序2 */ public static void main(String[] args) { // TODO Auto-generated method stub

int[] numb=new int[]{3,42,57,1,32,24};

int leng=numb.length;

System.out.println("排序前的数组各个值:");

for(int i=0;ileng;i++)

{

System.out.print(numb[i]+"\t");

}

System.out.println("\n");

swap(numb);

System.out.println("数组排序后:"); for(int i=0;ileng;i++)

{

System.out.print(numb[i]+"\t");

} }

private static int[] swap(int[] numb) { int n2[]=numb; int len=n2.length; int i,j; int temp; for(i=1;i=len;i++)

{

for(j=len-1;j=1;j--)

{

if(n2[j]n2[j-1])

{

temp=n2[j];

n2[j]=n2[j-1];

n2[j-1]=temp;

}

}

} return n2; } }

方法三: package basic.javastu; public class NumberTest3 {

/** * 实现冒泡程序2 */ public static void main(String[] args) { // TODO Auto-generated method stub

int[] numb=new int[]{3,42,57,1,32,24};

int leng=numb.length;

System.out.println("排序前的数组各个值:");

for(int i=0;ileng;i++)

{

System.out.print(numb[i]+"\t");

}

System.out.println("\n");

swap(numb);

System.out.println("数组排序后:"); for(int i=0;ileng;i++)

{

System.out.print(numb[i]+"\t");

} }

private static void swap(int[] numb) { int len=numb.length; int i,j; int temp; for(i=1;i=len;i++)

{

for(j=len-1;j=1;j--)

{

if(numb[j]numb[j-1])

{

temp=numb[j];

numb[j]=numb[j-1];

numb[j-1]=temp;

}

}

} } }

java冒泡排序代码

冒泡排序（Bubble Sort）是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

冒泡排序算法的运作如下:

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

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

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

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

public class BubbleSort{  

      public static void main(String[] args){  

          int score[] = {67, 69, 75, 87, 89, 90, 99, 100};  

          for (int i = 0; i  score.length -1; i++){    //最多做n-1趟排序  

              for(int j = 0 ;j  score.length - i - 1; j++){    //对当前无序区间score[0......length-i-1]进行排序(j的范围很关键，这个范围是在逐步缩小的)  

                  if(score[j]  score[j + 1]){    //把小的值交换到后面  

                      int temp = score[j];  

                      score[j] = score[j + 1];  

                      score[j + 1] = temp;  

                  }  

              }              

              System.out.print("第" + (i + 1) + "次排序结果：");  

              for(int a = 0; a  score.length; a++){  

                  System.out.print(score[a] + "\t");  

              }  

              System.out.println("");  

          }  

              System.out.print("最终排序结果：");  

              for(int a = 0; a  score.length; a++){  

                  System.out.print(score[a] + "\t");  

         }  

      }  

  }

JAVA 冒泡排序法的详细解释是什么？

冒泡排序的英文Bubble Sort，是一种最基础的交换排序。

大家一定都喝过汽水，汽水中常常有许多小小的气泡，哗啦哗啦飘到上面来。这是因为组成小气泡的二氧化碳比水要轻，所以小气泡可以一点一点向上浮动。而我们的冒泡排序之所以叫做冒泡排序，正是因为这种排序算法的每一个元素都可以像小气泡一样，根据自身大小，一点一点向着数组的一侧移动。

冒泡排序算法的原理如下：

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

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

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

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

具体如何来移动呢？让我们来看一个栗子：

请点击输入图片描述

请点击输入图片描述

有8个数组成一个无序数列：5，8，6，3，9，2，1，7，希望从小到大排序。按照冒泡排序的思想，我们要把相邻的元素两两比较，根据大小来交换元素的位置，过程如下：

首先让5和8比较，发现5比8要小，因此元素位置不变。

接下来让8和6比较，发现8比6要大，所以8和6交换位置。

请点击输入图片描述

请点击输入图片描述

请点击输入图片描述

请点击输入图片描述

继续让8和3比较，发现8比3要大，所以8和3交换位置。

请点击输入图片描述

请点击输入图片描述

请点击输入图片描述

请点击输入图片描述

继续让8和9比较，发现8比9要小，所以元素位置不变。

接下来让9和2比较，发现9比2要大，所以9和2交换位置。

请点击输入图片描述

请点击输入图片描述

请点击输入图片描述

请点击输入图片描述

接下来让9和1比较，发现9比1要大，所以9和1交换位置。

请点击输入图片描述

请点击输入图片描述

请点击输入图片描述

请点击输入图片描述

最后让9和7比较，发现9比7要大，所以9和7交换位置。

请点击输入图片描述

请点击输入图片描述

请点击输入图片描述

请点击输入图片描述

这样一来，元素9作为数列的最大元素，就像是汽水里的小气泡一样漂啊漂，漂到了最右侧。

这时候，我们的冒泡排序的第一轮结束了。数列最右侧的元素9可以认为是一个有序区域，有序区域目前只有一个元素。

请点击输入图片描述

请点击输入图片描述

下面，让我们来进行第二轮排序：

首先让5和6比较，发现5比6要小，因此元素位置不变。

接下来让6和3比较，发现6比3要大，所以6和3交换位置。

请点击输入图片描述

请点击输入图片描述

请点击输入图片描述

请点击输入图片描述

继续让6和8比较，发现6比8要小，因此元素位置不变。

接下来让8和2比较，发现8比2要大，所以8和2交换位置。

请点击输入图片描述

请点击输入图片描述

接下来让8和1比较，发现8比1要大，所以8和1交换位置。

请点击输入图片描述

请点击输入图片描述

请点击输入图片描述

请点击输入图片描述

继续让8和7比较，发现8比7要大，所以8和7交换位置。

请点击输入图片描述

请点击输入图片描述

请点击输入图片描述

请点击输入图片描述

第二轮排序结束后，我们数列右侧的有序区有了两个元素，顺序如下：

请点击输入图片描述

请点击输入图片描述

至于后续的交换细节，我们这里就不详细描述了，第三轮过后的状态如下：

请点击输入图片描述

请点击输入图片描述

第四轮过后状态如下：

请点击输入图片描述

请点击输入图片描述

第五轮过后状态如下：

请点击输入图片描述

请点击输入图片描述

第六轮过后状态如下：

请点击输入图片描述

请点击输入图片描述

第七轮过后状态如下（已经是有序了，所以没有改变）：

请点击输入图片描述

请点击输入图片描述

第八轮过后状态如下（同样没有改变）：

请点击输入图片描述

请点击输入图片描述

到此为止，所有元素都是有序的了，这就是冒泡排序的整体思路。

原始的冒泡排序是稳定排序。由于该排序算法的每一轮要遍历所有元素，轮转的次数和元素数量相当，所以时间复杂度是O（N^2） 。

冒泡排序代码

请点击输入图片描述

请点击输入图片描述

希望对您有所帮助！~

JAVA冒泡排序

package Test;

import java.util.Arrays;

public class Demo1 {

public static void main(String[] args) {

int[] a = {2,1,3,9,7,10,8,11,17,6};

//System.out.println(Arrays.toString(a));

sortArr(a,a.length - 1,0);

System.out.println(Arrays.toString(a));

sort(a);

System.out.println(Arrays.toString(a));

}

public static void sortArr(int[] a,int i,int j){

if(ji){

sortOne(a,i,j);

}else{

sortOne(a,--i,0);

}

}

public static void sortOne (int[] a,int i,int j){

if(i==0)return;

if(a[j + 1]  a[j]){

 int temp = a[j];

             a[j] = a[j + 1];

             a[j + 1] = temp;

}

sortArr(a,i,++j);

}

 public static void sort(int[] a)

    {

        int temp = 0;

        for (int i = a.length - 1; i  0; --i)

        {

            for (int j = 0; j  i; ++j)

            {

                if (a[j + 1]  a[j])

                {

                    temp = a[j];

                    a[j] = a[j + 1];

                    a[j + 1] = temp;

                }

            }

        }

    }

}

上面代码是从小到大排列

package Test;

import java.util.Arrays;

public class Demo1 {

public static void main(String[] args) {

Object[] a = {2,1,3,9,7,10,8,11,17,6};

sortArr(a,a.length - 1,0);

System.out.println(Arrays.toString(a));

Object[] b = {'a','m','s','b','h','e'};

sortArr(b,b.length - 1,0);

System.out.println(Arrays.toString(b));

}

public static void sortArr(Object[] a,int i,int j){

if(ji){

sortOne(a,i,j);

}else{

sortOne(a,--i,0);

}

}

public static void sortOne (Object[] a,int i,int j){

if(i==0)return;

if(a[j + 1] instanceof Integer){

if(Integer.valueOf(""+a[j + 1]) Integer.valueOf(""+ a[j])){

Object temp = a[j];

             a[j] = a[j + 1];

             a[j + 1] = temp;

}

}else if(a[j + 1] instanceof Character){

if(a[j + 1].toString().charAt(0) a[j].toString().charAt(0)){

Object temp = a[j];

             a[j] = a[j + 1];

             a[j + 1] = temp;

}

}

sortArr(a,i,++j);

}

//  public static void sort(int[] a)

//     {

//         int temp = 0;

//         for (int i = a.length - 1; i  0; --i)

//         {

//             for (int j = 0; j  i; ++j)

//             {

//                 if (a[j + 1]  a[j])

//                 {

//                     temp = a[j];

//                     a[j] = a[j + 1];

//                     a[j + 1] = temp;

//                 }

//             }

//         }

//     }

}

关于java冒泡排序代码详解和java代码实现冒泡排序的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。