【数据结构与算法】之排序系列-20240204

---

一、977. 有序数组的平方

简单
给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

示例 1：
输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]

示例 2：
输入：nums = [-7,-3,2,3,11]
输出：[4,9,9,49,121]

思路：采用双指针
数组 nums 是非递减排序的数组，那就相当于是个递增的数组，且每个元素的取值 -10^4 <= nums[i] <= 10^4，这就证明元素值有正有负。
通过这两个条件其实我们可以得出，平方以后的最大值肯定出现在两侧，不是左边就是右边（负数的平方为正数）。
碰到这种情况，我们一般祭出双指针法来解决，left 指向下标 0，right 指向下标 n - 1：
新建一个结果数组 res 存储最后的结果，site 指向数组末尾，数组从后向前存储。
若 nums[left] * nums[left] < nums[right] * nums[right]，res[site] = nums[right] * nums[right]。
若 nums[left] * nums[left] >= nums[right] * nums[right]，res[site] = nums[left] * nums[left]。

def sortdSquares(nums):
    if len(nums) == 1:
        return nums[0] * nums[0]
    # 初始化双指针
    left = 0
    right = len(nums) - 1
    # 存储结果数组，从数组末尾开始存储
    res = [-1] * len(nums)
    site = len(nums) - 1
    while left <= right:
        # 从两端遍历，将平方数大的存储在res数组中
        if nums[left] * nums[left] < nums[right] * nums[right]:
            res[site] = nums[right] * nums[right]
            right -= 1
        else:
            res[site] = nums[left] * nums[left]
            left += 1
        site -= 1
    return res

二、1051. 高度检查器

简单
学校打算为全体学生拍一张年度纪念照。根据要求，学生需要按照 非递减 的高度顺序排成一行。
排序后的高度情况用整数数组 expected 表示，其中 expected[i] 是预计排在这一行中第 i 位的学生的高度（下标从 0 开始）。
给你一个整数数组 heights ，表示 当前学生站位 的高度情况。heights[i] 是这一行中第 i 位学生的高度（下标从 0 开始）。
返回满足 heights[i] != expected[i] 的 下标数量 。

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

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

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

class S1051:
    def func(self, nums):
        ans = 0
        nums_sorted = sorted(nums)
        for i, j in list(zip(nums, nums_sorted)):
            if i != j:
                ans += 1
        return ans


res = S1051()
nums = [5, 1, 2, 3, 4]
print(res.func(nums))

三、1122. 数组的相对排序

简单
给你两个数组，arr1 和 arr2，arr2 中的元素各不相同，arr2 中的每个元素都出现在 arr1 中。
对 arr1 中的元素进行排序，使 arr1 中项的相对顺序和 arr2 中的相对顺序相同。未在 arr2 中出现过的元素需要按照升序放在 arr1 的末尾。

示例 1：
输入：arr1 = [2,3,1,3,2,4,6,7,9,2,19], arr2 = [2,1,4,3,9,6]
输出：[2,2,2,1,4,3,3,9,6,7,19]

示例 2:
输入：arr1 = [28,6,22,8,44,17], arr2 = [22,28,8,6]
输出：[22,28,8,6,17,44]

class S1122:
    def func(self, arr1, arr2):
        res = []
        for i in arr2:
            count = arr1.count(i)
            while count != 0:
                res.append(i)
                count -= 1
                arr1.remove(i)
        res = res + sorted(arr1)
        return res


res = S1122()
arr1 = [2, 3, 1, 3, 2, 4, 6, 7, 9, 2, 19]
arr2 = [2, 1, 4, 3, 9, 6]
print(res.func(arr1, arr2))

四、1200. 最小绝对差

简单
给你个整数数组 arr，其中每个元素都 不相同。
请你找到所有具有最小绝对差的元素对，并且按升序的顺序返回。
每对元素对 [a,b] 如下：
a , b 均为数组 arr 中的元素
a < b
b - a 等于 arr 中任意两个元素的最小绝对差

示例 1：
输入：arr = [4,2,1,3]
输出：[[1,2],[2,3],[3,4]]

示例 2：
输入：arr = [1,3,6,10,15]
输出：[[1,3]]

示例 3：
输入：arr = [3,8,-10,23,19,-4,-14,27]
输出：[[-14,-10],[19,23],[23,27]]

class S1200:
    def func(self, nums):
        nums.sort()
        n = len(nums)

        gap = 10000000
        for i in range(1, n):
            gap = min(gap, nums[i] - nums[i - 1])

        ans = []
        for i in range(1, n):
            if nums[i] - nums[i - 1] == gap:
                ans.append([nums[i - 1], nums[i]])
        return ans


res = S1200()
arr = [3, 8, -10, 23, 19, -4, -14, 27]
print(res.func(arr))

五、1331. 数组序号转换

简单
给你一个整数数组 arr ，请你将数组中的每个元素替换为它们排序后的序号。
序号代表了一个元素有多大。序号编号的规则如下：

序号从 1 开始编号。
一个元素越大，那么序号越大。如果两个元素相等，那么它们的序号相同。
每个数字的序号都应该尽可能地小。

示例 1：
输入：arr = [40,10,20,30]
输出：[4,1,2,3]
解释：40 是最大的元素。 10 是最小的元素。 20 是第二小的数字。 30 是第三小的数字。

示例 2：
输入：arr = [100,100,100]
输出：[1,1,1]
解释：所有元素有相同的序号。
示例 3：

输入：arr = [37,12,28,9,100,56,80,5,12]
输出：[5,3,4,2,8,6,7,1,3]

思路：
将数组去重后排序，数字在排序列表中的索引位置加一即代表数字在数组中的排位

class Solution1331:
    def func(self, arr):
        dct = {num: i + 1 for i, num in enumerate(sorted(set(arr)))}
        return [dct[num] for num in arr]

res = Solution1331()
arr = [40, 10, 20, 30]
print(res.func(arr))

---