数据结构与算法之快速排序

数据结构与算法之快速排序

---

目录

1. 快速排序介绍
2. 代码实现

---

1. 快速排序介绍

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

2. 快速排序：
   

3. 快速排序法示意图

---

2. 代码实现

代码一：随机快排，长期期望的 O(nlogn)

package sort;

import java.util.Arrays;

public class QuickSort {

    public static void quickSort(int[] arr) {
        if (arr==null||arr.length<2)
            return;
        quickSort(arr,0,arr.length-1);
    }

    public static void quickSort(int[] arr,int l,int r) {
        if (l<r){
            swap(arr,(int)(l+Math.random()*(r-l+1)),r);
            int[] p = partition(arr,l,r);
            quickSort(arr,l,p[0]-1);
            quickSort(arr,p[1]+1,r);
        }
    }

    private static int[] partition(int[] arr, int l, int r) {
        int less = l-1;
        int more = r;
        while (l<more){
            if (arr[l]<arr[r])
                swap(arr,++less,l++);
            else if (arr[l]>arr[r])
                swap(arr,--more,l);
            else 
                l++;
        }
        swap(arr,more,r);
        return new int[]{less+1,more};
    }

    private static void swap(int[] arr, int i, int r) {
        int tem = arr[i];
        arr[i] = arr[r];
        arr[r] = tem;
    }
    
    public static void main(String[] args) {
        int[] arr = {5, 3, 1, 2, 6, 4, 4};
        quickSort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

代码二：普通快排

package com.sort;

import java.util.Arrays;

public class QuickSort {
    public static void main(String[] args) {
        int[] arr = {2,10,8,22,34,5,12,28,21,11};
        quickSort(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));
    }

    public static void quickSort(int[] arr, int left, int right){
        int l = left;
        int r = right;

        //pivot 中轴
        int pivot = arr[(left+right)/2];
        int temp = 0;
        //while循环的目的是让比pivot值小放到左边
        //比pivot值大放右边
        while (l<r){
//          在pivot的左边一直找，找到大于等于pivot值，才退出
            while (arr[l]<pivot){
                l +=1;
            }
//            在pivot的右边一直找，找到小于等于pivot值，才退出
            while (arr[r]>pivot){
                r-=1;
            }
            //如果 l>=r ，说明pivot的左右边的值，已经按照左边全部是小于等于pivot值
            //右边全部是大于等于pivot值
            if (l>=r){
                break;
            }

            //交换
            temp = arr[l];
            arr[l] = arr[r];
            arr[r] = temp;

            //如果交换完后，发现pivot，发现arr[l] == pivot值相等 r--， 前移
            if (arr[l] == pivot){
                r-=1;
            }
            //如果交换完后，发现pivot，发现arr[r] == pivot值相等 l++， 后移
            if (arr[r] == pivot){
                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);
        }
    }
}

编译结果：

800万条数据大概2s能排好。