快速排序

快速排序

快速排序之所比较快，因为相比冒泡排序，每次交换是跳跃式的。每次排序的时候设置一个基准点，将小于等于基准点的数全部放到基准点的左边，将大于等于基准点的数全部放到基准点的右边。这样在每次交换的时候就不会像冒泡排序一样每次只能在相邻的数之间进行交换，交换的距离就大的多了。因此总的比较和交换次数就少了，速度自然就提高了。当然在最坏的情况下，仍可能是相邻的两个数进行了交换。因此快速排序的最差时间复杂度和冒泡排序是一样的都是O(N2)，它的平均时间复杂度为O(NlogN)。快速排序是基于一种叫做“二分”的思想。

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


/**
 * 快速排序
 * @Auther: ok168
 * @Description:
 */
public class FastSort {
    private static final Logger logger = LoggerFactory.getLogger(FastSort.class);

    public static void main(String[] args) {
        int[] arr1 = {3,10,6,8,4,7,5,6,7,3,4,2,1,10,9,8};
        long start1 = System.currentTimeMillis();
        quickSort(arr1, 0, arr1.length-1);
        long end1 = System.currentTimeMillis();
        System.out.println("quickSort time = " + (end1-start1));

        for (int i = 0; i < arr1.length; i++) {
            System.out.print(arr1[i] + " ");
        }
        
    }


    public static void quickSort(int[] arr, int low , int high){
        if(low >= high){
            return;
        }

        // 取一个作为中位值, 此处取arr首个
        int middle = arr[low];

        int i=low;  //低位
        int j=high; //高位
        int temp;   //用于高低交换

        int m;      //记录排序一次后的中位坐标

        while(i < j){
            while(arr[i] <= middle && i < j){ //从左往右->找到比中位值大的数坐标i
               i++;
            }

            while(middle < arr[j] && i < j){  //从右往左->找到比中位值小的数坐标j
               j--;
            }

            if(i < j){              // 交换i,j坐标的值
                temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }

        if(arr[i] < middle){   // 如果排序后 arr[i] < middle ,则交换i位置
            //logger.debug("arr[i] < middle ->" + arr[i] + " & " + middle);
            temp = arr[i];
            arr[i] = arr[low];
            arr[low] = temp;

            m = i;
        }else{                 // 如果排序后 arr[i] >= middle ,则交换i-1的位置
            //logger.debug("arr[i] >= middle ->" + arr[i] + " & " + middle);
            temp = arr[i-1];
            arr[i-1] = arr[low];
            arr[low] = temp;

            m = i-1;
        }

        quickSort(arr,low,m-1);
        quickSort(arr,m+1,high);
    }

}

看了别人写的之后,学习了一版,画图才看明白

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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

/**
 * 快速排序
 * @Auther: ok168
 * @Description:
 */
public class FastSort {
    private static final Logger logger = LoggerFactory.getLogger(FastSort.class);

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < 1000000; i++) {
            list.add(new Random().nextInt(1000000));
        }

        Integer[] arr = {7,10,6,4,8,0};
        //Integer[]  arr = list.toArray(new Integer[list.size()]);

        long start = System.currentTimeMillis();
        quickSort(arr, 0, arr.length-1);

        long end = System.currentTimeMillis();
        System.out.println("quickSort time = " + (end-start));

        //print(arr);
    }

    public static void quickSort(Integer[] arr, int low , int high){
        if(low >= high){
            return;
        }
        int middle = partition(arr, low , high);

        quickSort(arr,low,middle-1);
        quickSort(arr,middle+1,high);
    }

    public static int partition(Integer[] arr, int low , int high){
        //优化(三数取中)
        int mid = low + (high-low)/2;
        
        // 7,10,3,4,8,6
        swap(arr,low,mid,high);
        // 6,10,3,4,8,7

        // 取一个作为中位值
        int middle = arr[low];

        while(low < high){
            while(middle <= arr[high] && low < high){  //从右往左->找到比中位值小的数坐标
                high--;
            }
            arr[low] = arr[high];

            while(arr[low] <= middle && low < high){ //从左往右->找到比中位值大的数坐标
                low++;
            }
            arr[high] = arr[low];
        }
        arr[high] = middle;

        return high;
    }
    
    /*备注过程:
    6,10,3,4,8,7 ->  高位坐标3小于中位值6,赋值覆盖低位坐标0 (low=0,high=3)
    4,10,3,4,8,7 ->  低位坐标1大于中位值6,赋值覆盖高位坐标3 (low=1,high=3)
    4,10,3,10,8,7->  高位坐标2小于中位值6,赋值覆盖低位坐标1 (low=1,high=2)
    4,3,3,10,8,7 ->  高位低位达到相同,赋值坐标2位置的值为中位6  (low=2,high=2)
    4,3,6,10,8,7 
    
    4,3(左) 与 10,8,7(右)
    4,3 ->
    3,3 ->
    3,4
    
    10,8,7 ->
    7,8,7  ->
    7,8,10
      
    -> 3,4, 6 , 7,8,10
    */

    public static void swap(Integer[] arr, int a1,int a2,int a3){
        int t;
        if( (arr[a1]-arr[a2])*(arr[a2]-arr[a3])>0 ) {
            // middle = a2
            t = arr[a1];
            arr[a1] = arr[a2];
            arr[a2] = t;
        }else if( (arr[a2]-arr[a1])*(arr[a1]-arr[a3])>0 ){
            // middle = a1
        }else {
            // middle = a3
            t = arr[a1];
            arr[a1] = arr[a3];
            arr[a3] = t;
        }
    }

    public static void print(Integer[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }
    
}