快速排序算法思想

快速排序算法
➢快速排序算法
1、分解:数组A[p..r]被划分为两个子数组A[p. .q-1]和A[q+1,r],使得A[q]为大小居中的数，左侧A[p...q-1]中的每个元素都小于等于它，而右侧A[q+1,r]中的每个元素都大于等于它。其中计算下标q也是划分过程的一部分。，
2、解决:通过递归调用快速排序，对子数组A[p..q-1]和A[q+1,r]进行排序
3、合并:因为子数组都是原址排序的，所以不需要合并，数组A[p..r]已经有序
➢那么,划分就是问题的关键

QuickSort(A,p,r)
    if p<r
        q=Partition(A,p,r)
        QuickSort(A,p,,q-1)
        QuickSort(A,q+1,,r)

快速排序（单向扫描）

package 分治法;
//单向扫描法

import java.util.Arrays;

public class 快速排序算法 {
    public static void main(String[] args) {
        int []arr=new int[]{5,3,2,4,6,7,10};
        System.out.println(Arrays.toString(arr));
        quickSort(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));
    }
    public static void quickSort(int[] A,int p,int r){
        if(p<r){
            int q=partion(A,p,r);
            quickSort(A,p,q-1);
            quickSort(A,q+1,r);
        }
    }

    private static int partion(int[] A, int p, int r) {
        int pivot=A[p];
        int sp=p+1;//扫描指针
        int bigger=r;//右侧指针
        while(sp<=bigger){
            if(A[sp]<=pivot){
                sp++;//扫描元素小于主元指针右移
            }else{
                swap(A,sp,bigger);
                bigger--;//扫描元素大于主元，二指针所指元素交换，右侧指针左移
            }
        }
        swap(A,p,bigger);
        return bigger;
    }

    private static void swap(int[] A, int sp, int bigger) {
        int temp=A[sp];
        A[sp]=A[bigger];
        A[bigger]=temp;
    }
}

快速排序（双向扫描法）

package 分治法;

import java.util.Arrays;

public class 快速排序双向扫描 {
    public static void main(String[] args) {
        int []arr=new int[]{5,3,2,4,6,7,10};
        System.out.println(Arrays.toString(arr));
        quickSort(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));
    }
    public static void quickSort(int[] A,int p,int r){
        if(p<r){
            int q=partion(A,p,r);
            quickSort(A,p,q-1);
            quickSort(A,q+1,r);
        }
    }

    private static int partion(int[] A, int p, int r) {
        int pivot=A[p];
        int left=p+1;
        int right=r;
        while(left<=right){
            while(left<=right&&A[left]<A[p]) left++;
            while(left<=right&&A[right]>A[p]) right--;
            if(left<right){
                swap(A,left,right);
            }
        }
        swap(A,p,right);
        return right;
    }

    private static void swap(int[] A, int left, int right) {
        int temp=A[left];
        A[left]=A[right];
        A[right]=temp;
    }

}

快速排序（三分法）