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

﹏ヽ暗。殇╰゛Y 2022-10-02 14:51 175阅读 0赞

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

--------------------

## 目录 ##

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

--------------------

### 1. 快速排序介绍 ###

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkxMDY5NA_size_16_color_FFFFFF_t_70 1]

--------------------

### 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);
            }
        }
    }

编译结果：  
![在这里插入图片描述][20190621213615669.png]

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

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkxMDY5NA_size_16_color_FFFFFF_t_70]: /images/20220109/f08dd70a8f2e40a690ff703ec6c4120e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkxMDY5NA_size_16_color_FFFFFF_t_70 1]: /images/20220109/c798501029c7415483b7a365c8d27aa9.png
[20190621213615669.png]: /images/20220109/951f013745484b088dae13b72be1470e.png