常见排序算法

以后有时间再补充

package com.suanfa.paixv;

import java.util.Arrays;
import java.util.Random;

public class Test {
    public static void main(String[] args) {
            int num = 100000;
            Random random = new Random();
            int[] nums = new int[num];
            for (int i = 0; i < num; i++) {
                nums[i] = random.nextInt(num * 10);
            }
            int[] nums2 = new int[num];
            System.arraycopy(nums, 0, nums2, 0, num);
//        int[] nums = {3, 2, 1, 4};
//        System.out.println(Arrays.toString(nums));
            long l = System.currentTimeMillis();
            shellSort(nums, 3);
            long l2 = System.currentTimeMillis();
            System.out.println("排序时间: " + (l2 - l));
//        System.out.println(Arrays.toString(nums));
            System.out.println(sortTrue(nums) ? "排序成功" : ("错误数组: " + Arrays.toString(nums2)));
        }

    // 15688, 15903, 13828, 13794, 13796
    public static void bubbleSort(int[] nums) {
        for (int i = nums.length - 1; i > 0; i--) {
            for (int j = 0; j < i; j++) {
                if (nums[j] > nums[j + 1]) {
                    swap(nums, j, j + 1);
                }
            }
        }
    }

    // 5094, 4974, 3767, 4029, 3864
    public static void selectionSort(int[] nums) {
        for (int i = 0; i < nums.length - 1; i++) {
            int min = i;
            for (int j = i + 1; j < nums.length; j++) {
                if (nums[j] < nums[min]) {
                    min = j;
                }
            }
            swap(nums, i, min);
        }
    }

    // 1276, 1118, 982, 904, 991
    public static void insertionSort(int[] nums) {
        for (int i = 1; i < nums.length; i++) {
            int cur = nums[i];
            int j = 0;
            for (j = i; j > 0; j--) {
                if (nums[j - 1] > cur) {
                    nums[j] = nums[j - 1];
                } else {
                    break;
                }
            }
            nums[j] = cur;
        }
    }

    // 24, 20, 15, 16,  18
    public static void shellSort(int[] nums) {
        for (int h = nums.length / 2; h > 0; h/= 2) {
            for (int i = h; i < nums.length; i++) {
                int cur = nums[i];
                int j = 0;
                for (j = i; j >= h; j -= h) {
                    if (nums[j - h] > cur) {
                        nums[j] = nums[j - h];
                    } else {
                        break;
                    }
                }
                nums[j] = cur;
            }
        }
    }

    // incr：最小增量，2和3比较常见
    // 2: 29, 16, 12, 14, 13; 3: 15, 11, 15, 15, 11
    public static void shellSort(int[] nums, int incr) {
        int h = 1;
        while (h < nums.length / incr) {
            h = h * incr + 1;
        }
        while (h >= 1) {
            for (int i = h; i < nums.length; i++) {
                int cur = nums[i];
                int j = 0;
                for (j = i; j >= h; j -= h) {
                    if (nums[j - h] > cur) {
                        nums[j] = nums[j - h];
                    } else {
                        break;
                    }
                }
                nums[j] = cur;
            }
            h /= incr;
        }
    }

    public static void mergeSort(int[] nums) {  // 28, 16, 14, 12, 11
        mergeSort(nums, 0, nums.length - 1);
    }

    public static void mergeSort(int[] nums, int left, int right) {
        if (left >= right) {
            return;
        }
        int mid = (left + right) / 2;
        mergeSort(nums, left, mid);
        mergeSort(nums, mid + 1, right);
        int i = left;
        int j = mid + 1;
        int len = right - left + 1;
        int[] nums2 = new int[len];
        for (int k = 0; k < len; k++) {
            if (j > right || (i <= mid && nums[i] < nums[j])) {
                nums2[k] = nums[i++];
            } else {
                nums2[k] = nums[j++];
            }
        }
        System.arraycopy(nums2, 0, nums, left, len);
    }

    public static void quickSort(int[] nums) {  // 27, 20, 12, 12, 12
        quickSort(nums, 0, nums.length - 1);
    }

    public static void quickSort(int[] nums, int left, int right) {
        if (left >= right) {
            return;
        }
        int i = left;
        int j = right;
        int key = nums[i];
        while (i < j) {
            while (i < j && nums[j] >= key) {
                j--;
            }
            if (i < j) {
                nums[i] = nums[j];
            }
            while (i < j && nums[i] <= key) {
                i++;
            }
            if (i < j) {
                nums[j--] = nums[i];
            }
        }
        nums[i] = key;
        quickSort(nums, left, i - 1);
        quickSort(nums, i + 1, right);
    }

    public static void swap(int[] nums, int i, int j) {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }

    public static boolean sortTrue(int[] nums) {
        for (int i = 0; i < nums.length - 1; i++) {
            if (nums[i] > nums[i + 1]) {
                return false;
            }
        }
        return true;
    }
}