Java实现常见算法

排序

冒泡排序

冒泡排序的原理是每次比较相邻元素的大小，并且将大值交换到后面。
以下是代码实现。

// [3,9,1,45,8,13,2,5]
/*
    第一趟：
        第一次排序，3和9比较，不交换位置：  3*，9，1，45，8，13，2，5
        第二次排序，9和1比较，交换位置：    3，1*，9，45，8，13，2，5
        第三次排序，9和45比较，不交换位置： 3，1，9*，45，8，13，2，5
        第四次排序，45和8比较，交换位置：   3，1，9，8*，45，13，2，5
        第五次排序，45和13比较，交换位置：  3，1，9，8，13*，45，2，5
        第六次排序，45和2比较，交换位置：   3，1，9，8，13，2*，45，5
        第七次排序，45和5比较，交换位置：   3，1，9，8，13，2，5*，45
  ---------------------------------------------------
    第二趟：
        第一次排序，1和3比较，不交换位置：  1*，3，9，8，13，2，5，45
        第二次排序，3和9比较，不交换位置：  1，3*，9，8，13，2，5，45
        第三次排序，9和8比较，交换位置：    1，3，8*，9，13，2，5，45
        第四次排序，9和13比较，不交换位置： 1，3，8，9*，13，2，5，45
        第五次排序，13和2比较，交换位置：   1，3，8，9，2*，13，5，45
        第六次排序，13和5比较，交换位置：   1，3，8，9，2，5*，13，45
  ---------------------------------------------------
    第三趟：
        第一次排序，1和3比较，不交换位置：  1*，3，8，9，2，5，13，45
        第二次排序，3和8比较，不交换位置：  1，3*，8，9，2，5，13，45
        第三次排序，8和9比较，不交换位置：  1，3，8*，9，2，5，13，45
        第四次排序，9和2比较，交换位置：    1，3，8，2*，9，5，13，45
        第五次排序，9和5比较，交换位置：    1，3，8，2，5*，9，13，45
  ---------------------------------------------------
    第四趟：
        第一次排序，1和3比较，不交换位置：  1*，3，8，2，5，9，13，45
        第二次排序，3和8比较，不交换位置：  1，3*，8，2，5，9，13，45
        第三次排序，8和2比较，交换位置：    1，3，2*，8，5，9，13，45
        第四次排序，8和5比较，交换位置：    1，3，2，5*，8，9，13，45
 ---------------------------------------------------
    第五趟：
        第一次排序，1和3比较，不交换位置：  1*，3，2，5，8，9，13，45
        第二次排序，3和2比较，交换位置：    1，2*，3，5，8，9，13，45
        第三次排序，3和5比较，不交换位置：  1，2，3*，5，8，9，13，45
        第四次排序，5和8比较，不交换位置：  1，2，3，5*，8，9，13，45
 ---------------------------------------------------
    第六趟：
        第一次排序，1和2比较，不交换位置：  1*，2，3，5，8，9，13，45
        第二次排序，2和3比较，不交换位置：  1，2*，3，5，8，9，13，45
        第三次排序，3和5比较，不交换位置：  1，2，3*，5，8，9，13，45
 ---------------------------------------------------
    第七趟：
        第一次排序，1和2比较，不交换位置：  1*，2，3，5，8，9，13，45
        第二次排序，2和3比较，不交换位置：  1，2*，3，5，8，9，13，45
 */
private static void sort(int[] array) {

    //外层循环控制排序的趟数
    for(int i=0;i<array.length-1;i++){

        //内层循环控制每趟排序内的次数逐渐递减
        for(int j=0;j<array.length-1-i;j++){
            if(array[j]>array[j+1]){
                int tmp=array[j];
                array[j]=array[j+1];
                array[j+1]=tmp;
            }
        }
    }
}