快速排序算法介绍

1.算法的实现原理

首先选择一个元素作为基准值mid，一般选择数组的第一个数。将左指针指向左边界，右指针指向右边界，左指针向右边走，右指针向左边走，左指针寻找比mid值小的数组元素，右指针用于寻找比mid大的数组元素。两个指针都找到相应的元素后进行交换。继续移动指针寻找相应元素然后交换，直到两个指针相遇，将指针相遇的那个数组元素与mid元素交换。再迭代法对两部分进行排序。时间复杂度为nlogn

2.代码的具体实现

2.1算法的场景代码

 public static void main(String[] args) {
        int[] a = {5, 3, 7, 2, 9, 8, 1, 4};
        fast(a, 0, a.length - 1);
        System.out.println(Arrays.toString(a));
    }

2.2迭代部分代码实现 

这部分代码通过partition函数将数组划分为左分区和右分区，即比mid小和大的两部分，并获取mid的索引号，再通过fast函数迭代对左右分区排序

public static void fast(int[] a, int l, int r) {
        if (l >= r) {
            return ;
        }
        //确定分区索引号
        int p = partition1(a, l, r);
        //左边分区排序
        fast(a, l, p - 1);
        //右分区排序
        fast(a, p + 1, r);
 
    }

2.3分区代码实现

这部分的作用主要是将数组进行排序，将第一个元素设置为mid值，左右指针寻找比mid小和大的元素，找到后进行交换并继续寻找，直到左右指针相遇后停止寻找并将mid与相遇指针元素交换

public static int partition1(int[] a, int l, int r) {
        //选择基准点
        int mid = a[l];
        //定义左右指针
        int i = l;
        int j = r;
        //右指针一定要比左指针大
        while (j > i) {
            //左指针寻找比mid大的值，右指针寻找比mid小的值
            //一定要右指针先找否则容易出错
            while (j > i && a[j] > mid) {
                j--;
            }
            while (j > i && a[i] < mid) {
                i++;
            }
            exchange(a, i, j);
        }
        //一轮结束后mid与循环中左右指针相遇的元素进行交换
        //l代表mid值的索引号
        exchange(a, l, j);
        //将新的分区索引号返回
        return j;
    }

2.4交换函数的实现

 public static void exchange(int[] a, int l, int r) {
        int temp = 0;
        if(a[l]>a[r]){
            temp = a[l];
            a[l] = a[r];
            a[r] = temp;
        }
    }

3.完整代码

 
 
import java.util.Arrays;
import java.util.Scanner;
 
public class t2 {
    public static void main(String[] args) {
        int[] a = {5, 3, 7, 2, 9, 8, 1, 4};
        fast(a, 0, a.length - 1);
        System.out.println(Arrays.toString(a));
    }
 
    public static void fast(int[] a, int l, int r) {
        if (l >= r) {
            return ;
        }
        //确定分区索引号
        int p = partition1(a, l, r);
        //左边分区排序
        fast(a, l, p - 1);
        //右分区排序
        fast(a, p + 1, r);
 
    }
 
    public static int partition1(int[] a, int l, int r) {
        //选择基准点
        int mid = a[l];
        //定义左右指针
        int i = l;
        int j = r;
        //右指针一定要比左指针大
        while (j > i) {
            //左指针寻找比mid大的值，右指针寻找比mid小的值
            //一定要右指针先找否则容易出错
            while (j > i && a[j] > mid) {
                j--;
            }
            while (j > i && a[i] < mid) {
                i++;
            }
            exchange(a, i, j);
        }
        //一轮结束后mid与循环中左右指针相遇的元素进行交换
        //l代表mid值的索引号
        exchange(a, l, j);
        //将新的分区索引号返回
        return j;
    }
 
    public static void exchange(int[] a, int l, int r) {
        int temp = 0;
        if(a[l]>a[r]){
            temp = a[l];
            a[l] = a[r];
            a[r] = temp;
        }
    }
}