Java冒泡排序及练习

简单的冒泡排序写法

public class TestPopSort {

    public static void main(String[] args) {
        int[] arrs = {23, 12, 55, 34, 9};
        int temp;
        //冒泡排序只需要排元素个数-1次，而且我们从0开始，即从0--->arrs.length - 1
        for (int i = 0; i < arrs.length - 1; i++) {
            for (int j = 0; j < arrs.length - 1 - i; j++) {
                if (arrs[j] > arrs[j + 1]){
                    temp = arrs[j];
                    arrs[j] = arrs[j + 1];
                    arrs[j + 1] = temp;
                }
            }
        }

        for (int i = 0; i < arrs.length; i++) {
            System.out.print(arrs[i] + " ");
        }
    }

}

练习

import java.util.Scanner;

/**
 * 案例：从键盘输入本组学员的人数，和本组学员的成绩，用数组存储成绩，然后实现从高到低排序
 * 我将使用冒泡排序来进行排序
 */
public class Test09 {

    public static void main(String[] args) {
        //第一步定义数组，从键盘接收学员人数，和学员的成绩
        Scanner input = new Scanner(System.in);
        System.out.println("请输入小组人数");
        int students = input.nextInt();
        int[] stus = new int[students];
        for (int i = 0; i < stus.length; i++) {
            System.out.println("请录入小组人员的成绩");
            stus[i] = input.nextInt();
        }

        //第二步使用冒泡排序对成绩进行排序
        int temp = 0;
        //冒泡排序，最后一位不用排序(就已经确定是最大或者最小了)，因此循环 i < stus.length - 1次;
        for (int i = 0; i < stus.length - 1; i++) {
            //i是递增的，冒泡循环每经历一次外层循环，内层循环就会-1(因为每次都会确定当前未排序队列中的一个最大或者最小值)，而i正好递增，我们正好可以拿长度-i从而实现递减
            //这个最开始从j < stus.length - 1开始，即最大到stus.length - 2，因为我们使用stus[j] = stus[j + 1]，当j=stus.length - 2时，j+1=j=stus.length - 1即占用了数组最后一个元素。即正好使用完
            for (int j = 0; j < stus.length - 1 - i; j++) {
                if (stus[j] > stus[j + 1]){
                    temp = stus[j];
                    stus[j] = stus[j + 1];
                    stus[j + 1] = temp;
                    //System.out.println(1);
                }
            }
        }

        //循环遍历排序后的数组
        for (int i = 0; i < stus.length; i++) {
            System.out.print(stus[i] + "\t");
        }

    }

}

标准版冒泡排序写法

import java.util.Arrays;

/**
 * 冒泡排序，如果给一组数从小到大或者从大到小排序，那么有几个元素就进行几次冒泡，虽然n-1次也行
 */
public class Bubble {

    /*
    对数组a中的元素进行排序
    */
    public static void sort(Comparable[] a){
        int n = a.length - 1;
        for (int i = n; i > 0; i--){
            for (int j = 0; j < i; j++){
                boolean greater = greater(a[j], a[j + 1]);
                if (greater == true){
                    exch(a, j, j+1);
                }
            }
        }
    }

    /*
    比较v元素是否大于w元素
    由多态性我们可以把Integet类型看作Comparable接口类型
    */
    private static boolean greater(Comparable v,Comparable w){
        return v.compareTo(w) > 0;
    }

    /*
    数组元素i和j交换位置
    这个案例我们传入的数组a[] 中每个元素都是Integet类型，该类型继承了Comparable接口
    重写了comparaTo()方法，因此由多态性我们可以把Integet类型看作Comparable接口类型
    我们这样做的好处就是，后面调用时，只需要继承Comparable接口，重写比较方法就行了，通用性较好
    */
    private static void exch(Comparable[] a,int i,int j){

        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;

    }


}

//测试代码
class Test {
    public static void main(String[] args) {
        Integer[] a = {4, 5, 6, 3, 2, 1};
        Bubble.sort(a);
        System.out.println(Arrays.toString(a));
    }
}