常用排序算法实现总结

LeetCode912. 排序数组

Tips：

• 选择排序的内部循环是从前往后遍历未排序数组（位置固定，找合适元素）
• 插入排序的内部循环是从后往前遍历已排序数组（元素固定，找合适位置）
• 冒泡排序的外部循环只是为了起到记录迭代次数的作用
• 快排注意while循环内的while循环判断条件要增加外层循环的判断条件，也是归并（判断条件都含等号）的思想，有递归，要先考虑递归出口
• 堆排注意要没有产生交换时就要跳出堆化循环（和插排一样属于往有序集合中插入，未产生交换就要跳出） 归并排序过程中，[l, mid] 和 [mid + 1, r]和分别是排好序的，merge时要注意边界（l <= mid && m <= right）

快排

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

    void sort(int[] nums, int lo, int hi) {
        if (lo >= hi) return; // 判断是否只剩下一个元素，是，则直接返回
        
        // 利用 partition 函数找到一个随机的基准点
        int p = partition(nums, lo, hi);
        
        // 递归地对基准点左半边和右半边的数进行排序
        sort(nums, lo, p - 1);
        sort(nums, p + 1, hi);
    }

    int partition(int[] nums, int lo, int hi) {
        // 随机选择一个数作为基准值，nums[hi] 就是基准值
        // swap(nums, randRange(lo, hi), hi);

        int i, j;

        // 从左到右用每个数和基准值比较，若比基准值小，则放到指针 i 所指向的位置。循环完毕后，i 指针之前的数都比基准值小
        for (i = lo, j = lo; j < hi; j++) {
            if (nums[j] <= nums[hi]) {
                swap(nums, i++, j);
            }
        }
        // 末尾的基准值放置到指针 i 的位置，i 指针之后的数都比基准值大
        swap(nums, i, j);

        // 返回指针 i，作为基准点的位置
        return i;
    }

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

通过迭代来完成根据基准的分区

class Solution {
    public int[] sortArray(int[] nums) {
        if (nums.length <= 1) return nums;
        qsort(nums, 0, nums.length - 1);
        return nums;
    }

    void qsort(int[] nums, int low, int high){
        int l = low;
        int h = high;
        if (l < h) {
            int tmp = nums[l];
            while (l < h) {
                while (l < h && nums[h] >= tmp) h--;
                if (l < h) nums[l] = nums[h];
                while (l < h && nums[l] < tmp) l++;
                if (l < h) nums[h] = nums[l];
            }
            nums[l] = tmp;
            qsort(nums, low, l);
            qsort(nums, l + 1, high);
        }
    }
}

堆排序

class Solution {
    public int[] sortArray(int[] nums) {
        if(nums.length <=1)return nums;
        heapSort(nums);
        return nums;
    }
    
    void heapSort(int[] nums) {
        int size = nums.length;
        for (int i = size/2-1; i >=0; i--) {
            adjust(nums, size, i);
        }

        for (int i = size - 1; i >= 1; i--) {
            int temp = nums[0];
            nums[0] = nums[i];
            nums[i] = temp;
            adjust(nums, i, 0);
        }
    }

    void adjust(int []nums, int len, int index) {
        int l = 2 * index + 1;
        int r = 2 * index + 2;
        int maxIndex = index;
        if (l<len&&nums[l]>nums[maxIndex])maxIndex = l;
        if (r<len&&nums[r]>nums[maxIndex])maxIndex = r;
        if (maxIndex != index) {
            int temp = nums[maxIndex];
            nums[maxIndex] = nums[index];
            nums[index] = temp;
            adjust(nums, len, maxIndex);
        }
    }
}

若带有后续插入重排的操作则需要用下面的heapify方法（左右孩子先比较）

class Solution {
    public int[] sortArray(int[] nums) {
        int n = nums.length;
        if (n <= 1) return nums;

        bulidHeap(nums, n);

        for (int i = n; i > 1; i--) { // 从后往前便于统计
            swap(nums, 0, i-1);
            heapify(nums, i-1, 0);
        }
        return nums;
    }

    private void bulidHeap(int[] nums, int size) {
        for (int i = size / 2; i >= 0; i--) {
            heapify(nums, size, i);
        }
    }

    private void heapify(int[] nums, int k, int i) {
        while (2 * i + 1 < k) { // 加不加1取决于编号从几开始
            int maxPos = 2 * i + 1;
            if (maxPos + 1 < k && nums[maxPos] < nums[maxPos + 1]) maxPos++;
            if (nums[i] < nums[maxPos]) {
                swap(nums, maxPos, i);
                i = maxPos;
            } else {
                break;
            }
        }
    }

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

冒泡排序

class Solution {
    public int[] sortArray(int[] nums) {
        //定义一个布尔变量 hasChange，用来标记每轮遍历中是否发生了交换
        boolean hasChange = true; 

        int n = nums.length;

        //每轮遍历开始，将 hasChange 设置为 false
        for (int i = 0; i < n - 1 && hasChange; i++) {
            hasChange = false;

            //进行两两比较，如果发现当前的数比下一个数还大，那么就交换这两个数，同时记录一下有交换发生
            for (int j = 0; j < n - 1 - i; j++) {
                if (nums[j] > nums[j + 1]) {
                    swap(nums, j, j + 1);
                    hasChange = true;
                }
            }
        }
        return nums;
    }

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

选择排序

选择当前位置应该放入的对应大小元素（即设置当前位置元素为最小值，若未排序数组中有比他小的，则交换）

class Solution {
    public int[] sortArray(int[] nums) {
        int n = nums.length;
        int min = 0;
        for (int i = 0; i < n - 1; i++) {
            min = i;
            for (int j = i + 1; j < n; j++) {
                if (nums[j] < nums[min]){
                    min = j; //先记录，全部比较完后在交换
                }
            }
            if (min != i) {
                swap(nums, min, i);
            }
        }
        return nums;
    }

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

插入排序

不断从无序数组中取第一个元素，而后不断向前比较，若小于则交换，直到放至其适合位置

class Solution {
    public int[] sortArray(int[] nums) {
        int n = nums.length;
        for (int i = 1; i < n; i++) {
            int tmp = nums[i];
            for (int j = i - 1; j >= 0; j--) {
                if(tmp < nums[j]) {
                    nums[j + 1] = nums[j];
                    nums[j] = tmp; // 每次后移都选择将tmp赋值给当前位置，可以处理tmp需要放在第一个的情况
                } else {
                    break;
                }
            }
        }
        return nums;
    }
}

归并排序

mergeSort负责分，merge负责并（生成当前数组范围的新数组，双指针一次比较插入）

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

    private void mergeSort(int[] nums, int l, int r) {
        if (l >= r) {
            return;
        }

        int mid = l + ((r - l) >> 1);

        mergeSort(nums, l, mid);
        mergeSort(nums, mid + 1, r);
        merge(nums, l, mid, r);
    }

    private void merge(int[] nums, int left, int mid, int right) {
        int l = left, m = mid + 1, r = right;
        int k = 0;
        int[] tmp = new int[r - l + 1];

        while (l <= mid && m <= right) {
            if (nums[l] < nums[m]) {
                tmp[k++] = nums[l++];
            } else {
                tmp[k++] = nums[m++];
            }
        }
        while (l <= mid) {
            tmp[k++] = nums[l++];
        }
        while (m <= right) {
            tmp[k++] = nums[m++];
        }

        for (int num : tmp) {
            nums[left++] = num;
        }
    }
}