简单排序

冒泡排序：

假设一个数组 int[] array 长度为5，坐标为：[0]、[1]、[2]、[3]、[4] ，每相邻两位数比较。
第一次比较：[0]与[1]、[1]与[2]、[2]与[3]、[3]与[4] （array[4] 已是最大）
第二次比较：[0]与[1]、[1]与[2]、[2]与[3]
第三次比较：[0]与[1]、[1]与[2]
第四次比较：[0]与[1]（array[0] 已是最小）

public class BubbleSort {

    public static void main(String[] args) {

        int[] array = { 1, 65, 48, 9, 5, 2, 33, 6, 45, 88, 11, 2, 59, 4 };

        int c = -1;
        //控制次数
        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]) {
                    c = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = c;
                }
            }
        }

        for (int r : array) {
            System.out.println(r);
        }
    }

}

效率：

在一个10个数据项的数组中，第一次排序时要进行 9 次比较，第二次排序进行 8 次比较 。。。。 直到最后一次进行 1 次比较，那么次数为：
9 + 8 + 7 + 6 + 5 + 4 + 3 + 2 + 1 = 45，假设数组的长度为 N ， 那么：
(N-1) + (N-2) + (N-3) + (N-4) + ...... + 1 = N * (N-1) / 2 （ 约成  N² ）
假设每次大概只有一半的数据需要交换，那么交换的次数为：N² / 4

在大O表示法中，忽略了 2 和 4 ， 那么意味着比较和交换的次数都为 N² ，认为冒泡排序需要O(N²) 时间级别。

类似冒泡的一种排序

    for (int i = 0; i < array.length; i++) {
        for (int j = i + 1; j < array.length; j++) {
        if (array[i] > array[j]) {
            c = array[i];
            array[i] = array[j];
            array[j] = c;
        }
        }
    }

选择排序：

排序从左开始，记录下最矮数值的坐标，在第一轮之中做了（N-1）次的比较之后，已经记录下最矮数值的坐标，再与其坐标的数值与最左边的数值进行交换。
也就是每一轮的比较，都只做 1 次交换。

public class SelectSort {

    public static void main(String[] args) {
    int[] array = { 1, 65, 48, 9, 5, 2, 33, 6, 45, 88, 11, 2, 59, 4 };

    int c;
    int min ;
    for (int i = 0; i < array.length -1 ; i++) {
        min = i;
        for (int j = i + 1; j < array.length; j++) {
        if (array[j] < array[min]) {
            min = j;
        }
        }
        c = array[min];
        array[min] = array[i];
        array[i] = c;
    }

    for (int r : array) {
        System.out.println(r);
    }
    }

}

 效率：

与冒泡排序执行了相同次数的比较：N * (N-1) / 2，但交换次数只进行不到 N 次，当 N 值很大时，比较次数是主要的，所以结论是选择排序与冒泡排序一样运行了 O（N²）时间，但是选择排序无疑是更快的，因为交换次数少。

插入排序：

局部有序：在冒泡和选择排序中是不会出现的，在这两种算法中，一组数据项在某一时刻是完全有序，在插入排序中，一组数据仅仅是局部有序。
在队伍之中有一个标记的成员，在这个标记成员的左边的所有成员都是局部有序，意味着这一部分成员是按照顺序的（从小到大，标记成员是最大的）。
标记往右移，新的标记成员 temp 与左边一位（局部有序中最大的成员）M 比较，如果temp 比 它小，则 M 放到新标记的位置（原temp的位置），之后temp 再与左边第二位成员比较。。。如此下去，如果找到temp 与比较的值大的话，就放在该比较值右边的位置。

public static void insert() {
    int[] array = { 1, 65, 48, 9, 5, 2, 33, 6, 45, 88, 11, 2, 59, 4 };
    int in, out;
    for (out = 1; out < array.length; out++) {
        int temp = array[out];
        in = out;
        while (in > 0 && array[in - 1] >= temp) {
        　　array[in] = array[in - 1];
        　　in--;
        }
        array[in] = temp;
    }
}

插入排序效率：
第一趟排序：最多一次，第二趟：最多两次。。。。。最后一趟，最多N-1次。
1 + 2 + 3 + 4 + ...... + (N-1) = N*(N-1)/2
平均只有一半数据真的进行比较，那么 N*(N-1)/4
插入排序算法仍然需要O(N²)的时间，复制的次数大致等于比较的次数。然而，一次复制（插入）与一次交换（冒泡、选择）的时间耗费不同，所以一般情况下，它要比冒泡排序快一倍，比选择排序还快一些。