Java中的快速排序算法

快速排序算法的核心思想：

以0索引的数字为基准数，确定基准数在数组中正确的位置。比基准数小的全部在左边，比基准数大的全部在右边，后面以此类推

6

1

2

7

9

3

4

5

10

8

针对于表格中的数据，用快速排序算法处理如下

 

代码分析：

定义数组，模拟快速排序算法

int[] arr = {6,1,2,7,9,3,4,5,10,8};

定义方法，实现快速排序的核心思想，通过递归的方式反复调用方法

public static void quicksort(int[] arr,int i,int j)

参数一： 我们要排序的数组    参数二： 要排序数组的起始索引    参数三： 要排序数组的结束索引

        //定义两个变量记录要查找的范围
        int start = i;
        int end = j;

        //递归出口
        if(start > end){
            return;
        }

        //记录基准数
        int baseNumber = arr[i];

利用循环找到要交换的数字，按之前图片中的方法进行搜索

        while (start != end){
            //利用end从后往前开始找，找比基准数小的数字
            while(true){
                if(end <= start || arr[end] < baseNumber ){
                    break;
                }
                end--;
            }
            //利用start从前往后找，找比基准数大的数字
            while(true){
                if(end <= start || arr[start] > baseNumber ){
                    break;
                }
                start++;
            }
            //把end和start指向的元素进行交换
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
        }

当start和end指向同一个元素的时候，循环结束，表示已经找到了基准数在数组中应存入的位置
此时，基准数归位：就是拿着这个范围的第一个数字，跟start指向的元素进行交换

        int temp = arr[i];
        arr[i] = arr[start];
        arr[start] = temp;

最后通过递归重复刚刚的过程

        //确定基准数左边的范围，重复一遍刚刚的过程
        quicksort(arr,i,start - 1);
        //确定基准数右边的范围，重复一遍刚刚的过程
        quicksort(arr,start + 1,j);

完整代码1：

public class fast1 {
    public static void main(String[] args) {
        
        int[] arr = {6,1,2,7,9,3,4,5,10,8};

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


    }

    /*
     *  参数一： 我们要排序的数组
     *  参数二： 要排序数组的起始索引
     *  参数三： 要排序数组的结束索引
     * */
    public static void quicksort(int[] arr,int i,int j){
        //定义两个变量记录要查找的范围
        int start = i;
        int end = j;

        //递归出口
        if(start > end){
            return;
        }

        //记录基准数
        int baseNumber = arr[i];

        //利用循环找到要交换的数字
        while (start != end){
            //利用end从后往前开始找，找比基准数小的数字
            while(true){
                if(end <= start || arr[end] < baseNumber ){
                    break;
                }
                end--;
            }
            //利用start从前往后找，找比基准数大的数字
            while(true){
                if(end <= start || arr[start] > baseNumber ){
                    break;
                }
                start++;
            }
            //把end和start指向的元素进行交换
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
        }

        //当start和end指向同一个元素的时候，循环结束
        //表示已经找到了基准数在数组中应存入的位置
        //基准数归位：就是拿着这个范围的第一个数字，跟start指向的元素进行交换
        int temp = arr[i];
        arr[i] = arr[start];
        arr[start] = temp;

        //确定基准数左边的范围，重复一遍刚刚的过程
        quicksort(arr,i,start - 1);
        //确定基准数右边的范围，重复一遍刚刚的过程
        quicksort(arr,start + 1,j);
    }
}

完整代码2(测试排序效率)：

public class fast2 {
    public static void main(String[] args) {

        int[] arr = new int[1000000];
        Random r = new Random();
        for (int i = 0; i < arr.length; i++) {
            arr[i] = r.nextInt();
        }

        long start = System.currentTimeMillis();
        quicksort(arr,0,arr.length - 1);
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }

    /*
     *  参数一： 我们要排序的数组
     *  参数二： 要排序数组的起始索引
     *  参数三： 要排序数组的结束索引
     * */
    public static void quicksort(int[] arr,int i,int j){
        //定义两个变量记录要查找的范围
        int start = i;
        int end = j;

        //递归出口
        if(start > end){
            return;
        }

        //记录基准数
        int baseNumber = arr[i];

        //利用循环找到要交换的数字
        while (start != end){
            //利用end从后往前开始找，找比基准数小的数字
            while(true){
                if(end <= start || arr[end] < baseNumber ){
                    break;
                }
                end--;
            }
            //利用start从前往后找，找比基准数大的数字
            while(true){
                if(end <= start || arr[start] > baseNumber ){
                    break;
                }
                start++;
            }
            //把end和start指向的元素进行交换
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
        }

        //当start和end指向同一个元素的时候，循环结束
        //表示已经找到了基准数在数组中应存入的位置
        //基准数归位：就是拿着这个范围的第一个数字，跟start指向的元素进行交换
        int temp = arr[i];
        arr[i] = arr[start];
        arr[start] = temp;

        //确定基准数左边的范围，重复一遍刚刚的过程
        quicksort(arr,i,start - 1);
        //确定基准数右边的范围，重复一遍刚刚的过程
        quicksort(arr,start + 1,j);
    }
}

运行结果：

//fast1:   1 2 3 4 5 6 7 8 9 10 


//速度特别快(一百万个数据)

//fast2:   125(单位：毫秒)

//fast2:   141(单位：毫秒)

//fast2:   119(单位：毫秒)

//fast2:   139(单位：毫秒)

//fast2:   125(单位：毫秒)