排序效率,快排归并堆排Java实现

常见的排序时间复杂度与空间复杂度

排序算法 平均时间复杂度 最坏时间复杂度 空间复杂度 是否稳定
冒泡排序 On2 On2 O(1)
选择排序 On2 On2 O(1) 不是
直接插入排序 On2 On2 O(1)
归并排序 O(nlogn) O(nlogn) 单元格
快速排序 O(nlogn) On2) O(nlogn) 不是
堆排序 O(nlogn) O(nlogn) O(1) 不是
希尔排序 O(nlogn) Ons O(1) 不是
计数排序 O(n+k) O(n+k) O(n+k)
基数排序 O(NM) O(NM) O(M)

排序原理动画

实现代码

快速排序

package com.leetcode.sort;

import java.util.Arrays;

/**
 * @Auther: Jibny Zhan
 * @Date: 2019/11/30 20:12
 * @Description:
 */
public class QuickSort {

    private static int count;

    private static void QuickSort(int[] num, int left, int right) {
        if (left >= right)
            return;
        int i = left;
        int j = right;
        int key = num[left];
        while (i < j) {
            if (num[j] >= key && i < j)
                j--;
            else if (num[i] <= key && i < j)
                i++;
            else {
                num[i] ^= num[j];
                num[j] ^= num[i];
                num[i] ^= num[j];
            }
        }
        num[left] = num[i];
        num[i] = key;
        count++;
        QuickSort(num, left, i - 1);
        QuickSort(num, i + 1, right);
    }

    public static void main(String[] args) {
        int[] num = {45, 3, 78, 64, 52, 11, 64, 55, 99, 11, 18};
        System.out.println(Arrays.toString(num));
        QuickSort(num, 0, num.length - 1);
        System.out.println(Arrays.toString(num));
        System.out.println("数组个数:" + num.length);
        System.out.println("循环次数:" + count);

    }

}

归并排序

package com.leetcode.sort;

import java.util.Arrays;

/**
 * @Auther: Jibny Zhan
 * @Date: 2019/12/1 00:42
 * @Description:
 */
public class MergeSort {

    private static void sort(int[] arr) {
        mergeSort(arr, 0, arr.length - 1);
    }
	
    //分割
    private static void mergeSort(int[] arr, int left, int right) {
        if (left == right)
            return;
        int mid = (left + right) >> 1;
        mergeSort(arr, left, mid);
        mergeSort(arr, mid + 1, right);
        merge(arr, left, mid, right);
    }

    //合并
    private static void merge(int[] arr, int left, int mid, int right) {
        int[] temp = new int[right - left + 1];
        int i = 0;
        int p1 = left;
        int p2 = mid + 1;
        while (p1 <= mid && p2 <= right)
            temp[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
        while (p1 <= mid)
            temp[i++] = arr[p1++];
        while (p2 <= right)
            temp[i++] = arr[p2++];
        for (i = 0; i < temp.length; i++) {
            arr[left + i] = temp[i];
        }
    }

    public static void main(String[] args) {
        int[] nums = {2, 5, 3, 1, 10, 4, 6, 9};
        sort(nums);
        System.out.println(Arrays.toString(nums));
    }

}

堆排序

package com.leetcode.sort;

import java.util.Arrays;

/**
 * @Auther: Jibny Zhan
 * @Date: 2019/11/30 20:36
 * @Description:
 */
public class HeapSort {
    private static int count;

    //    1.调整堆
    public static void heapify(int[] tree, int n, int i) {
        if (i >= n)
            return;
        count++;
        int right = (i << 1) + 1;
        int left = (i << 1) + 2;
        int max = i;
        if (left < n && tree[left] > tree[max]) {
            max = left;
        }
        if (right < n && tree[right] > tree[max]) {
            max = right;
        }
        if (max != i) {
            swap(tree, i, max);
            heapify(tree, n, max);
        }
    }

    //    2.构建堆,从后往前调整堆
    public static void buildHeap(int[] tree, int n) {
        int lastNode = n - 1;
        int parent = (lastNode - 1) >> 1;
        int i = parent;
        for (i = parent; i >= 0; i--) {
            heapify(tree, n, i);
        }
    }

    //    3.交换堆顶和末尾元素
    public static void heapSort(int[] tree, int n) {
        buildHeap(tree, n);
        int i;
        for (i = n - 1; i >= 0; i--) {
            swap(tree, i, 0);
            heapify(tree, i, 0);
        }
    }

    public static void swap(int[] tree, int A, int B) {
        tree[A] ^= tree[B];
        tree[B] ^= tree[A];
        tree[A] ^= tree[B];
    }


    public static void main(String[] args) {
        int[] tree = {2, 5, 3, 1, 10, 4};
        heapSort(tree, tree.length);
        System.out.println(Arrays.toString(tree));
        System.out.println("循环次数:" + count);
    }
}

桶排序

package com.leetcode.sort;

import java.util.Arrays;

/**
 * @Auther: Jibny Zhan
 * @Date: 2019/11/30 21:47
 * @Description:
 */
public class BucketSort {
    public static int[] bucketSort(int[] nums, int maxNum){
        int[] sorted = new int[maxNum+1];

        for(int i=0; i<nums.length; i++){
            sorted[nums[i]] = nums[i];//把数据放到对应索引的位置
        }
        return sorted;
    }

    public static void main(String[] args) {
        int[] x = { 99, 65, 24, 47, 50, 88,33, 66, 67, 31, 18 };
        int[] sorted = bucketSort(x, 99);
        System.out.println(Arrays.toString(sorted));
    }

}
posted @ 2020-03-16 00:23  Jibny  阅读(155)  评论(0编辑  收藏  举报