冒泡排序与快速排序

算法分析：

序列 S= {S0, S1, S2, ...,Sn-1}是n个可排序的序列。

(1). i从n-1递减到1，重复步骤(2)~(3)。

(2). j从0递增到i-1，重复步骤(3)。

(3). 若Sj > Sj+1，交换它们。

原始代码和改进的代码如下：

import java.util.Arrays;

class InsertSort {
    public void bubbleSort(int[] array) {
        for (int i = array.length-1; i > 0; i--) {
            for (int j = 0; j < i; j++) {
                if(array[j+1] < array[j]) {
                    int tmp = array[j+1];
                    array[j+1] = array[j];
                    array[j] = tmp;
                }
            }
        }
    }
    public void bubbleSortBetter(int[] array) {
        for (int i = array.length-1; i > 0; i--) {
            boolean change = false;
            for (int j = 0; j < i; j++) {
                if(array[j+1] < array[j]) {
                    int tmp = array[j+1];
                    array[j+1] = array[j];
                    array[j] = tmp;
                    change = true;
                }
            }
            if(!change) break; // 无改变时，说明从j=0到j=i已经是有序的，故不需要再次排序。
        }
    }
}
public class TestClass {
    public static void main(String[] args) {
        int[] test = {5, 3, 4, 1, 7, 6};
        new InsertSort().bubbleSort(test);
        System.out.println(Arrays.toString(test));
    }
}

快速排序的三步分治过程：

关于快速排序的详细通俗解说，点击百科快速排序算法。下面给出Java代码，注意递归条件left < right。

import java.util.Arrays;

class QuickSort {
    public void quickSort(int[] array, int left, int right) {
        int index = partition(array, left, right);
        if(left < index-1) quickSort(array, left, index-1); //排序基准点的左半部分
        if(index+1 < right) quickSort(array, index+1, right); //排序基准点的右半部分
    }

    public int partition(int[] array, int left, int right) {
        int pivot = array[left]; //找第1个元素作为基准点
        while (left < right) {
            while (left < right && array[right] >= pivot) right--;
            if(left < right) {
                int tmp = array[left];array[left] = array[right]; array[right] = tmp;
                left++;
            }
            while (left < right && array[left] <= pivot) left++;
            if(left < right) {
                int tmp = array[left];array[left] = array[right]; array[right] = tmp;
                right--;
            }
        }
        return left; //返回基准点的下标
    }
}
public class TestClass {
    public static void main(String[] args) {
        int[] test = {6, 2, 7, 3, 8, 9};
        new QuickSort().quickSort(test, 0, test.length-1);
        System.out.println(Arrays.toString(test));
    }
}

冒泡算法最好的时间复杂度为O(N)，最坏的时间复杂度O(N2)，平均时间复杂度O(N2)，是稳定的排序算法。

快速排序算法最好的时间复杂度为O(Nlg(N))，最坏的时间复杂度O(N2)，平均时间复杂度O(Nlg(N))，就其平均性能比较而言，它是基于关键字比较的内部排序算法中速度最快的，快速排序亦因此而得名，它是非稳定的。