选择，插入，快排，堆排的Java实现

最新推荐文章于 2020-09-27 10:40:30 发布

低头看天，抬头走路

最新推荐文章于 2020-09-27 10:40:30 发布

阅读量1.4k

点赞数

CC 4.0 BY-SA版权

分类专栏： # 排序文章标签：快速排序堆排序插入排序选择排序 Java

本文链接：https://blog.youkuaiyun.com/rusbme/article/details/52270576

排序专栏收录该内容

2 篇文章

订阅专栏

本文深入探讨了快速排序算法的不同基准选择方法及其对算法性能的影响。包括固定基准元、随机基准元和三数取中等策略，并介绍了如何通过这些方法提高排序效率。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

快速排序

选择基准元的方式：
对于分治算法，当每次划分时，算法若都能分成两个等长的子序列时，那么分治算法效率会达到最大。也就是说，基准的选择是很重要的。选择基准的方式决定了两个分割后两个子序列的长度，进而对整个算法的效率产生决定性影响。

最理想的方法是，选择的基准恰好能把待排序序列分成两个等长的子序列。

方法1 固定基准元
如果输入序列是随机的，处理时间是可以接受的。如果数组已经有序时，此时的分割就是一个非常不好的分割。因为每次划分只能使待排序序列减一，此时为最坏情况，快速排序沦为冒泡排序，时间复杂度为Θ(n^2)。而且，输入的数据是有序或部分有序的情况是相当常见的。因此，使用第一个元素作为基准元是非常糟糕的，应该立即放弃这种想法。
方法2 随机基准元
这是一种相对安全的策略。由于基准元的位置是随机的，那么产生的分割也不会总是会出现劣质的分割。在整个数组数字全相等时，仍然是最坏情况，时间复杂度是O(n^{2）。实际上，随机化快速排序得到理论最坏情况的可能性仅为1/(2}n）。所以随机化快速排序可以对于绝大多数输入数据达到O(nlogn）的期望时间复杂度。
方法3 三数取中
引入的原因：虽然随机选取基准时，减少出现不好分割的几率，但是还是最坏情况下还是O(n^2），要缓解这种情况，就引入了三数取中选取基准。

分析：最佳的划分是将待排序的序列分成等长的子序列，最佳的状态我们可以使用序列的中间的值，也就是第N/2个数。可是，这很难算出来，并且会明显减慢快速排序的速度。这样的中值的估计可以通过随机选取三个元素并用它们的中值作为基准元而得到。事实上，随机性并没有多大的帮助，因此一般的做法是使用左端、右端和中心位置上的三个元素的中值作为基准元。显然使用三数中值分割法消除了预排序输入的不好情形，并且减少快排大约5%的比较次数。

优化：当待排序序列的长度分割到一定大小后，使用插入排序。
原因：对于很小和部分有序的数组，快排不如插排好。当待排序序列的长度分割到一定大小后，继续分割的效率比插入排序要差，此时可以使用插排而不是快排

快排的通俗化理解：白话经典算法系列之六快速排序快速搞定

public class QuickSort {
    public static void main(String[] args) {
        int[] array = { 3,4,6,2,7,9,1,10,11};
        quickSort(array,0,array.length - 1);
        for (int x : array){
            System.out.println(x);
        }

    }

    private static void quickSort(int[] array,int start,int end) {
        if(array == null || array.length == 0){
            return;
        }
        if(start < end){
            int pivot = partition(array,start,end);
            quickSort(array,0,pivot - 1);
            quickSort(array,pivot + 1,end);
        }
    }

    private static int partition(int[] array, int low, int high) {
        int mid = (low + high)/2;
        if(array[low] < array[high]){
            swap(array,low,high);
        }
        if(array[mid] < array[high]){
            swap(array,mid,high);
        }
        if(array[low] < array[mid]){
            swap(array,low,mid);
        }
        int pivot = array[low];
        int i = low;
        int j = high;
        while(i != j) {
            while (array[j] >= pivot && j > i) {
                j--;
            }
            while (array[i] <= pivot && j > i) {
                i++;
            }
            if (i < j) {
                swap(array, i, j);
            }
        }
        swap(array, low, i);
        return i;
    }

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

import java.util.ArrayList;
import java.util.List;

public class QuickSort {
    public static void main(String[] args){
        List<Integer> list = new ArrayList<>();
        list.add(5);
        list.add(7);
        list.add(3);
        list.add(9);
        list.add(10);
        list.add(1);
        list.add(25);
        quickSort(list);
        for(Integer i : list){
            System.out.println(i);
        }
    }

    private static void quickSort(List<Integer> list) {
        if(list.size() > 1){
            List<Integer> smaller = new ArrayList<>();
            List<Integer> same = new ArrayList<>();
            List<Integer> larger = new ArrayList<>();
            int chooseItem = list.get(list.size()/2);
            for(Integer i : list){
                if(i < chooseItem){
                    smaller.add(i);
                }
                if(i == chooseItem){
                    same.add(i);
                }
                if(i > chooseItem){
                    larger.add(i);
                }
            }

//递归地对第一组和第三组进行排序，然后连接这三个组

            quickSort(smaller);
            quickSort(larger);            

            list.clear();
            list.addAll(smaller);
            list.addAll(same);
            list.addAll(larger);

        }
    }
}

堆排序

由于堆也是用数组模拟的，故堆化数组后，第一次将A[0]与A[n - 1]交换，再对A[0…n-2]重新恢复堆。第二次将A[0]与A[n – 2]交换，再对A[0…n - 3]重新恢复堆，重复这样的操作直到A[0]与A[1]交换。由于每次都是将最小的数据并入到后面的有序区间，故操作完成后整个数组就有序了。有点类似于直接选择排序。

public class HeapSort {
    public static void main(String[] args) {
        int[] array = { 3,4,6,2,7,9,1,10,11};
        heapSort(array);
        for (int x : array){
            System.out.println(x);
        }

    }

    private static void heapSort(int[] array) {
        if(array == null || array.length == 0){
            return;
        }
        buildMaxHeap(array);
        for(int i = array.length - 1; i > 0; i --){
            swap(array,0,i);
            maxHeap(array,i,0);
        }
    }

    private static void maxHeap(int[] array, int size, int index) {
        int left = index * 2 + 1;
        int right = index * 2 + 2;
        int largest = index;
        if(left < size && array[left] > array[index]){
            largest = left;
        }
        if(right < size && array[right] > array[largest]){
            largest = right;
        }
        if(largest != index){
            swap(array,index,largest);
            maxHeap(array,size,largest);
        }
    }

    private static void swap(int[] array, int i, int i1) {
        int temp = array[i];
        array[i] = array[i1];
        array[i1] = temp;
    }

    private static void buildMaxHeap(int[] array) {
        for(int i = array.length/2 - 1; i >= 0 ; i --){
            maxHeap(array,array.length,i);
        }
    }
}

插入排序

插入排序就是每一步都将一个待排数据按其大小插入到已经排序的数据中的适当位置，直到全部插入完毕。

public class InsertSort {
    public static void main(String[] args) {
        int[] array = { 3,4,6,2,7,9,1,10,11};
        insertSort(array);
        for (int x : array) {
            System.out.println(x);
        }
    }

    private static void insertSort(int[] array) {
        if(array == null || array.length == 0){
            return;
        }
        for(int i = 1; i < array.length; i++){
            for(int j = i; j > 0; j--){
                if(array[j] > array[j-1]){
                    swap(array,j,j-1);
                } else {
                    break;
                }
            }
        }
    }

    private static void swap(int[] array, int i, int i1) {
        int temp = array[i];
        array[i] = array[i1];
        array[i1] = temp;
    }

}

选择排序

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

public class ChooseSort {
    public static void main(String[] args) {
        int[] array = { 3,4,6,2,7,9,1,10,11};
        chooseSort(array);
        for (int x : array){
            System.out.println(x);
        }

    }

    private static void chooseSort(int[] array) {
        if(array == null || array.length == 0){
            return;
        }
        for(int i = 0; i < array.length; i++){
            int min = i;
            for(int j = i + 1; j <array.length; j++){
                if(array[j] < array[min]){
                    min = j;
                }
            }
            if(i != min){
                swap(array,i,min);
            }
        }
    }

    private static void swap(int[] array, int i, int min) {
        int temp = array[i];
        array[i] = array [min];
        array[min] = temp;
    }
}