快速排序 java与python实现

最新推荐文章于 2020-08-25 11:08:51 发布

原创最新推荐文章于 2020-08-25 11:08:51 发布 · 233 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#排序算法 #程序员面试

算法同时被 2 个专栏收录

11 篇文章

订阅专栏

python

2 篇文章

订阅专栏

本文深入探讨了快速排序算法，一种高效的排序方法，通过分治策略实现原地排序，避免了额外空间的使用。提供了Java和Python两种语言的实现代码，演示了如何通过随机选择主元进行排序，最终达到O(nlogn)的时间复杂度。

快速排序QuickSort

快速排序由于排序效率在同为 O(nlogn) 的几种排序方法中效率最高，因此经常被采用。

快速排序思想与归并一样采用分治思想，相比于归并排序，快速排序属于原址排序，不需要创建额外的数组协助。

Java实现，随机选择主元

import java.util.Arrays;
import java.util.Random;
 
/**
 * 分治思想
 * 随机选择主元
 * 时间复杂度theta(nlogn)
 * @author Shine
 */
public class QuickSort {
 
    public static void quickSort(double[] arr, int from, int to) {
        if (from < to) {
            int q = randomPartition(arr, from, to);
            quickSort(arr, from, q - 1);
            quickSort(arr, q + 1, to);
        }
 
    }
 
    private static int randomPartition(double[] arr, int f, int t) {
        // 随机选择主元，替换到数组尾部
        Random ran = new Random();
        int i = ran.nextInt(t - f) + f;
        swap(arr, i, f);
        return partition(arr, f, t);
    }
 
    private static void swap(double[] arr, int i, int j) {
        if (i < arr.length && j < arr.length) {
            double temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
 
    }
 
    private static int partition(double[] arr, int f, int t) {
        // 
        double tail = arr[t];
        int i = f - 1;
        for (int j = f; j <= t - 1; j++) {
            if (arr[j] <= tail) {
                i += 1;
                swap(arr, i, j);
            }
        }
        swap(arr, i + 1, t);
        return i + 1;
    }
 
    public static void main(String[] args) {
 
        double[] arr = new double[]{1.5, 0.7, 3.4, -1.6, 2.3, -0.4, 0};
         System.out.println("Before sort:" +Arrays.toString(arr));
        quickSort(arr, 0, arr.length - 1);
        System.out.println("After sort:" +Arrays.toString(arr));
    }
}

输出结果：

run:
Before sort:[1.5, 0.7, 3.4, -1.6, 2.3, -0.4, 0.0]
After sort:[-1.6, -0.4, 0.0, 0.7, 1.5, 2.3, 3.4]
成功构建 (总时间: 0 秒)

Python3实现

def quicksort(seq, lo, hi):
    """快速排序 Theta(N^2)"""
    """选择一个元素作为主元，把原始序列按照不大于主元的和大于主元的分成两部分递归"""
 
    if lo < hi:
        tag = quickpartition(seq, lo, hi)
        quicksort(seq, lo, tag-1)
        quicksort(seq, tag + 1, hi)
    return seq[lo:hi]
 
 
def quickpartition(seq1, lo1, hi1):
    x = seq1[hi1]
    i = lo1 - 1
    for j in range(lo1, hi1):
        if seq1[j] <= x:
            i = i + 1
            temp = seq1[i]
            seq1[i] = seq1[j]
            seq1[j] = temp
    temp1 = x
    seq1[i + 1] = temp1
    seq1[hi1] = seq1[i + 1]
    return i + 1
 
 
if __name__ == '__main__':
    test1 = [15, 5.4, 6, -9.23, 4, 0, -5, -8, -2.96]
    print("seq")
    print(test1)
    print("Quicksorted seq")
    quicksort(test1, 0, len(test1) - 1)
    print(test1)

seq
[15, 5.4, 6, -9.23, 4, 0, -5, -8, -2.96]

Quicksorted seq
[-9.23, -8, -5, -2.96, 0, 4, 5.4, 6, 15]