数组排序之Java实现

数组排序小结

package main.java.cellar.test;

/**
 * Created by cui on 9/27/14.
 */
public class ArraySorts {
    /**
     * @param args
     */
    public static void main(String[] args) {

        int[] number = { 95, 45, 15, 44, 66, 88, 77 };

        // bubbleSort(number);

        // insertSort(number);

        // shellSort(number);

        // quickSort(number, 0, number.length - 1);
        sort(number, 0, number.length - 1);

        for (int z = 0; z < number.length; z++)
            System.out.print(number[z] + " ");

    }

    /**
     * bubble sort
     *
     * @param number
     */
    public static void bubbleSort(int[] number) {
        int temp = 0;
        for (int i = 0; i < number.length - 1; i++) {
            for (int j = 0; j < number.length - 1 - i; j++) {
                if (number[j] > number[j + 1]) {
                    temp = number[j];
                    number[j] = number[j + 1];
                    number[j + 1] = temp;
                } // if end
            }
        }

    }

    /**
     * insert sort
     *
     * @param number
     */
    public static void insertSort(int[] number) {
        int n = number.length;
        if (n < 2)
            return;

        int i, j, k;
        for (i = 1; i < n; i++) {
            // 为a[i]在前面的a[0...i-1]有序区间中找一个合适的位置
            for (j = i - 1; j >= 0; j--)
                // 如当前值大于已排序好的最大值，则直接结束
                if (number[j] < number[i])
                    break;
            // 如找到了一个合适的位置
            if (j != i - 1) {
                // 将比a[i]大的数据向后移
                int temp = number[i];
                for (k = i - 1; k > j; k--)
                    number[k + 1] = number[k];

                // 将a[i]放到正确位置上
                number[k + 1] = temp;
            }
        }

    }

    /**
     * shell sort
     *
     * @param number
     */
    public static void shellSort(int[] number) {
        int n = number.length;
        if (n < 2)
            return;

        int i, j, gap;

        for (gap = n / 2; gap > 0; gap /= 2)
            // 步长
            for (i = 0; i < gap; i++) // 直接插入排序
            {
                for (j = i + gap; j < n; j += gap) {
                    if (number[j] < number[j - gap]) {
                        int temp = number[j];
                        int k = j - gap;
                        while (k >= 0 && number[k] > temp) {
                            number[k + gap] = number[k];
                            k -= gap;
                        }
                        number[k + gap] = temp;
                    }
                }
            }

    }

    /**
     * quick sort(Divide-and-ConquerMethod) C.R.A.Hoare year 1962
     *
     * @param s
     * @param l
     * @param r
     */
    public static void quickSort(int s[], int l, int r) {
        if (l < r) {
            // 将中间的这个数和第一个数交换
            int i = l, j = r, x = s[l];
            while (i < j) {
                while (i < j && s[j] >= x)
                    // 从右向左找第一个小于x的数
                    j--;
                if (i < j)
                    s[i++] = s[j];

                while (i < j && s[i] < x)
                    // 从左向右找第一个大于等于x的数
                    i++;
                if (i < j)
                    s[j--] = s[i];
            }
            s[i] = x;
            // 分治左右，递归调用
            quickSort(s, l, i - 1);
            quickSort(s, i + 1, r);
        }
    }

    /**
     * part code of DualPivotQuicksort
     *
     * @param a
     * @param left
     * @param right
     */
    public static void sort(int[] a, int left, int right) {
        for (int i = left, j = i; i < right; j = ++i) {
            int ai = a[i + 1];
            while (ai < a[j]) {
                a[j + 1] = a[j];
                if (j-- == left) {
                    break;
                }
            }
            a[j + 1] = ai;
        }
    }
}