排序算法(四):快速排序

  • 快速排序由C. A. R.
    Hoare在1962年提出。
    它的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列

  • 时间复杂度: 最坏 O(N ^ 2)(如果数组是逆序的) 平均水平 O(NlogN)
  • 空间复杂度: O(N) 递归. 最坏情况下要递归 N层
    稳定性: 不稳定排序

  1. 以最左边为基准值

package com.company;

public class QuickSort {
    public static void main(String[] args) {
        int array[] = {1, 0, 6, 12, 7, 9, 3, 4, 5, 10, 8};
        quickSort(array, 0, array.length - 1);
        for (int i: array) {
            System.out.print(i + " ");
        }
    }

    /**
     * 快速排序,递归实现
     * 写代码要注意边界问题
     * @param array:数组最左下标,0
     * @param start:数组最右下标,length - 1
     * @param end
     */
    public static void quickSort(int array[], int start, int end){
        int pivot = array[start];// 关键值或基准值
        int left = start;
        int right = end;
        if(left >= right){
            return;
        }
        while(left != right){
            // 向左走,找比pivot小的数(必须right先走,因选的基准值为最左边的数)
            while(left < right && array[right] >= pivot){
                right--;
            }
            // 向右走,找到比pivot大的数
            while(left < right && array[left] <= pivot){
                left++;
            }
            // 没有相遇,但找到了,交换两数
            if(left < right){
                int tmp = array[left];
                array[left] = array[right];
                array[right] = tmp;
            }
        }
        // 退出while循环或没进去,表示left == right
        array[start] = array[left];
        array[left] = pivot;

        // 子问题,递归解决左边与右边
        quickSort(array, start, left -1);
        quickSort(array, left + 1, end);
    }
}

这里写图片描述


  1. 以最右作为基准值

package com.company;

public class QuickSortRight {
    public static void QuickSort(int num[], int start, int end){
        int pivot = num[end];   // 以最右边的数字为基准值
        int left = start;
        int right = end;

        if(left >= right){
            return;
        }

        while(left != right){
            //左边先走,找比pivot大的数(因为升序排序)
            while(left < right && num[left] <= pivot){
                left++;
            }
            //右边再走,找比pivot小的数
            while(left < right && num[right] >= pivot){
                right--;
            }
            // 此时,左右都找到了,但没有相遇,交换两数
            if(left < right){
                int tmp = num[left];
                num[left] = num[right];
                num[right] = tmp;
            }
        }

        // 不满足while循环时,left与right相遇,将基准值与相遇的数进行替换
        num[end] = num[left];
        num[left] = pivot;

        // 子问题分别处理相遇下标左右两边的数
        QuickSort(num, start, left - 1);
        QuickSort(num, left + 1, end);
    }

    public static void main(String[] args) {
        int arr[] = {6, 3, 2, 5, 1, 4, 0, 4, 5, 1};
        QuickSort(arr, 0,arr.length - 1);
        for (int i : arr) {
            System.out.print(i + " ");
        }
    }
}

这里写图片描述



阅读更多
上一篇反射四大核心类:Class、Constructor、Method、 Filed
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭