三个典型的经典算法冒泡排序，插入排序，选择排序

稍微轻松点，彻底理解了一下这三个算法，当然只是部分，还有什么改良版，具体分类等等，不过下周有事，先把这几个典型的弄明白，老规矩，看代码说问题

/**
 * Created by fanyafeng on 2015/5/8/0008.
 */
public class ALGTest {
    public static void main(String[] args) {
        System.out.println("排序算法");
        System.out.println("-------------------------------------------------------------------");
        domain();
    }

    private static void domain() {
        bubble();
        insert();
        select();
    }

    private static void insert() {
        int[] unbu = {5, 3, 9, 8, 7, 4, 9, 5, 5, 2, 84, 51, 8, 4, 18, 515, 8, 54, 8, 15, 84, 65, 6, 98, 5, 6, 8, 2, 6, 8, 2, 69, 8, 4, 26, 85, 21, 6, 82, 69, 85, 2, 6, 8, 1, 6, 8, 74515, 6, 85, 21, 6, 84, 2, 785, 542, 85, 6, 85, 12};
        //        long bubble_sort_startTime = System.currentTimeMillis();
        long insertionSort_startTime = System.nanoTime();
        insertionSort(unbu);
//        long bubble_sort_endTime = System.currentTimeMillis();
        long insertionSort_endTime = System.nanoTime();
        for (int item : unbu) {
            System.out.print(item + ",");
        }
        System.out.println("\n" + "程序运行时间：" + (insertionSort_endTime - insertionSort_startTime) + "nm或者ms");
    }

    private static void select() {
        int[] unbu1 = {5, 3, 9, 8, 7, 4, 9, 5, 5, 2, 84, 51, 8, 4, 18, 515, 8, 54, 8, 15, 84, 65, 6, 98, 5, 6, 8, 2, 6, 8, 2, 69, 8, 4, 26, 85, 21, 6, 82, 69, 85, 2, 6, 8, 1, 6, 8, 74515, 6, 85, 21, 6, 84, 2, 785, 542, 85, 6, 85, 12};
//        long startTime = System.currentTimeMillis();
        long startTime = System.nanoTime();
        selection_sort(unbu1);
//        long endTime = System.currentTimeMillis();
        long endTime = System.nanoTime();
        for (int item : unbu1) {
            System.out.print(item + ",");
        }
        System.out.println("\n" + "程序运行时间：" + (endTime - startTime) + "nm或者ms");
    }

    private static void bubble() {
        int[] unbu3 = {5, 3, 9, 8, 7, 4, 9, 5, 5, 2, 84, 51, 8, 4, 18, 515, 8, 54, 8, 15, 84, 65, 6, 98, 5, 6, 8, 2, 6, 8, 2, 69, 8, 4, 26, 85, 21, 6, 82, 69, 85, 2, 6, 8, 1, 6, 8, 74515, 6, 85, 21, 6, 84, 2, 785, 542, 85, 6, 85, 12};
//        long bubble_sort_startTime = System.currentTimeMillis();
        long bubble_sort_startTime = System.nanoTime();
        bubble_sort(unbu3);
//        long bubble_sort_endTime = System.currentTimeMillis();
        long bubble_sort_endTime = System.nanoTime();
        for (int item : unbu3) {
            System.out.print(item + ",");
        }
        System.out.println("\n" + "程序运行时间：" + (bubble_sort_endTime - bubble_sort_startTime) + "nm或者ms");
    }


    public static void insertionSort(int[] unsort) {
        /**
         * 插入排序，这个的外层循环直接从1开始，后面没有减1
         * 这个稍微复杂一点，但是效率是最高的，我没用统计学的方法，我是测试了有那么个几十次，大家自己也可以测试下
         * 看看我说的是不是对的
         * 外循环还是老样子，将值取出来，其实不难理解，排序就是比较大小的过程，如果没有一个作为被比较的
         * 那这个算法也是不成立的，这样大家写的话其实最外面的一层想都不用想，惯性的就应该写出来
         *每次都将最大的放在最后面
         *可以理解为都是从数组的最后面进行插入
         */
        int i, j, k;
        for (i = 1; i < unsort.length; i++) {
            k = unsort[i];//取出
            /**
             * 查找位置
             * 第一次的时候
             * 这里说一下unsort[j]=unsort[i-1],k=unsort[i]<unsort[j]
             * 那么也就是说unsort[i]<unsort[i-1]
             * 也就是unsort[j+1]<unsort[j]=k
             */
            for (j = i - 1; j >= 0 && k < unsort[j]; j--) {
                unsort[j + 1] = unsort[j];//向后移动元素
            }
            unsort[j + 1] = k;//插入
        }
    }

    private static void selection_sort(int[] unsort) {
        /**
         * 选择排序
         * 外面的循环是先取出一个值，也就是unsort[i]
         * 里面的循环是出去外面的取得那个值，其实就是每次排序的第一个值，然后将其遍历
         * 并且和第一个做比较如果外循环取得数字大的话则调换顺序，反之不变
         * 相信说到这大家都能很清楚的理解了把，这个是将其从小到大排列
         * 如果从大到小的话只用将if里面的符号改一下就行了
         * 对了说漏了一点，就是数组的个数外循环遍历的话，是要减去1的，不然有个无效遍历
         * 会影响效率的
         * 下面的话是不能减一的，因为他就是从i+1开始的，外层则是从0开始，length需要减去一
         * 下面的减去一肯定会漏掉东西的
         */
        for (int i = 0; i < unsort.length - 1; i++) {
            for (int j = i + 1; j < unsort.length; j++) {
                if (unsort[i] > unsort[j]) {
                    int temp = unsort[i];
                    unsort[i] = unsort[j];
                    unsort[j] = temp;
                }
            }
        }
    }

    private static void bubble_sort(int[] unsort) {
        /**
         * 冒泡排序,基本的冒泡排序，貌似还有改良版，一会再说，先说这个
         * 先简单来说一下冒泡的意思把，就是每次都把两个数相比之下大的那个放在最上面就是大的那头
         * 这样的话理解下下面的应该简单了吧
         * 同样外层循环遍历所有unsort
         * 然后内层循环开始取值比较大小
         * 它会一次次的比较相邻的两个数的数值，每次都把大的放在前面
         * 这样的话最后一趟遍历就会把所有的都排列好
         */
        for (int i = 0; i < unsort.length - 1; i++) {
            for (int j = 0; j < unsort.length - i - 1; j++) {
                if (unsort[j] > unsort[j + 1]) {
                    int temp = unsort[j];
                    unsort[j] = unsort[j + 1];
                    unsort[j + 1] = temp;
                }
            }
        }
    }


}

面试问的最多的貌似就是冒泡算法，这里博主把解释都放到代码里了，具体的可以细看，博主不多说了，估计要匿一周

忘了，上一下输出

<img src="http://img.blog.csdn.net/20150510202416892?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvcXFfMjMxOTU1ODM=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center" alt="" />