Java快速排序

Posted 2022-04-26 木木林Violet

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java快速排序相关的知识，希望对你有一定的参考价值。

排序流程图

排序思想

1.先对整个数组进行分区。
2.在分区时便可以对数组进行一定程度的排序。
3.从待排序的区间中选择一个数，作为目前整个区间的基准值。
4.遍历整个待排序区间，将比基准值小的（可以包括相等的）放在基准值的左边，将比基准值打的（也可以包括相等的）放到基准值的右边。
5.采用分治的思想，对左右的两个小区间也使用同样的方式处理，直到小区间的长度为1，代表已经有序，或者小区间的长度为0，代表没有数据。
6.重复上述的流程，直到整个数组排序完成。

排序代码

public static void quickSort(int[] arr)
	//对数组进行快速排序，区间为闭区间
    quickSortInternal(arr, 0, arr.length - 1);


//对数组分区
private static void quickSortInternal(int[] arr, int l, int r) 
	//将当前的数组进行快速排序
    int p = partition(arr, l, r);
    //对左区间进行快速排序
    quickSortInternal(arr, l, p);
    //对右区间进行快速排序
    quickSortInternal(arr, p + 1, r);


//对分好区的子数组进行快速排序
private static int partition(int[] arr, int l, int r) 
	//用v来记录基准值
    int v = arr[l];
    //j为小于基准值的区间
    int j = l;
    for (int i = l + 1; i <= r; i++) 
    	//若小于基准值，则将数字移动到小于的区间中
        if (arr[i] < v)
            swap(arr, i, ++j);
        
    
    //将基准值交换到相应的位置
    swap(arr, l, j);
    return j;


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

代码改进1——防止栈溢出和加入随机数

代码改进思想

1.上述的代码在较少的数据处理时，一般不会有什么问题，但当遇到很多的数据时，就可能会出现栈溢出的问题。于是可以在处理较少的数据时，直接使用插入排序（插入排序在近乎有序时，效率很高），减少对函数的调用。
2.在进行快速排序选择基准值时，可以使用随机数，使得排序会更加有效。

改进代码

public static void quickSort(int[] arr)
    quickSortInternal(arr, 0, arr.length - 1);


//对数组分区
private static void quickSortInternal(int[] arr, int l, int r) 
	//在较少的数据时，使用插入排序，
    if (r - l <= 15)
        insertSort(arr, l, r);
        return;
    
    int p = partition(arr, l, r);
    quickSortInternal(arr, l, p);
    quickSortInternal(arr, p + 1, r);


//对分好区的子数组进行快速排序
private static int partition(int[] arr, int l, int r) 
	//加入随机数，使得此次的排序会更加有效
    int randomIndex = random.nextInt(l, r);
    swap(arr, l, randomIndex);
    int v = arr[l];
    int j = l;
    for (int i = l + 1; i <= r; i++) 
        if (arr[i] < v)
            swap(arr, i, ++j);
        
    
    swap(arr, l, j);
    return j;


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


public static void insertSort(int[] arr,int l,int r)
    for (int i = l + 1; i <= r; i++) 
        for (int j = i; j > l && arr[j] < arr[j - 1]; j--)
            swap(arr, j - 1, j);

代码改进2——二路快排

代码改进流程图

代码改进思想

之前的代码都是一次遍历只能选择一个数放入到对应的区间，于是我们便可以想到是否可以一次遍历，选出两个数来放入到对应的区间，以提高遍历的效率
1.使用左右两个指针，分别指向待排序数据的起始和结尾的位置，左指针向右遍历，右指针向左遍历。
2.当左指针找到一个大于基准值的数，且右指针找到第一个小于基准值的数时，两数据进行交换。
3.重复上述的流程，直到两指针相遇，则遍历结束。
4.将基准值交换到相应的位置。

改进代码

public static void quickSort2(int[] arr)
    quickSortInternal2(arr, 0, arr.length - 1);


private static void quickSortInternal2(int[] arr, int l, int r) 
    if (l - r <= 15)
        insertSort(arr, l, r);
        return;
    
    int p = partition2(arr, l, r);
    quickSortInternal2(arr, l, p);
    quickSortInternal2(arr, p + 1, r);


private static int partition2(int[] arr, int l, int r) 
    int randomIndex = random.nextInt(l, r);
    swap(arr, l, randomIndex);
    int v = arr[l];
    //左指针
    int m = l;
    //右指针
    int n = r;
    while (m < n)
    	//左指针一直遍历，直到找到一个大于基准值的数
        while (m < n && arr[m + 1] < v)
            ++m;
        
        //右指针一直遍历，直到找到一个小于基准值的数
        while (m < n && arr[n - 1] > v)
            --n;
        
        //交换左右指针所指向的数
        swap(arr, m, n);
        ++m;
        --n;
    
    swap(arr, l, m);
    return m;


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


public static void insertSort(int[] arr,int l,int r)
    for (int i = l + 1; i <= r; i++) 
        for (int j = i; j > l && arr[j] < arr[j - 1]; j--)
            swap(arr, j - 1, j);