排序算法

参考：http://easense2009.iteye.com/blog/1568614
http://www.cnblogs.com/morewindows/archive/2011/08/13/2137415.html

package com.test;

public class Sort {
    public static void main(String[] args) {
        Sort p = new Sort();
        p.Sort_Quick(p.array, 0, p.array.length);
        p.print(p.array);

    }

    public int[] array = { 3, 2, 19, 7, 6, 20 };

    public void print(int[] array) {
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + ",");
        }
        System.out.println();
    }

    /***
     * 选择排序的基本思想是遍历数组的过程中，以 i 代表当前需要排序的序号，则需要在剩余的 [i…n-1] 中找出其中的最小值，然后将找到的最小值与 i
     * 指向的值进行交换。因为每一趟确定元素的过程中都会有一个选择最大值的子流程，所以人们形象地称之为选择排序。
     * 
     * @param array
     * @return
     */
    public int[] Sort_xuanze(int[] array) {
        for (int i = 0; i < array.length; i++) {
            for (int j = i + 1; j < array.length; j++) {
                if (array[i] > array[j]) {
                    int tmp = array[j];
                    array[j] = array[i];
                    array[i] = tmp;
                }
            }
        }
        return array;
    }

    /***
     * 冒泡排序可以算是最经典的排序算法了，记得小弟上学时最先接触的也就是这个算法了，因为实现方法最简单，两层 for
     * 循环，里层循环中判断相邻两个元素是否逆序
     * ，是的话将两个元素交换，外层循环一次，就能将数组中剩下的元素中最小的元素“浮”到最前面，所以称之为冒泡排序。
     * 
     * 大值元素放后边
     * 
     * @param array
     * @return
     */
    public int[] Sort_maopao(int[] array) {
        for (int i = 0; i < array.length; i++) {// 次数
            for (int j = 0; j < array.length - i - 1; j++) {// 两两比较大的放后边
                int a1 = array[j];
                int a2 = array[j + 1];
                if (a1 > a2) {
                    int tmp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = tmp;
                }
            }
        }
        return array;
    }

    /***
     * 插入排序的基本思想是在遍历数组的过程中，假设在序号 i 之前的元素即 [0..i-1] 都已经排好序，本趟需要找到 i 对应的元素 x 的正确位置
     * k ，并且在寻找这个位置 k 的过程中逐个将比较过的元素往后移一位，为元素 x “腾位置”，最后将 k 对应的元素值赋为 x
     * ，插入排序也是根据排序的特性来命名的。
     * 
     * @param array
     * @return
     */
    public int[] Sort_Insert(int[] array, int start, int len) {
        for (int i = start + 1; i < len; i++) {
            int k = -1;
            for (int j = start; j < i; j++) {
                if (array[i] < array[j]) {
                    k = j;
                    break;
                }
            }
            // k为插入位置
            if (k >= 0) {// 移位
                int tmp = array[i];
                for (int p = i - 1; p >= k; p--) {
                    array[p + 1] = array[p];
                }
                array[k] = tmp;
            }

        }
        return array;
    }

    /***
     * 希尔排序的诞生是由于插入排序在处理大规模数组的时候会遇到需要移动太多元素的问题。希尔排序的思想是将一个大的数组“分而治之”，划分为若干个小的数组，
     * 以 gap 来划分，比如数组 [1, 2, 3, 4, 5, 6, 7, 8] ，如果以 gap = 2 来划分，可以分为 [1, 3, 5,
     * 7] 和 [2, 4, 6, 8] 两个数组（对应的，如 gap = 3 ，则划分的数组为： [1, 4, 7] 、 [2, 5, 8] 、
     * [3, 6] ）然后分别对划分出来的数组进行插入排序，待各个子数组排序完毕之后再减小 gap 值重复进行之前的步骤，直至 gap = 1
     * ，即对整个数组进行插入排序，此时的数组已经基本上快排好序了，所以需要移动的元素会很小很小，解决了插入排序在处理大规模数组时较多移动次数的问题。
     * 
     * @param array
     * @return
     */
    public int[] Sort_xier(int[] array) {
        int gap = 1;
        while (gap < array.length / 3) {
            gap = gap * 3 + 1;
        }
        while (gap >= 1) {
            int num = array.length / gap;
            for (int i = 0; i < gap; i++) {
                int len = num;
                if (i == gap - 1) {
                    len = array.length - num * i;
                }
                Sort_Insert(array, num * i, len);
            }
            gap = gap / 3;
        }
        return array;
    }

    /***
     * 归并排序采用的是递归来实现，属于“分而治之”，将目标数组从中间一分为二，之后分别对这两个数组进行排序，排序完毕之后再将排好序的两个数组“归并”
     * 到一起，
     * 
     * @param array
     * @param start
     * @param len
     */
    public void Sort_digui(int[] array, int start, int len) {
        if (len <= 1) {
            return;
        }
        int mid = start + len / 2;
        int len1 = len / 2;
        int len2 = len - len / 2;
        Sort_digui(array, start, len1);// 前面排序
        Sort_digui(array, mid, len2);// 后面排序
        // 合并
        int[] array1 = new int[array.length];
        System.arraycopy(array, 0, array1, 0, array.length);

        int i = 0;
        int j = 0;
        int l = 0;
        while (i < len1 || j < len2) {
            if (i < len1 && j < len2) {
                if (array1[start + i] > array1[mid + j]) {
                    array[start + l] = array1[mid + j];
                    j++;
                } else {
                    array[start + l] = array1[start + i];
                    i++;
                }
            } else if (i < len1) {
                array[start + l] = array1[start + i];
                i++;
            } else if (j < len2) {
                array[start + l] = array1[mid + j];
                j++;
            }
            l++;
        }

    }

    /***
     * 快速排序方法的基本思想是：
     * <p>
     * 1．先从数列中取出一个数作为基准数。
     * <p>
     * 2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
     * <p>
     * 3．再对左右区间重复第二步，直到各区间只有一个数。
     * <p>
     * 
     * @param array
     */
    public void Sort_Quick(int[] array, int start, int len) {
        if (len <= 1) {
            return;
        }
        //
        int[] array1 = new int[array.length];
        System.arraycopy(array, 0, array1, 0, array.length);

        // 放入cur
        int curValue = array[start];
        int cur = start;
        int lenPaixu = 1;
        //开始排序
        for (int i = start + 1; i < start+len; i++) {
            if (array1[i] <= curValue) {// 小于cur的 放入cur左边(start 位置)
                for (int j = start + lenPaixu - 1; j >= start; j--) {
                    array[j + 1] = array[j];
                }
                array[start] = array1[i];
                cur++;
            } else {
                array[start+lenPaixu] = array1[i];
            }
            lenPaixu++;
        }
        
        Sort_Quick(array, start, cur-start);
        Sort_Quick(array, cur+1, len-(cur-start)-1);

    }

}