常用的排序算法回顾

public class 排序算法 {
    static int[] nums = { 3, 10, 28, 9, 5, 3, 9, 3, 1, 7, 5, 10, 35, 100 };
    static int[] nums1 = { 3, 10, 28, 9, 5, 3, 9, 3, 1, 7, 5, 10, 35, 100 };
    static int[] nums2 = { 49, 38, 65, 97, 26, 13, 27, 49, 55, 4 };

    static int[] positiveNums = { 1, 2, 3, 4, 5 };
    static int[] reverseNums = { 5, 4, 3, 2, 1 };

    public static void main(String[] args) {
//      bubbleSort(nums); 
//      shellSort(nums2);
//      insertSort(nums1);
        fastSort(nums1);
    }

    // 冒泡排序
    /*
     * 原理：从数组中最下面的元素与上面的元素进行比较，比上面的小，就交换。
     * 交换后在与其前一个进行比较，如果还比其小，就再与前一个进行比较，以此类推。
     * 一遍遍历后，会将最小的元素放到最前面，下次遍历则从最下面的元素遍历到最前的元素-1个即可。
     */
    public static void bubbleSort(int[] arrays) {
        int temp = 0;
        int changeTimes = 0;
        for (int j = arrays.length - 1; j > 0; j--) {
            for (int i = 0; i < j; i++) {
                if (arrays[i] > arrays[i + 1]) {
                    swap(arrays, i, i + 1);
                    changeTimes++;
                    System.out.println(Arrays.toString(arrays));
                }
            }
        }
        System.out.println("\t" + "交换次数：" + changeTimes + " 次");
    }

    public static void swap(int arrays[], int a, int b) {
        int temp = 0;
        temp = arrays[a];
        arrays[a] = arrays[b];
        arrays[b] = temp;
    }

    // 插入排序
    /*
     * 原理：初始化数组只有一个元素，将剩余元素每次都与数组内的元素从后向前进行比较，
     * 如果比前面的元素小，则将大的数进行向后移动，给这个添加的小的元素腾出位置，最后放入。
     * 
     */
    public static void insertSort(int[] arrays) {
        int changeTimes = 0;
        for (int i = 1; i < arrays.length; i++) {
            for (int j = i; j > 0; j--) {
                if (arrays[j - 1] > arrays[j]) {
                    swap(arrays, j - 1, j);
                    changeTimes++;
                    System.out.println(Arrays.toString(arrays));
                }
            }
        }
        System.out.println("\t" + "交换次数：" + changeTimes + " 次");
    }

    // 希尔排序 使用步长进行排序
    /*
     *原理：优化的插入排序。
     * 将一组待插入排序的数组，按照步长进行分组，每次划分的单元越来越小，最后步长为0时，则为整个数组都排好序列了
     * 
     */
    public static void shellSort(int[] arrays) {
        int gap = 0;
        int changeTimes = 0;
        for (gap = arrays.length / 2; gap > 0; gap /= 2) {
            System.out.println("gap : " + gap);
            // 使用gap将比较的数组分为几组
            for (int i = 0; i < gap; i++) {
                for (int j = i; j < arrays.length; j += gap) {
                    for (int k = j; k - gap >= 0; k -= gap)
                        if (arrays[k - gap] > arrays[k]) {
                            swap(arrays, k, k - gap);
                            changeTimes++;
                            System.out.println(Arrays.toString(arrays));
                        }
                }
            }

        }
        System.out.println("\t" + "交换次数：" + changeTimes + " 次");
    }

    // 快速排序
    /*
     * 
     * 先找出最左边的数为基数，将从右边选比基数小的数放左边，从左边选比基数大的数放右边。
     * 分治算法+递归，最后得出最终排好序的队列。
     */
    public static void fastSort(int[] arrays) {
        System.out.println(Arrays.toString(arrays));
        quicksort(arrays, 0, arrays.length - 1);
        System.out.println(Arrays.toString(arrays));
    }

    public static void quicksort(int[] arrays, int l, int r) {
        if (l >= r) {
            return;
        }
        int left = l;
        int right = r;
        int base = arrays[l];
        boolean directionToRight = true;// 初始化方向从左到右
        L: while (left < right) {
            if(directionToRight) {
            for (int i = left; i < right; i++) {
                if (arrays[i] >= base) {
                    arrays[right] = arrays[i];
                    right--;
                    left = i;
                    directionToRight = !directionToRight;
                    continue L;
                }
            }
            left = right;
            }
            else {
            for (int i = right; i > left; i--) {
                if (arrays[i] <= base) {
                    arrays[left] = arrays[i];
                    left++;
                    right = i;
                    directionToRight = !directionToRight;
                    continue L;
                }
            }
            right = left;
        }
        }
        arrays[left] = base;
        quicksort(arrays,l,left-1);
        quicksort(arrays,left +1,r);
    }

}