精通数组排序：LeetCode 912 征服升序排列的奥秘

2023-11-03 16:08:39

数组排序的意义

在计算机科学的世界中，数组可谓无处不在。从存储用户数据到处理科学计算，数组的身影随处可见。然而，当数组中的元素杂乱无章时，就会对我们的程序带来诸多不便。试想一下，如果一个电商网站上的商品列表没有经过排序，那么用户在寻找心仪商品时将会遇到多么大的困难。

数组排序，顾名思义，就是将数组中的元素按照一定的规则进行排列，使之呈现出有序的状态。这不仅可以提高数据的查找效率，还可以简化算法的实现。因此，掌握数组排序算法对于程序员来说至关重要。

排序算法漫谈

排序算法的种类繁多，各有千秋。每种算法都有其独特的特点和适用场景。在本文中，我们将重点介绍三种经典的排序算法：冒泡排序、快速排序和归并排序。

冒泡排序

冒泡排序是一种最简单、最直观的排序算法。它的基本思想是：将相邻的两个元素进行比较，如果前一个元素大于后一个元素，则交换这两个元素的位置。这样反复比较和交换，直到数组中的所有元素都按顺序排列好为止。

冒泡排序虽然简单易懂，但其时间复杂度为 O(n^2)，这意味着随着数组规模的增大，排序的时间开销会急剧上升。因此，冒泡排序并不适用于大型数组的排序。

快速排序

快速排序是一种高效的排序算法，其时间复杂度为 O(n log n)。它的基本思想是：选择数组中的一个元素作为枢轴，将数组划分为两个子数组，分别对这两个子数组进行递归排序，最后将排序后的子数组合并成一个有序的数组。

快速排序的性能优异，但在某些情况下，例如数组已经基本有序时，快速排序的性能会退化为 O(n^2)。

归并排序

归并排序也是一种高效的排序算法，其时间复杂度同样为 O(n log n)。它的基本思想是：将数组划分为两个子数组，分别对这两个子数组进行递归排序，最后将排序后的子数组合并成一个有序的数组。

归并排序的性能稳定，不受数组初始状态的影响，因此它是一种非常可靠的排序算法。

LeetCode 912 题详解

LeetCode 912 题要求我们对一个整数数组进行升序排列。我们可以使用上述三种排序算法中的任何一种来解决这个问题。

Python 实现

def sortArray(nums):
  """
  对一个整数数组进行升序排列。

  Args:
    nums: 一个整数数组。

  Returns:
    一个升序排列的整数数组。
  """

  # 使用冒泡排序算法对数组进行排序
  for i in range(len(nums)):
    for j in range(i + 1, len(nums)):
      if nums[i] > nums[j]:
        nums[i], nums[j] = nums[j], nums[i]

  return nums


# 测试代码
nums = [5, 3, 1, 2, 4]
print(sortArray(nums))

Java 实现

public class Solution {
    /**
     * 对一个整数数组进行升序排列。
     *
     * @param nums 一个整数数组。
     *
     * @return 一个升序排列的整数数组。
     */
    public int[] sortArray(int[] nums) {
        // 使用快速排序算法对数组进行排序
        quickSort(nums, 0, nums.length - 1);

        return nums;
    }

    private void quickSort(int[] nums, int low, int high) {
        if (low < high) {
            int partitionIndex = partition(nums, low, high);

            quickSort(nums, low, partitionIndex - 1);
            quickSort(nums, partitionIndex + 1, high);
        }
    }

    private int partition(int[] nums, int low, int high) {
        int pivot = nums[high];
        int i = low - 1;

        for (int j = low; j < high; j++) {
            if (nums[j] <= pivot) {
                i++;

                int temp = nums[i];
                nums[i] = nums[j];
                nums[j] = temp;
            }
        }

        int temp = nums[i + 1];
        nums[i + 1] = nums[high];
        nums[high] = temp;

        return i + 1;
    }

    // 测试代码
    public static void main(String[] args) {
        int[] nums = {5, 3, 1, 2, 4};
        int[] sortedNums = new Solution().sortArray(nums);

        for (int num : sortedNums) {
            System.out.println(num);
        }
    }
}

C++ 实现

#include <iostream>
#include <vector>

using namespace std;

vector<int> sortArray(vector<int>& nums) {
  // 使用归并排序算法对数组进行排序
  return mergeSort(nums, 0, nums.size() - 1);
}

vector<int> mergeSort(vector<int>& nums, int low, int high) {
  if (low < high) {
    int mid = (low + high) / 2;

    vector<int> left = mergeSort(nums, low, mid);
    vector<int> right = mergeSort(nums, mid + 1, high);

    return merge(left, right);
  }

  return vector<int>{nums[low]};
}

vector<int> merge(vector<int>& left, vector<int>& right) {
  vector<int> merged;
  int i = 0, j = 0;

  while (i < left.size() && j < right.size()) {
    if (left[i] < right[j]) {
      merged.push_back(left[i++]);
    } else {
      merged.push_back(right[j++]);
    }
  }

  while (i < left.size()) {
    merged.push_back(left[i++]);
  }

  while (j < right.size()) {
    merged.push_back(right[j++]);
  }

  return merged;
}

// 测试代码
int main() {
  vector<int> nums = {5, 3, 1, 2, 4};
  vector<int> sortedNums = sortArray(nums);

  for (int num : sortedNums) {
    cout << num << " ";
  }

  cout << endl;

  return 0;
}