排序算法-交换排序之快速排序

和归并排序一样,快速排序也是一种分治的递归算法。
快速排序的思想是:选取一个枢纽元,将比枢纽元小的元素放枢纽元前面,把比枢纽元小的元素放后面,然后将前面的集合,后面的集合,重复之前的步骤。
枢纽元的选取是一门学问,我们要将枢纽元的尽量选取为集合中间值,使得枢纽元两边的元素量能更加均匀,避免大小不等的递归调用。我们将第一个元素,中值元素,最后一个元素作比较,取大小在三者中间的元素作为枢纽元。
在下面的代码中,我们对快速排序进行了优化,首先是枢纽元的选取,其次,对于小数组(N<=20),快速排序不如插入排序。所以我们在元素量小于20时,采用了插入排序。同时避免了当集合为一个或者两个元素时,选取枢纽元没有三个元素的情况,当然也给编程增加了方便。
代码:

package com.creat.sort;

import org.junit.Test;

/**
 * Created by whz on 2017/8/23.
 */
public class QuickSort {

    @Test
    public void testSort(){
        Integer[] array = new Integer[]{10,54,78,789,30,310,354,365,312,412,564,474,499,574,400,55,47,123,156,126,50,100,20,41,414,33,454,1000,40,70};
        sort(array);
        for(int i = 0; i < array.length; i++){
            System.out.print(array[i]+" ");
        }
        System.out.println();
    }

    public static <T extends Comparable<? super T>> void sort(T[] array){
        sort(array,0, array.length-1);
    }

    public static <T extends Comparable<? super T>> void insertSort(T[] array,int left, int right){
        int length = array.length;
        T temp = null;
        for(int i = 1+left; i <= right; i++){
            for(int n = i-1; n >= left; n--){
                if(array[n].compareTo(array[n+1]) > 0){
                    temp = array[n];
                    array[n] = array[n+1];
                    array[n+1] = temp;
                }else {
                    break;
                }
            }
        }
    }

    private static <T extends Comparable<? super T>> void sort(T[] array,int left, int right){
        if(right - left +1 > 20){
            T pivot = getPivot(array, left, right);
            int l = left;
            int r = right - 2;
            while(l < r){
                while(array[l].compareTo(pivot) < 0){
                    l++;
                }
                while(array[r].compareTo(pivot) > 0 ){
                    r--;
                }
                if(l < r){
                    swap(array, l, r);
                }else {
                    break;
                }
            }
            swap(array, l, right - 1);
            sort(array, left, l-1);
            sort(array, l+1, right);
        }else {
            insertSort(array, left, right);
        }
    }

    private static <T extends Comparable<? super T>> T getPivot(T[] array,int left, int right){
        int middle = (left + right)/2;
        if(array[left].compareTo(array[middle]) > 0){
            swap(array, left, middle);
        }
        if(array[left].compareTo(array[right]) > 0 ){
            swap(array, left, right);
        }
        if(array[middle].compareTo(array[right]) > 0){
            swap(array, middle, right);
        }
        swap(array, middle, right-1);
        return array[right-1];
    }

    private static <T extends Comparable<? super T>> void swap(T[] array,int one, int anthor){
        T temp = array[one];
        array[one] = array[anthor];
        array[anthor] = temp;
    }
}

快速排序的时间复杂度最好和平均为O(Nlog2N),最坏为O(N^2)。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值