排序Java实现

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

一、归并排序

class Solution {
    private int[] assist;
    private static final int INSERTION_SORT_THRESHOLD = 47;

    public int[] sortArray(int[] nums) {
        assist = new int[nums.length];
        sort(nums, 0, nums.length - 1);
        return nums;
    }

    private void sort(int[] nums, int left, int right) {
        if (right - left < INSERTION_SORT_THRESHOLD) {
            insertionSort(nums, left, right);
            return;
        }
        int mid = left + (right - left) / 2;
        sort(nums, left, mid);
        sort(nums, mid + 1, right);
        if (nums[mid] > nums[mid + 1]) {
            merge(nums, left, mid, right);
        }
    }

    private void merge(int[] nums, int left, int mid, int right) {
        System.arraycopy(nums, left, assist, left, right - left + 1);
        int i = left, j = mid + 1;
        for (int k = left; k <= right; k++) {
            if (i > mid) {
                nums[k] = assist[j++];
            } else if (j > right) {
                nums[k] = assist[i++];
            } else if (assist[i] <= assist[j]) {
                nums[k] = assist[i++];
            } else {
                nums[k] = assist[j++];
            }
        }
    }

    private void insertionSort(int[] nums, int left, int right) {
        for (int i = left + 1; i <= right; i++) {
            int j = i, temp = nums[j];
            while (j > left && nums[j - 1] > temp) {
                nums[j] = nums[j - 1];
                j--;
            }
            nums[j] = temp;
        }
    }
}

二、堆排序

class Solution {
    public int[] sortArray(int[] nums) {
        for (int i = (nums.length - 2) / 2; i >= 0; i--) {
            shiftDown(nums, nums.length, i);
        }
        for (int i = nums.length - 1; i > 0; i--) {
            swap(nums, 0, i);
            shiftDown(nums, i, 0);
        }
        return nums;
    }

    private void shiftDown(int[] nums, int n, int k) {
        int val = nums[k];
        while (2 * k + 1 < n) {
            int j = 2 * k + 1;
            if (j + 1 < n && nums[j + 1] > nums[j]) {
                j++;
            }
            if (val >= nums[j]) {
                break;
            }
            nums[k] = nums[j];
            k = j;
        }
        nums[k] = val;
    }

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

三、快速排序

class Solution {

    private static Random random = new Random();
    private static final int INSERTION_SORT_THRESHOLD = 47;

    public int[] sortArray(int[] nums) {
        quickSort(nums, 0, nums.length - 1);
        return nums;
    }

    private void quickSort(int[] nums, int left, int right) {
        if (right - left < INSERTION_SORT_THRESHOLD) {
            insertionSort(nums, left, right);
            return;
        }
        int p = partition(nums, left, right);
        quickSort(nums, left, p - 1);
        quickSort(nums, p + 1, right);
    }

    private int partition(int[] nums, int left, int right) {
        int idx = random.nextInt(right - left + 1) + left;
        swap(nums, left, idx);
        int pivot = nums[left], j = left;
        for (int i = left + 1; i <= right; i++) {
            if (nums[i] < pivot) {
                j++;
                if (i > j) swap(nums, i, j);
            }
        }
        swap(nums, left, j);
        return j;
    }

    private void insertionSort(int[] nums, int left, int right) {
        for (int i = left + 1; i <= right; i++) {
            int j = i, temp = nums[j];
            while (j > left && nums[j - 1] > temp) {
                nums[j] = nums[j - 1];
                j--;
            }
            nums[j] = temp;
        }
    }

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

四、插入排序

class Solution {
    public int[] sortArray(int[] nums) {
        for (int i = 1; i < nums.length; i++) {
            int j = i, temp = nums[j];
            while (j > 0 && nums[j - 1] > temp) {
                nums[j] = nums[j - 1];
                j--;
            }
            nums[j] = temp;
        }
        return nums;
    }
}

五、选择排序

class Solution {
    public int[] sortArray(int[] nums) {
        for (int i = 0; i < nums.length - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < nums.length; j++) {
                if (nums[j] < nums[minIndex]) {
                    minIndex = j;
                }
            }
            swap(nums, minIndex, i);
        }
        return nums;
    }

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

六、冒泡排序

class Solution {
    public int[] sortArray(int[] nums) {
        boolean swapped = false;
        for (int i = 0; i < nums.length - 1; i++) {
            for (int j = 0; j < nums.length - 1 - i; j++) {
                if (nums[j] > nums[j + 1]) {
                    swap(nums, j, j + 1);
                    swapped = true;
                }
            }
            if (!swapped) break;
        }
        return nums;
    }

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