简单排序（冒泡、选择、插入）

冒泡排序、选择排序和插入排序代码如下：

package cn.luxh.app.test;

public class SimpleSortUtil {
    
    /**
     * 冒泡排序
     * 从小到大排序
     * 思路：
     * 1）第一趟排序进行了len-1次比较，数组中的最大值元素排到了最末端，位置已固定，该元素不再参与下趟比较
     * 2）第二趟排序进行了len-2次比较，因为只需要比较到第一个位置固定的元素（第一趟排序中的最大值元素）即可，数组中的第二大值元素位置也已固定，该元素不再参与下趟比较
     * 3）第三趟排序进行了len-3次比较，因为只需要比较到第一个位置固定的元素（第二趟排序中的最大值元素）即可，数组中的第三大值元素位置也已固定，该元素不再参与下趟比较
     * 4）依次类推...
     * 
     * @param array
     * @return
     */
    public static int[] bubbleSort(int[] array) {
        int out;//外层循环计数
        int in;//内层循环计数
        int len = array.length;
        
         //1）外层for循环计数器out从数组的最后开始，即out等于len-1,每经过一次循环，out减1（往左移）；
         //2）下标大于out的元素都是已经排好序的了；
         //3）内层for循环计数器in从数组的最开始算起，即in=0,每完成一次内部循环加1，当in等于out时结束一次循环。
         //4）在内层循环中，比较in和in+1的两个元素
        for(out=len-1;out>1;out--) {
            //下标大于out的元素都是已经排好序的，不用再处理。
            for(in=0;in<out;in++) {
                if(array[in]>array[in+1]) {
                    //当前元素值比后面的元素值大，则交换两个元素的位置
                    int temp = array[in];
                    array[in] = array[in+1];
                    array[in+1] = temp;
                }
            }
        }
        return array;
    }
    
    
    /**
     * 选择排序
     * 从小到大排序
     * 思路：
     * 1）第一趟比较时，找到最小的元素，然后这个最小元素和数组最左边（下标为0）的元素交换位置，这个最小值不再参与下次比较
     * 2）第二趟比较时，从下标为1的元素开始，找到最小的元素，然后把这个最小值元素和下标为1的元素交换位置，这个最小元素不再参与下次比较
     * 3）依次类推...
     * @param array
     * @return
     */
    public static int[] selectionSort(int[] array) {
        int min;//最小值下标
        int in;//内层循环计数
        int out;//外层循环计数
        int len = array.length;
        
        
        for(out=0;out<len-1;out++) {
            min = out;//最小值下标初始化
            for(in=out+1;in<len;in++) {
                //如果有元素比array[min]小，则把下标赋给min
                if(array[in]<array[min]) {
                    min = in;
                }
            }
            //内层循环每结束一次，就把找到的最小元素和外层循环开始的元素交换
            int temp = array[out];
            array[out] = array[min];
            array[min] = temp;
        }
        return array;
    }
    
    /**
     * 插入排序
     * 从小到大
     * 在外层的for循环中，out计数器从1开始，向右移动，它标记了未排序部分的最左端的数据；
     * 在内层的while循环中，in计数器从out开始，向左移动，直到temp变量（标志位）的值小于in所指的数组值和in不能再向左移动为止
     * while循环的每一趟都向右移动了一个已排序的元素
     * 
     * 
     * @param array
     * @return
     */
    public static int[] insertSort(int[] array) {
        int in;//内层循环计数
        int out;//外层循环计数
        int len = array.length;
        for(out=1;out<len;out++) {
            //移出标志位值
            int temp = array[out];
            in = out;
            while(in>0 && array[in-1] >=temp) {
                //大于标志位的值，则右移
                array[in] = array[in-1];
                in--;//左移计数器
            }
            //插入标志为值
            array[in] = temp;
        }
        return array;
    }
    
}

测试：

package cn.luxh.app.test;

import org.junit.Test;

public class SimpleSortTester {
    
    @Test
    public void testSort() {
        int[] array = {6,45,35,23,78,34,26,67,38,90,345,2345,12,3568,80,100};
        //SimpleSortUtil.bubbleSort(array);
        //SimpleSortUtil.selectionSort(array);
        SimpleSortUtil.insertSort(array);
        displayArray(array);
    }
    
    public void displayArray(int[] array) {
        for(int a:array) {
            System.out.println(a);
        }
    }
    
}

　　这几种简单排序算法时间复杂度都是O(N²)，一般都是在数据量小的情况下考虑使用。

　　冒泡排序效率最差；

　　选择排序降低了元素交换的次数；

　　基本上有序时，插入排序比冒泡排序和选择排序要好些。