[LeetCode] 462. Minimum Moves to Equal Array Elements II

Given an integer array nums of size n, return the minimum number of moves required to make all array elements equal.

In one move, you can increment or decrement an element of the array by 1.

Test cases are designed so that the answer will fit in a 32-bit integer.

Example 1:

Input: nums = [1,2,3]
Output: 2
Explanation:
Only two moves are needed (remember each move increments or decrements one element):
[1,2,3]  =>  [2,2,3]  =>  [2,2,2]

Example 2:

Input: nums = [1,10,2,9]
Output: 1 

Constraints:

• n == nums.length
• 1 <= nums.length <= 105
• -109 <= nums[i] <= 109

最少移动次数使数组元素相等II。

给你一个长度为 n 的整数数组 nums ，返回使所有数组元素相等需要的最少移动数。

在一步操作中，你可以使数组中的一个元素加 1 或者减 1 。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/minimum-moves-to-equal-array-elements-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

题意跟版本一453题很接近，但是这次并不是将所有的数字都往最大值靠拢，这个题考的是问最少操作多少次可以使所有数字相同，而且这个题的操作次数是针对每一个数字而言的，也就是说，每一个数字动一次，就是一次操作。

思路是找到数组的中位数，然后每个数字和中位数的差值就是操作次数。最后要求的结果就是每个数字的操作次数的累加和。既然是求中位数，比较直观的思路就是用Arrays.sort()先排序，找到数组中间的数字，或者是用快速排序找。就这道题的 test case 而言，前者更快。

时间O(nlogn), worse case is O(n^2)

空间O(1)

Java函数排序

class Solution {
    public int minMoves2(int[] nums) {
        Arrays.sort(nums);
        int res = 0;
        int mid = nums[nums.length / 2];
        for (int num : nums) {
            res += Math.abs(num - mid);
        }
        return res;
    }
}

 

快速排序

class Solution {
    public int minMoves2(int[] nums) {
        int res = 0;
        int median = findKthLargest(nums, nums.length / 2 + 1);
        for (int num : nums) {
            res += Math.abs(median - num);
        }
        return res;
    }

    private int findKthLargest(int[] nums, int k) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        int left = 0;
        int right = nums.length - 1;
        while (true) {
            int pos = partition(nums, left, right);
            if (pos + 1 == k) {
                return nums[pos];
            } else if (pos + 1 > k) {
                right = pos - 1;
            } else {
                left = pos + 1;
            }
        }
    }

    private int partition(int[] nums, int left, int right) {
        int pivot = nums[left];
        int l = left + 1;
        int r = right;
        while (l <= r) {
            if (nums[l] < pivot && nums[r] > pivot) {
                swap(nums, l++, r--);
            }
            if (nums[l] >= pivot) {
                l++;
            }
            if (nums[r] <= pivot) {
                r--;
            }
        }
        swap(nums, left, r);
        return r;
    }

    private void swap(int[] nums, int i, int j) {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
}

 

LeetCode 题目总结