Java-快排-堆排-归并

Handsomk

于 2022-02-20 10:43:06 发布

阅读量71

点赞数

分类专栏： LeetCode 文章标签： java 排序算法 leetcode

本文链接：https://blog.csdn.net/weixin_43438720/article/details/123027923

版权

LeetCode 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

这篇博客深入介绍了三种常见的排序算法：快速排序、堆排序和归并排序。快速排序通过选取基准元素进行分区，然后递归排序两部分；堆排序利用最大堆或最小堆的性质，调整数组使其满足堆特性；归并排序则采用分治策略，将数组分为两半，分别排序后再合并。这些算法各有特点，在不同场景下有不同的效率表现。

摘要由CSDN通过智能技术生成

快速排序


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

    public void quickSort(int[] nums, int left, int right) {
        if (left < right) {
            int index = partition(nums, left, right);
            quickSort(nums, left, index - 1);
            quickSort(nums, index + 1, right);
        }
    }

    public int partition(int[] nums, int l, int r) {
        int k = new Random().nextInt(r - l + 1) + l;
        swap(nums, k, r);
        int pivot = nums[r];
        while (l < r) {
            while (l < r && nums[l] <= pivot) l++;
            nums[r] = nums[l];
            while (l < r && nums[r] > pivot) r--; //注意这里是r--
            nums[l] = nums[r];
        }
        nums[r] = pivot;
        return r;
    }

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

堆排序

package com.mk.www;

public class HeapSort {
    public int[] SortArray(int[] nums) {
        heapSort(nums);
        return nums;
    }

    public void heapSort(int[] nums) {
        int n = nums.length;
        buildMaxHeap(nums, n);
        for (int i = n - 1; i >= 1; --i) {
            swap(nums, 0, i);
            n--;
            adjustHeap(nums, 0, n);
        }
    }
    public void buildMaxHeap(int[] nums, int len) {
        for (int i = len / 2; i >= 0; --i) {
            adjustHeap(nums, i, len);
        }
    }

    public void adjustHeap(int[] nums, int root, int len) {
        for (; (root << 1) + 1 < len;) {
            int l = (root << 1) + 1;
            int r = (root << 1) + 2;
            int large = root;
            if (nums[l] > nums[large]) large = l;
            if (r < len && nums[r] > nums[large]) large = r;
            if (large != root) {
                swap(nums, large, root);
                root = large;
            } else {
                break;
            }
        }
    }

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

归并排序

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

    public void mergeSort(int[] nums, int l, int r) {
        if (l >= r) return;
        int mid = (l + r) / 2;
        mergeSort(nums, l, mid);
        mergeSort(nums, mid + 1, r);
        int[] b = new int[nums.length];
        int i = l, j = mid + 1, k = 0;
        while (i <= mid && j <= r) {
            if (nums[i] < nums[j]) {
                b[k++] = nums[i++];
            } else {
                b[k++] = nums[j++];
            }
        }
        while (i <= mid) b[k++] = nums[i++];
        while (j <= r) b[k++] = nums[j++];
        for (int p = 0; p < k; p++) {
            nums[p + l] = b[p];
        }
    }
}