java中kuaisupaixu java中快速排序算法输出

目录

• 一、快速排序算法介绍
• 二、快速排序算法示意图
• 三、快速排序算法的应用实例需求
• 四、快速排序算法示例
• 五、测试快速排序算法所消耗的时间示例

一、快速排序算法介绍

• 快速排序（Quicksort）是对冒泡排序的一种改进。
• 通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列

二、快速排序算法示意图

三、快速排序算法的应用实例需求

对 [-9,78,0,23,-567,70] 进行从小到大的排序，要求使用快速排序法。并测试测试1000万条数据排序耗时。

四、快速排序算法示例

1、代码

package com.rf.springboot01.dataStructure.sort;

import java.util.Arrays;

/**
 * @description: 快速排序示例
 * @author: xiaozhi
 * @create: 2020-08-10 21:20
 */
public class QuickSort {
    public static void main(String[] args) {
        int[] arr = {-9,78,0,23,-567,70};
        quickSort(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));
    }
    /** 
    * @Description:  快速排序方法
    * @Param: [arr] 
    * @Author: xz  
    * @return: void
    * @Date: 2020/8/10 21:21  
    */ 
    public static void quickSort(int[] arr,int left ,int right){
        int l =left;//左下标
        int r=right;//右下标
        int middle=arr[(left+right)/2];//中轴值
        int temp=0;//定义一个临时变量
        //while循环目的：比middle小的值让左边，比middle大的值放右边
        while(l<r){
            //从中轴值middle左边开始查找，找到>=中轴值middle才退出
            while(arr[l]<middle){
                l+=1;
            }
            //从中轴值middle右边开始找，找到<=中轴值middle才推出
            while(arr[r]>middle){
                r-=1;
            }
            //如果左边下标(l) >= 右边下标(r),说明中轴值middle的左右俩边的值已经按照
            //左边全部都是 <= middle 的值，右边全部都是 >= middle的值
            if(l >= r){
                break;
            }
            //交换
            temp=arr[l];
            arr[l]=arr[r];
            arr[r]=temp;

            //如果交换完后，发现这个arr[l] == middle 相等 r--， 前移
            if(arr[l] == middle){
                r-=1;
            }
            //如果交换完后，发现这个arr[r] == middle 相等 l--， 前移
            if(arr[r] == middle){
                l+=1;
            }
        }

        // 如果 l == r, 必须l++, r--, 否则为出现栈溢出
        if(l == r){
            l+=1;
            r-=1;
        }
        //向左递归
        if(left <r){
            quickSort(arr,left,r);
        }
        //向右递归
        if(right>l){
            quickSort(arr,l,right);
        }

    }

}

2、运行main函数，运行结果如下：

五、测试快速排序算法所消耗的时间示例

1、代码

package com.rf.springboot01.dataStructure.sort;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;

/**
 * @description: 测试快速排序算法所消耗的时间示例
 * @author: xiaozhi
 * @create: 2020-08-10 22:04
 */
public class QuickSort2 {
    public static void main(String[] args) {
        int arr[] = new int[10000000];
        for(int i=0;i<10000000;i++){//创建一个带有一千万个随机数的数组
            arr[i]= (int) (Math.random()*8000000); //随机生成（0到8000000之间）的数
        }
        Date data1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String date1Str = simpleDateFormat.format(data1);
        System.out.println("排序前的时间是=" + date1Str);

        quickSort(arr,0,arr.length-1);

        Date data2 = new Date();
        String date2Str = simpleDateFormat.format(data2);
        System.out.println("排序后的时间是=" + date2Str);
    }
    /**
     * @Description:  快速排序方法
     * @Param: [arr]
     * @Author: xz
     * @return: void
     * @Date: 2020/8/10 21:21
     */
    public static void quickSort(int[] arr,int left ,int right){
        int l =left;//左下标
        int r=right;//右下标
        int middle=arr[(left+right)/2];//中轴值
        int temp=0;//定义一个临时变量
        //while循环目的：比middle小的值让左边，比middle大的值放右边
        while(l<r){
            //从中轴值middle左边开始查找，找到>=中轴值middle才退出
            while(arr[l]<middle){
                l+=1;
            }
            //从中轴值middle右边开始找，找到<=中轴值middle才推出
            while(arr[r]>middle){
                r-=1;
            }
            //如果左边下标(l) >= 右边下标(r),说明中轴值middle的左右俩边的值已经按照
            //左边全部都是 <= middle 的值，右边全部都是 >= middle的值
            if(l >= r){
                break;
            }
            //交换
            temp=arr[l];
            arr[l]=arr[r];
            arr[r]=temp;

            //如果交换完后，发现这个arr[l] == middle 相等 r--， 前移
            if(arr[l] == middle){
                r-=1;
            }
            //如果交换完后，发现这个arr[r] == middle 相等 l--， 前移
            if(arr[r] == middle){
                l+=1;
            }
        }

        // 如果 l == r, 必须l++, r--, 否则为出现栈溢出
        if(l == r){
            l+=1;
            r-=1;
        }
        //向左递归
        if(left <r){
            quickSort(arr,left,r);
        }
        //向右递归
        if(right>l){
            quickSort(arr,l,right);
        }

    }
}

2、运行main函数，运行结果如下：

本地计算机，win10系统，8G内存测试带有一千万个随机数的数组，用快速排序耗时大约2秒