java冒泡排序法

public class SortTest {

public void sort(int[] args){

for(int m : args){

Systemoutprint("排序前 "+args[m]+" ");

}

int time1 = 0,time2 = 0;

for(int i = 0 ; i < argslength-1 ; i++){

++time1;

for(int j = i+1 ; j < argslength ; j++){

++time2;

int temp ;

if(args[i] > args[j]){

temp = args[j];

args[j] = args[i];

args[i] = temp;

}

}

}

Systemoutprintln();

Systemoutprintln("外循环次数："+time1+"内循环次数："+time2);

for(int n : args){

Systemoutprint("排序后 "+n+" ");

}

}

public static void main(String[] args) {

int[] arg = new int[]{2,1,4,5,8,7,6,3,9,0};

new SortTest()sort(arg);

}

}

降序排列 循环次数最少

输出结果为：

排序前 4 排序前 1 排序前 8 排序前 7 排序前 9 排序前 3 排序前 6 排序前 5 排序前 0 排序前 2

外循环次数：9 内循环次数：45

排序后 0 排序后 1 排序后 2 排序后 3 排序后 4 排序后 5 排序后 6 排序后 7 排序后 8 排序后 9

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

由于在排序过程中总是小数往前放，大数往后放，相当于气泡往上升，所以称作冒泡排序。

for(int

j=0;j<=len-i-1;j++),冒泡排序比较相邻的值，也就是a[j]和a[j+1]相比较

所以这段代码从a[0]开始与后面的a[1]比较，如果a[1]小于

a[0]就换。不小于j++，a[1]和[a2]比较，以此类推，直到比到a[len-i-1]时，也就比到了最后一个数组了。上层循环就是控制数组比较的长度。

public class Main extends Object {

public static void main(String[]args) { int[] data = {6,5,9,7,2,8};

Systemoutprintln("冒泡排序法： ");

Systemoutprintln("原始数据为： "); //遍历数组

for(int i = 0; i < datalength; i++) {

Systemoutprint(data[i] + " ");

}

Systemoutprint("\n"); //冒泡排序

bubbleSort(data);

}

public static void bubbleSort(int[]data) { //temp用于数组元素交换

int temp; //i记录扫描次数

for(int i = datalength - 1; i > 0; i--) { //进行这一轮的冒泡排序

for(int j = 0; j < i; j++) { //从第一个元素开始和下一个比较，比下一个大则交换

if(data[j] > data[j + 1]) {

temp = data[j];

data[j] = data[j + 1];

data[j + 1] = temp;

}

}

}

Systemoutprint("排序结果为： "); //输出排序后的结果

for(int k = 0; k < datalength; k++) {

Systemoutprint(data[k] + " ");

}

Systemoutprint("\n");

}

}

package Test;

import javautilArrays;

public class Demo1 {

public static void main(String[] args) {

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

//Systemoutprintln(ArraystoString(a));

sortArr(a,alength - 1,0);

Systemoutprintln(ArraystoString(a));

sort(a);

Systemoutprintln(ArraystoString(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 = alength - 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;

                }

            }

        }

    }

}

上面代码是从小到大排列

import javautilArrays;

public class Demo1 {

public static void main(String[] args) {

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

sortArr(a,alength - 1,0);

Systemoutprintln(ArraystoString(a));

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

sortArr(b,blength - 1,0);

Systemoutprintln(ArraystoString(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(IntegervalueOf(""+a[j + 1]) <IntegervalueOf(""+ 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 = alength - 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;

//                 }

//             }

//         }

//     }

}

import javautilArrays;

public class Maopao {

public static void main(String[] args) {

int[] arr1 = new int[] { 1, 9, 4, 7, 5, 10 };

int temp = 0;

for (int i = 0; i < arr1length; i++) {

for (int j = 0; j < arr1length; j++) {

if (arr1[i] > arr1[j]) {

temp = arr1[j];

arr1[j] = arr1[i];

arr1[i] = temp;

}

}

}

Systemoutprintln("降序排列---------》");

for (int i = 0; i < arr1length; i++) {

Systemoutprintln(arr1[i]);

}

Systemoutprintln("升序排列------------》");

Arrayssort(arr1);

for (int i = 0; i < arr1length; i++) {

Systemoutprintln(arr1[i]);

}

}

}

Comparable 是排序接口。

若一个类实现了Comparable接口，就意味着“该类支持排序”。

参数改成ArrayList<Integer>list就可以比较了。因为Integer类实现了Comparable接口。

只要<>中是Comparable的实现类，if里的比较就可以进行。Comparable类有很多实现类，比如String，Float等。

以上就是关于java冒泡排序法全部的内容，包括:java冒泡排序法、java冒泡排序详细讲解、冒泡排序法java等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！