排序题目：高度检查器

题目

标题和出处

标题：高度检查器

出处：1051. 高度检查器

难度

2 级

题目描述

要求

学校打算为全体学生拍一张年度纪念照。根据要求，学生需要按照非递减的高度顺序排成一行。排序后的高度情况用整数数组 $\text{expected}$ 表示，其中 $\text{expected[i]}$ 是排在这一行中第 $\text{i}$ 位的学生的预期高度（下标从 $\text{0}$ 开始）。

给定整数数组 $\text{heights}$，表示学生站位的当前顺序，其中 $\text{heights[i]}$ 是这一行中第 $\text{i}$ 位学生的高度（下标从 $\text{0}$ 开始）。

返回满足 $\text{heights[i]}\ne \text{expected[i]}$ 的下标数量。

示例

示例 1：

输入：$\text{heights = [1,1,4,2,1,3]}$
输出：$\text{3}$
解释：
高度：$\text{[1,1,4,2,1,3]}$
预期：$\text{[1,1,1,2,3,4]}$
下标 $\text{2}$、$\text{4}$、$\text{5}$ 处的学生高度不匹配。

示例 2：

输入：$\text{heights = [5,1,2,3,4]}$
输出：$\text{5}$
解释：
高度：$\text{[5,1,2,3,4]}$
预期：$\text{[1,2,3,4,5]}$
所有下标的对应学生高度都不匹配。

示例 3：

输入：$\text{heights = [1,2,3,4,5]}$
输出：$\text{0}$
解释：
高度：$\text{[1,2,3,4,5]}$
预期：$\text{[1,2,3,4,5]}$
所有下标的对应学生高度都匹配。

数据范围

• $\text{1}\le \text{heights.length}\le \text{100}$
• $\text{1}\le \text{heights[i]}\le \text{100}$

解法一

思路和算法

由于要求拍照时学生按照非递减的高度顺序排列，排序后的高度情况是整数数组 $\text{expected}$，因此数组 $\text{expected}$ 为数组 $\text{heights}$ 升序排序之后的结果。

为了得到数组 $\text{expected}$，需要创建与数组 $\text{heights}$ 相同长度的数组 $\text{expected}$，将数组 $\text{heights}$ 中的元素复制到数组 $\text{expected}$ 中，然后对数组 $\text{expected}$ 升序排序，即可得到排序后的数组 $\text{expected}$。

对数组 $\text{expected}$ 排序之后，同时遍历数组 $\text{heights}$ 和数组 $\text{expected}$，统计对应元素不相等的下标数量。

代码

class Solution {
    public int heightChecker(int[] heights) {
        int length = heights.length;
        int[] expected = new int[length];
        System.arraycopy(heights, 0, expected, 0, length);
        Arrays.sort(expected);
        int diff = 0;
        for (int i = 0; i < length; i++) {
            if (heights[i] != expected[i]) {
                diff++;
            }
        }
        return diff;
    }
}

复杂度分析

• 时间复杂度：$O(n\log n)$，其中 $n$ 是数组 $\text{heights}$ 的长度。需要 $O(n)$ 的时间将数组 $\text{heights}$ 中的元素复制到数组 $\text{expected}$ 中，对数组 $\text{expected}$ 排序需要 $O(n\log n)$ 的时间，遍历两个数组统计对应元素不相等的下标数量需要 $O(n)$ 的时间，总时间复杂度是 $O(n\log n)$。

• 空间复杂度：$O(n)$，其中 $n$ 是数组 $\text{heights}$ 的长度。需要创建长度为 $n$ 的数组 $\text{expected}$，对数组 $\text{expected}$ 排序需要 $O(\log n)$ 的递归调用栈空间，空间复杂度是 $O(n)$。

解法二

思路和算法

解法一需要 $O(n\log n)$ 的时间复杂度。如果使用计数代替排序，则可以降低时间复杂度。

首先得到学生高度的最大值，然后对每个高度计数。得到计数之后，按照升序顺序同时遍历每个高度和数组 $\text{heights}$。假设数组 $\text{heights}$ 有序，高度 $\text{height}$ 的计数为 $\text{count}$，则遍历数组 $\text{heights}$ 中的 $\text{count}$ 个元素，这些元素都等于 $\text{height}$，如果这 $\text{count}$ 个元素中存在不等于 $\text{height}$ 的元素，则每个不等于 $\text{height}$ 的元素表示一个高度不匹配的位置。

以示例 1 为例。高度数组 $\text{heights}=[1,1,4,2,1,3]$，计数数组 $\text{counts}=[0,3,1,1,1]$（计数数组的下标从 $0$ 开始）。同时遍历计数数组 $\text{counts}$ 和高度数组 $\text{heights}$：

1. 高度 $\text{height}=1$，$\text{counts}[1]=3$，遍历 $\text{heights}$ 的 $3$ 个元素 $1,1,4$，有 $1$ 个元素不等于 $1$，计数加 $1$；

2. 高度 $\text{height}=2$，$\text{counts}[2]=1$，遍历 $\text{heights}$ 的 $1$ 个元素 $2$，计数不变；

3. 高度 $\text{height}=3$，$\text{counts}[3]=1$，遍历 $\text{heights}$ 的 $1$ 个元素 $1$，有 $1$ 个元素不等于 $3$，计数加 $1$；

4. 高度 $\text{height}=4$，$\text{counts}[4]=1$，遍历 $\text{heights}$ 的 $1$ 个元素 $3$，有 $1$ 个元素不等于 $4$，计数加 $1$。

遍历结束之后得到计数 $3$ 即为答案。

代码

class Solution {
    public int heightChecker(int[] heights) {
        int maxHeight = 0;
        for (int height : heights) {
            maxHeight = Math.max(maxHeight, height);
        }
        int[] counts = new int[maxHeight + 1];
        for (int height : heights) {
            counts[height]++;
        }
        int diff = 0;
        for (int height = 1, index = 0; height <= maxHeight; height++) {
            int count = counts[height];
            for (int i = 1; i <= count; i++) {
                if (heights[index] != height) {
                    diff++;
                }
                index++;
            }
        }
        return diff;
    }
}

复杂度分析

• 时间复杂度：$O(n+m)$，其中 $n$ 是数组 $\text{heights}$ 的长度，$m$ 是数组 $\text{heights}$ 的最大值。需要 $O(n)$ 的时间得到数组 $\text{heights}$ 的最大值并对每个高度计数，需要 $O(n+m)$ 的时间统计高度不匹配的下标数量，总时间复杂度是 $O(n+m)$。

• 空间复杂度：$O(m)$，其中 $m$ 是数组 $\text{heights}$ 的最大值。计数需要 $O(m)$ 的空间。