java冒泡排序（java冒泡排序详细讲解）

java冒泡排序详细讲解

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

for(int
j=0;j《=len-i-1;j++),冒泡排序比较相邻的值，也就是a[j]和a[j+1]相比较
所以这段代码从a开始与后面的a比较，如果a小于
a就换。不小于j++，a和[a2]比较，以此类推，直到比到a[len-i-1]时，也就比到了最后一个数组了。上层循环就是控制数组比较的长度。

Java冒泡排序

package net.sunyixin.acggo.test;
public class Main{
public static void outputArray(int arr){
String arrStr = ““;
for(int i : arr){
arrStr += i + “ “;
}
System.out.println(arrStr);
}
public static void swap(int arr, int i, int j){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
/**
* 冒泡排序方法
* @param nums 排序对象
*/
public static void bubbleSort(int 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]){
swap(nums, j, j+1);
}
}
}
}
public static void main(String args){
int arr = new int;
for(int i=0;i《arr.length;i++){
arr[i] = (int)(Math.random()*100);
}
bubbleSort(arr);
outputArray(arr);
}
}

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(j《i){
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(j《i){
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冒泡排序法代码

冒泡排序是比较经典的排序算法。代码如下：

for(int i=1;i《arr.length;i++){
for(int j=1;j《arr.length-i;j++){
//交换位置
}

拓展资料：

原理：比较两个相邻的元素，将值大的元素交换至右端。

思路：依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。重复第一趟步骤，直至全部排序完成。

第一趟比较完成后，最后一个数一定是数组中最大的一个数，所以第二趟比较的时候最后一个数不参与比较；

第二趟比较完成后，倒数第二个数也一定是数组中第二大的数，所以第三趟比较的时候最后两个数不参与比较；

依次类推，每一趟比较次数-1；

……

举例说明：要排序数组：int arr={6,3,8,2,9,1};

for(int i=1;i《arr.length;i++){
for(int j=1;j《arr.length-i;j++){
//交换位置
}

参考资料：冒泡排序原理

java实现冒泡排序

你这样写，相当于只冒了一次泡，把最大的一个数，也就是最后一个数，找出来了，冒泡排序是要for循环里在嵌套一个for循环才能做出来的，外面的for循环控制冒泡多少次，里面的循环找出每次的最大值。你这样写少了外面的那个for循环，相当于只找了一次最大值。

java中的冒泡排序

都不正确，正确的冒泡排序写法是：

for(int i=0;i《arrs.length-1;i++){
    for(int j=0;j《arrs.length-1-i;j++){
        if(a[j]》a[j+1]){
            int t=a[j];
            a[j]=a[j+1];
            a[j+1]=t;
        }
    }
}

java这个冒泡排序是怎么回事

首先可以肯定的是你这个代码肯定是完全没问题的，这就是冒泡排序的写法：

至于这个问题，我认为最好的解决方法就是重新创一个类，然后把代码复制过去试试。

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冒泡排序的原理

冒泡排序是所欲排序算法里最好理解的了。
1、排序算法：
A)比较相邻的元素。如果第一个比第二个大，就交换他们两个。
B)对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
C)针对所有的元素重复以上的步骤，除了最后一个。
D)持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
2、给你一个java的实现代码：
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是

冒泡排序算法：

int类型的数组：3 1 6 2 5

算法：取出最大的放在最后，下次就不用比较最后一个了。*/

public class BubbleSort{

public static void main(String args){

int a = {3,1,6,2,5};

//开始排序

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

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

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

//交换位置

int temp;

temp = a[j];

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

a[j+1] = temp;

//遍历

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

System.out.println(a[i]);

}

算法原理

冒泡排序算法的运作如下：（从后往前）

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

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

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

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