揭秘快速排序的算法奥秘：不同语言的实现探究

后端

2023-09-14 13:27:38

快速排序算法：一种高效的“分而治之”排序技术

在算法的世界中，快速排序算法以其卓越的性能和广泛的适用性而闻名。它是一种快速而高效的算法，适用于各种数据规模和类型。本文将深入探讨快速排序算法的原理，并通过不同的语言实现，展示其在实际应用中的强大魅力。

快速排序算法：原理揭秘

快速排序采用“分而治之”的策略，就像一位足智多谋的将军，将待排序的军队（数组）巧妙地分而治之。它遵循以下步骤：

选择基准值： 首先，算法会从待排序数组中选取一个元素作为基准值。这个基准值就像一面旗帜，将数组划分成两部分。
分区： 接下来，算法会遍历数组，将比基准值小的元素移动到基准值的左边，比基准值大的元素移动到基准值的右边。想象一下，军队在基准值这面旗帜的指引下，整齐有序地排队。
递归调用： 分区完成后，算法会分别对基准值左右两边的两个子数组递归地应用同样的策略，直至每个子数组只剩下一个或零个元素。就像分而治之的将军，算法不断地将问题分解成更小的子问题，最终征服整个数组。

不同语言中的快速排序实现

快速排序算法的魅力在于它的通用性，它可以在各种编程语言中实现。以下是不同语言中的示例：

Java：

public class QuickSort {
    public static void sort(int[] arr, int low, int high) {
        if (low < high) {
            int partitionIndex = partition(arr, low, high);
            sort(arr, low, partitionIndex - 1);
            sort(arr, partitionIndex + 1, high);
        }
    }

    private static int partition(int[] arr, int low, int high) {
        int pivot = arr[high];
        int i = (low - 1);
        for (int j = low; j < high; j++) {
            if (arr[j] < pivot) {
                i++;
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        int temp = arr[i + 1];
        arr[i + 1] = arr[high];
        arr[high] = temp;
        return (i + 1);
    }
}

Go：

func QuickSort(arr []int) {
    if len(arr) <= 1 {
        return
    }
    pivot := arr[len(arr)-1]
    var left, right []int
    for i := 0; i < len(arr)-1; i++ {
        if arr[i] < pivot {
            left = append(left, arr[i])
        } else {
            right = append(right, arr[i])
        }
    }
    QuickSort(left)
    QuickSort(right)
    copy(arr, append(left, pivot, right...))
}

Python：

def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[-1]
    left = [x for x in arr if x < pivot]
    right = [x for x in arr if x >= pivot]
    return quick_sort(left) + [pivot] + quick_sort(right)

JS：

const quickSort = (arr) => {
  if (arr.length <= 1) {
    return arr;
  }
  const pivot = arr[arr.length - 1];
  const left = [];
  const right = [];
  for (let i = 0; i < arr.length - 1; i++) {
    if (arr[i] < pivot) {
      left.push(arr[i]);
    } else {
      right.push(arr[i]);
    }
  }
  return [...quickSort(left), pivot, ...quickSort(right)];
};

C：

void quick_sort(int arr[], int low, int high) {
    if (low < high) {
        int partition_index = partition(arr, low, high);
        quick_sort(arr, low, partition_index - 1);
        quick_sort(arr, partition_index + 1, high);
    }
}

int partition(int arr[], int low, int high) {
    int pivot = arr[high];
    int i = (low - 1);
    for (int j = low; j < high; j++) {
        if (arr[j] < pivot) {
            i++;
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }
    int temp = arr[i + 1];
    arr[i + 1] = arr[high];
    arr[high] = temp;
    return (i + 1);
}