排序算法-快排

1、快速排序

①首先随机选出一个数组中的数，当做参考值

②分成三个区域，比参考值小的区域，等于参考值的区域，比参考值大的区域

③进行快排

④quickSort过程和partition过程

public class QuickSort {
    public static void quickSort(int[] arr){
//        if(arr == null || arr.length<2){
//            return;
//        }
//        quickSort(arr,0,arr.length-1);
        //1、判断是否是个长度大于2或者为空的数组,如果是的话，不用进行排序
        if(arr.length<2 || arr == null){
            return;
        }
        quickSort(arr,0,arr.length-1);
    }
    //arr[]排好序
    public static void quickSort(int[] arr,int L,int R){
//        if(L<R){
//            swap(arr,L+(int)(Math.random()*(R - L + 1)),R);
//            int[] p = partition(arr,L,R);
//            quickSort(arr,L,p[0]-1);
//            quickSort(arr,p[1]+1,R);
//        }
        //2、进行排序，快排
        if(L<R){//判断条件，如果左边的数小于右边的，进行快排
            //将随机选一个数，作为快排的参考值,放到数组的最后一个位置
            swap(arr,L+(int)(Math.random()*(R-L+1)),R);
            //快排的分区，定义一个数组，存两个值，一个是比参考值小的区域的右边界大1的L，一个是比参考值大的左边界小1的R
            //依靠一个方法返回这两个边界
            int p[] = partition(arr,L,R);
            //快排递归
            quickSort(arr,L,p[0]-1);
            quickSort(arr,p[1]+1,R);
        }

    }
    //这是一个处理arr的函数
    //默认以arr[r]做划分，arr[r]->p <p    ==p     >p
    //返回等于区域（左边界，右边界），所以返回一个长度为2的数组res，res[0] res[1]
    public static int[] partition(int[] arr,int L,int R){
//        int less = L-1;
//        int more = R;
//        while(L < more){
//            if(arr[L] < arr[R]){
//                swap(arr,++less,L++);
//            }else if(arr[L] > arr[R]){
//                swap(arr,--more,L);
//            }else{
//                L++;
//            }
//        }
//        swap(arr,more,R);
//        return new int[]{less+1,more};
        //定义一个变量，是指小于参考值的左边界，和大于参考值的右边界
        int less = L-1;
        int more = R;
        while(L<more){
            if(arr[L]<arr[R]){
                swap(arr,++less,L);
            }else if(arr[L]>arr[R]){
                swap(arr,--more,L);
            }else{
                L++;
            }
        }
        //将最后一个存放的参考值与大于参考值的区域的左边界交换
        swap(arr,more++,R);
        //将最后得到的排序完的参考值的区域的左右边界返回
        return new int[]{less+1,more-1};
    }

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

    public static void main(String[] args){
        int[] arr = new int[]{12,4,6,8,3,8,56};
        QuickSort.quickSort(arr);
        for(int j=0;j<arr.length;j++){
            System.out.println(arr[j]);
        }
    }
}

2、快速排序第一次练习

package com.joy.sort.quicksort;

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

/**
 * @author joy
 * @Package arithmetic
 * @Description: 快速排序
 * @date 2022/3/15 9:13
 */
public class QuickSort {
    //调用快速排序的总方法
    public static void quickSort(int arr[]){
        quickSort(arr,0,arr.length-1);
    }

    private static void quickSort(int[] arr, int L, int R) {
        if(arr == null || arr.length<2){
            return;
        }
        if(L < R){
            //随机调选出一个数，作为参照值，放在数组最后的位置
            int random = L+(int)(Math.random()*(R-L+1));
            swap(arr,random,R);
            //进行排序
            List<Integer> list = partition(arr, L, R);
            quickSort(arr,0,list.get(0));
            quickSort(arr,list.get(1),R);
        }
    }

    //排序的partition过程
    private static List<Integer> partition(int[] arr, int L, int R) {
        int less = L-1;
        int more = R;

        while(L<more){
            if(arr[L]<arr[R]){
                swap(arr,L,++less);
                L++;
            }else if(arr[L]>arr[R]){
                swap(arr,L,--more);
            }else{
                L++;
            }
        }
        swap(arr,R,more);
        ArrayList<Integer> list = new ArrayList<>();
        list.add(less);//作为下一次排序的左边区域的R
        list.add(more+1);//作为下一次排序的右边区域的L
        return list;
    }

    //交换数组中两个数位置的方法
    private static void swap(int[] arr, int random, int R) {
//        arr[random] = arr[random]^arr[R];
//        arr[R] = arr[random]^arr[R];
//        arr[random] = arr[random]^arr[R];
        int temp = arr[random];
        arr[random] = arr[R];
        arr[R] = temp;
    }

    public static void main(String[] args) {
        int arr[] = new int[]{8,2,6,4,3};
        quickSort(arr);
        for(int i : arr){
            System.out.println(i);
        }
    }
}