冒泡排序-java

冒泡排序-java

转载请注明出处：http://blog.csdn.net/a740169405/article/details/50716134

思想：

冒泡排序的思想是把小的数从后面一个一个的交换到前面，想水中的气泡一样一直往上冒：

使用循环实现：

/**
 * 使用循环的方式实现冒泡排序
 */
private static void bubbleSort(int[] arr) {
    if (arr == null || arr.length == 0) {
        return;
    }
    boolean isChange;
    int count = arr.length;
    for (int i = 0; i < count; i++) {
        isChange = false;
        for (int j = count - 1; j > i; j--) {
            if (arr[j] < arr[j - 1]) {
                change(arr, j, j - 1);
                isChange = true;
            }
        }
        if (!isChange) {
            break;
        }
    }
}

这里之所以加isChange的判断是为了提高排序的效率，如果一次的比较中，没有发生交换，则说明当前已经是排好序的，之后不需要再进行比较。

递归方式：

/**
 * 使用递归的方式进行冒泡排序
 * @param arr 数组
 * @param tag 当前的冒泡位置
 */
private static boolean bubbleSort(int[] arr, int tag) {
    if (arr == null || tag < 0 || tag >= arr.length) {
        return false;
    }
    int count = arr.length;
    boolean isChange = false;
    for (int j = count - 1; j > tag; j--) {
        if (arr[j] < arr[j - 1]) {
            change(arr, j, j - 1);
            isChange = true;
        }
    }
    return isChange && bubbleSort(arr, ++tag);
}

交换方法：

/**
 * 交换数组中指定位置的两个数字
 */
private static void change(int[] arr, int l, int r) {
    int tmp = arr[l];
    arr[l] = arr[r];
    arr[r] = tmp;
}

调用代码：

int[] array = new int[] {3, 7, 4, 56, 34, 12, 90, 67, 24};
int[] arr = new int[] {1, 45, 78, 23, 12, 98, 150, 1, 45};
bubbleSort(array);
System.out.println(Arrays.toString(array));
bubbleSort(arr, 0);
System.out.println(Arrays.toString(arr));

结果：

复杂度分析：
最好情况：只循环比较一趟，也就是n-1，去除常数项，最后为n
最坏情况：数组是一个逆置数组，此时需要比较次数为：

当然，需要交换的次数也为这么多次，去除常数项，再去除最高次幂的常数，得到复杂度为n²

也就是冒泡排序的时间复杂度在n与n²之间

稳定性分析：

冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。所以，如果两个元素相等，我想你是不会再无聊地把他们俩交换一下的；如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。