排序算法

为什么80%的码农都做不了架构师？>>>   

1.选择排序算法

选择排序算法通过反复地将某一特定值放到它在列表中的最终已排序位置从而完成对某一列值的排序。

先选出列表中最小的数值，然后将它与列表中第一个位置的值交换位置。然后扫描剩下部分最小的值，并和列表第二个位置的值做交换，以此类推。得到的列表第一个位置的值为最小值，最后一个位置的值为最大值。

    /**
     * 选择排序
     * @param data
     */
    public static  void selectionSort(int [] data) {
        int min;
        int temp;
        for (int index = 0; index< data.length; index++) {
            min = index;
            for(int scan = index + 1; scan < data.length; scan++) {
                //得到最小值的索引
                if (data[scan] < data[index]) {
                    min = scan;
                }
            }
            temp = data[index];
            data[index] = data[min];
            data[min] = temp;
        }
    }

注意，因为该算法每一重复过程都在寻找最小值，所以结果是数组按照升序排列，如果要让数组按照降序排列每次都寻找最大值即可。

2.插入排序法

插入排序算法同故宫反复地将某一特定值插入到该数组某个已排序的子集中来完成对数组的排序。

    /**
     * 插入排序
     * 提取某一特定值逐次与前面已经排序好的元素进行比较，如果小于前一个元素，则把前一个元素换到该元素位置并继续向前比较
     * 直到大于前一个元素则将这个元素放置在当前的位置。
     * @param data
     */
    public static void insertionSort(int[] data) {
        for (int index=1;index<data.length;index++) {
            //从第二个元素开始，遍历数组元素
            int key = data[index];//取得当前元素
            int position = index;//当前元素位置
            //将元素不断和前面的元素进行比较，如果小于前面的元素则和前面的元素互换位置，如果大于前面的元素则进行下一次外层循环
            while (position > 0 && key < data[position - 1]) {
                data[position] = data[position - 1];//将元素向后挪动一位
                position --;
            }
            data[position] = key;
        }
    }

3.冒泡排序法

冒泡排序算法通过重复地比较相邻的元素且在必要时将他们呼唤，从而完成对某个数组的排序。

通俗的讲就是不断的将最大数放置在数组的最左侧，共进行n-1次排序（最后一轮只有索引为0的元素）。每一轮排序都从最左侧元素开始和相邻的元素比较，将每次比较的最大值放在右侧，最终将此次排序的最大值放在进行排序的元素的最左侧。

  /**
     * 冒泡排序法
     * @param data
     */
    public static void bubbleSort(int[] data) {

        int position, scan;
        for (position = data.length - 1; position > 0; position--) {
            /**
             *  外层循环控制每次排序结束位置每次排序后position减1，
             *  同时position也是此次排序最大值的放置位置
             */
            for (scan = 0; scan < position; scan++) {
                /**
                 *  如果前一个元素大于后一个元素则，两元素互换位置,
                 *  scan是当前元素的位置要小于position否则data[scan + 1]会导致数组越界
                 */
                if (data[scan] > data[scan + 1]) {
                    int temp = data[scan];
                    data[scan] = data[scan + 1];
                    data[scan + 1] = temp;
                }
            }
        }
    }

4.快速排序法

前几种排序算法都使用了一对嵌套循环，为了对一个含n个元素的数组排序，需要大约进行次比较操作。现在，我们将注意力转移到更加有效率的排序法上，他们给其自身提供了一个递归实现。

 /**
     * 快速排序
     * @param data  要排序的数组
     * @param left  最左端元素
     * @param right 最右端元素
     */
    public static void quickSort(int[] data, int left, int right) {
        //如果left大于等于right，需要排序的部分只有一个元素,方法返回
        if (left >= right) { return; }
        //设置最左边的元素为基准点pivot
        int p = data[left];
        //把要排序的序列中比p大的放到右边，比p小的放到左边，p的下标位置为i
        int i = left,j = right;
        while (i<j) {
            //j向左移寻找比p小的元素
            while (i<j && data[j]>=p) {//i如果等于j就代表这轮比较结束了，所以要限制j不等于i
                j--;//不断左移
            }
            //i向右移找到比p大的元素
            while (i<j && data[i] <= p) {
                i++;//不断右移
            }
            //交换i、j位置
            if (i < j) {
                int temp = data[i];
                data[i] = data[j];
                data[j] = temp;
            }
        }
        /**
         * 当i=j结束循环，
         * 那么运用分治思想需要得到新的基准点
         */
        data[left] = data[i];
        data[i] = p;
        //对序列中，i左边的元素实施快速排序
        quickSort(data,left,i-1);
        //对序列中，i右边的元素实施快速排序
        quickSort(data,i+1,right);
    }

转载于:https://my.oschina.net/codelx/blog/1548163