三个简单排序算法：冒泡、简单选择、直接插入-CSDN博客

第一个是冒泡，最简单，但是性能一般（以下是改进版的，在冒泡过程中加入了flag判断有没交换过）

public class BubbleSort {
    public static void main(String[] args) {
        int i,j;
        int[] arr = {2, 5, 7, 9, 13, 14, 34, 1, 3, 6, 8};
        boolean flag = true;
        for (int item : arr) {
            System.out.printf(item+" ");
        }
        System.out.println();
        //改进了冒泡排序，如果后面已经排好序了，没发生过交换，则可以直接退出
        for (i = 0; i < arr.length-1 && flag; i++) {
            flag = false;
            for (j=arr.length-2;j>=i;j--) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                    flag = true;
                }
            }
        }
        for (int item : arr) {
            System.out.printf(item + " ");
        }
    }
}

第二个是简单选择排序，性能比冒泡稍好

/*简单排序法，和冒泡一样的时间复杂度O(n^2)，但是性能上简排要好点*/
public class SimSelSort {
    public static void main(String[] args) {
        int i,j,min;
        int[] arr = {2, 5, 7, 9, 13, 14, 34, 1, 3, 6, 8};
        for (int k = 0; k < arr.length; k++) {
            System.out.printf(arr[k] + " ");
        }
        System.out.println();
        for (i=0;i<arr.length;i++) {
            min = i;
            for (j = i; j < arr.length; j++) {//和冒泡比，比较的次数多了，但是交换少了
                if (arr[min] > arr[j]) {
                    min = j;
                }
            }
            if (min != i) {//有没有更小的，有就交换。下一个，i++
                int temp = arr[i];
                arr[i] = arr[min];
                arr[min] = temp;
            }
        }
        for (int k = 0; k < arr.length; k++) {
            System.out.printf(arr[k] + " ");
        }
        System.out.println();
    }
}

第三个是直接插入排序，平均比较和移动次数为n^2/4，虽然时间复杂度相同，但是要优于冒泡和选择排序

/*直接插入排序，复杂度O(n^2)，但是要比冒泡和简单排序稍好
* 书中用有序表，可以使用哨兵插到最前端，如果没有哨兵，只能用临时变量temp保存数组上的位置，却不能在前头再加了
* 这时候可以采用网上的方法，先找到我要插入的位置，再直接插入，应该是一样的*/
public class StraiInsSort {
    public static void main(String[] args) {
        int i, j, temp;
        int[] arr = {2, 5, 7, 9, 13, 14, 34, 1, 3, 6, 8};
        for (int item : arr) {
            System.out.printf(item+" ");
        }
        System.out.println();
/*        for (i=1;i<arr.length;i++) {
            if (arr[i] < arr[i - 1]) {
                temp = arr[i];
                for (j=i-1;arr[j]>temp && j>0;j--) {
                    arr[j + 1] = arr[j];
                }
                arr[j+1] = temp;
            }
        }*/
//书里的办法不能解决第一个没排序的情况

        for(i=1;i<arr.length;i++) {
            for (j = i - 1; j >= 0; j--) {
                if (arr[j] < arr[i])
                    break;
            }
//为arr[i]在arr[0]...arr[i-1]找个合适的位置，
//找到比自己小的，定为梦中情人，就让j=她的序号，跟在她后面，没找到就插到首位j=0

            if (j != i - 1) {
                temp = arr[i];
                for (int k = i-1; k>j; k--) {//梦中情人之后都往后移动
                    arr[k + 1] = arr[k];
                }
                arr[j+1] = temp;
            }
        }
        for (int item : arr) {
            System.out.printf(item+" ");
        }
        System.out.println();
    }
}

三个排序算法都是O(n^2)的时间复杂度，性能上从弱到强。

转载于:https://my.oschina.net/swanf/blog/1509641