Leetcode: Minimum Moves to Equal Array Elements II

Given a non-empty integer array, find the minimum number of moves required to make all array elements equal, where a move is incrementing a selected element by 1 or decrementing a selected element by 1.

You may assume the array's length is at most 10,000.

Example:

Input:
[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]

Just like meeting point problem, find the median elements in the array after sorting, so

Solution 1: Sort, find the median: O(NlogN)

public class Solution {
    public int minMoves2(int[] nums) {
        Arrays.sort(nums);
        int i = 0, j = nums.length-1;
        int count = 0;
        while(i < j){
            count += nums[j]-nums[i];
            i++;
            j--;
        }
        return count;
    }
}

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

Solution 2: Quick Select

This solution relies on the fact that if we increment/decrement each element to the median of all the elements, the optimal number of moves is necessary. The median of all elements can be found in expected O(n) time using QuickSelect (or O(n) 

public class Solution {
    public int minMoves2(int[] nums) {
        int median = findMedian(nums, 0, nums.length-1, nums.length/2+1);
        int res = 0;
        for (int num : nums) {
            res += Math.abs(num-median);
        }
        return res;
    }
    
    public int findMedian(int[] nums, int l, int r, int k) {
        int start = l;
        int end = r;
        int pivot = r;
        while (start < end) {
            while (start < end && nums[start] < nums[pivot]) {
                start++;
            }
            while (start < end && nums[end] >= nums[pivot]) {
                end--;
            }
            if (start == end) break;
            swap(nums, start, end);
        }
        swap(nums, start, pivot);
        if (start+1 == k) return nums[start];
        else if (k < start+1) return findMedian(nums, l, start-1, k);
        else return findMedian(nums, start+1, r, k);
    }
    
    public void swap(int[] nums, int i, int j) {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
}