几大排序的Java实现

最新推荐文章于 2024-10-30 17:05:25 发布

原创最新推荐文章于 2024-10-30 17:05:25 发布 · 222 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#排序算法 #数据结构 #快速排序 #堆排序 #java

Java学习专栏收录该内容

22 篇文章

订阅专栏

插入排序

public static void insertSort(int[] nums) {
    int length = nums.length;
    for (int i = 0; i < length; i++) {
        int j = 0;
        while (j < i) {
            if (nums[j] > nums[i]) {
                int key = nums[i];
                for (int k = i; k > j; k--)
                    nums[k] = nums[k - 1];
                nums[j] = key;
                break;
            }
            j++;
        }
    }
}

选择排序

public static void selectSort(int[] nums) {
    int length = nums.length;
    for (int i = 0; i < length - 1; i++) {
        int maxIndex = i;
        for (int j = i + 1; j < length; j++) {
            maxIndex = nums[j] < nums[maxIndex] ? j : maxIndex;
        }
        int tmp = nums[i];
        nums[i] = nums[maxIndex];
        nums[maxIndex] = tmp;
    }
}

归并排序

public static void mergeSort(int[] nums, int low, int high) {
    if (low >= high)
        return;
    int mid = (low + high) / 2;
    mergeSort(nums, low, mid);
    mergeSort(nums, mid + 1, high);
    int[] tmp = new int[high - low + 1];
    int i = low, j = mid + 1;
    int index = 0;
    while (i <= mid && j <= high) {
        if (nums[i] <= nums[j])
            tmp[index++] = nums[i++];
        else
            tmp[index++] = nums[j++];
    }
    while (i <= mid)
        tmp[index++] = nums[i++];
    while (j <= high)
        tmp[index++] = nums[j++];
    for (int k = low; k <= high; k++)
        nums[k] = tmp[k - low];
}

快速排序

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

计数排序

public static void countSort(int[] nums) {
    int maxNum = Integer.MIN_VALUE;
    int minNum = Integer.MAX_VALUE;
    for (int num : nums) {
        maxNum = num > maxNum ? num : maxNum;
        minNum = num < minNum ? num : minNum;
    }
    int[] bucket = new int[maxNum - minNum + 1];
    for (int i = 0; i < bucket.length; i++)
        bucket[i] = 0;
    for (int num : nums) {
        bucket[num - minNum]++;
    }
    int index = 0;
    for (int i = 0; i < bucket.length; i++) {
        while (bucket[i] > 0) {
            nums[index++] = i + minNum;
            bucket[i]--;
        }
    }
}

基数排序

public static void radixSort(int[] nums) {
    int[][] bucket = new int[10][nums.length];
    int[] cnt = new int[10];
    int maxNum = Integer.MIN_VALUE;
    int minNum = Integer.MAX_VALUE;
    for (int num : nums) {
        maxNum = num > maxNum ? num : maxNum;
        minNum = num < minNum ? num : minNum;
    }
    for (int n = 1; n <= maxNum - minNum; n *= 10) {
        for (int num : nums) {
            int digit = ((num - minNum) / n) % 10;
            bucket[digit][cnt[digit]++] = num;
        }
        int index = 0;
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < cnt[i]; j++)
                nums[index++] = bucket[i][j];
            cnt[i] = 0;
        }
    }
}

堆排序

public static void heapSort(int[] nums) {
    //1.构建大顶堆
    for (int i = nums.length / 2 - 1; i >= 0; i--) {
        //从第一个非叶子结点从下至上，从右至左调整结构
        adjustHeap(nums, i, nums.length);
    }
    //2.调整堆结构+交换堆顶元素与末尾元素
    for (int j = nums.length - 1; j > 0; j--) {
        //将堆顶元素与末尾元素进行交换
        int tmp = nums[0];
        nums[0] = nums[j];
        nums[j] = tmp;
        adjustHeap(nums, 0, j);//重新对堆进行调整
    }
}
public static void adjustHeap(int[] nums, int i, int length) {
    int tmp = nums[i];//先取出当前元素i
    for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {//从i结点的左子结点开始，也就是2i+1处开始
        if (k + 1 < length && nums[k] < nums[k + 1]) {//如果左子结点小于右子结点，k指向右子结点
            k++;
        }
        if (nums[k] > tmp) {//如果子节点大于父节点，将子节点值赋给父节点（不用进行交换）
            nums[i] = nums[k];
            i = k;
        } else {
            break;
        }
    }
    nums[i] = tmp;//将tmp值放到最终的位置
}

测试程序

public class main {
    public static void main(String args[]) {
        int[] nums = {5, -1, 3, 1, 7, 9, 8, -10, 4};
//        insertSort(nums);
//        selectSort(nums);
//        mergeSort(nums,0,nums.length-1);
//        quickSort(nums,0,nums.length-1);
//        countSort(nums);
        radixSort(nums);

        for (int num : nums) {
            System.out.print(num + ", ");
        }
        System.out.println("");
    }
}