sorting Archives - Page 6 of 9 - Huahua's Tech Road

花花酱 LeetCode 75. Sort Colors

By zxi on October 1, 2019

Given an array with n objects colored red, white or blue, sort them in-place so that objects of the same color are adjacent, with the colors in the order red, white and blue.

Here, we will use the integers 0, 1, and 2 to represent the color red, white, and blue respectively.

Note: You are not suppose to use the library’s sort function for this problem.

Example:

Input: [2,0,2,1,1,0]
Output: [0,0,1,1,2,2]

Follow up:

A rather straight forward solution is a two-pass algorithm using counting sort.
First, iterate the array counting number of 0’s, 1’s, and 2’s, then overwrite array with total number of 0’s, then 1’s and followed by 2’s.
Could you come up with a one-pass algorithm using only constant space?

Solution 1: Counting sort

Time complexity: O(n)
Space complexity: O(1)

C++

// Author: Huahua

class Solution {

public:

void sortColors(vector<int>& nums) {

vector<int> c(3);

for (int x : nums)

++c[x];

auto it = begin(nums);

for (int i = 0; i < 3; ++i)

while (c[i]--)

*it++ = i;

}

};

Solution 2: Two pointers

Time complexity: O(n)
Space complexity: O(1)

C++

// Author: Huahua

class Solution {

public:

void sortColors(vector<int>& nums) {

const int n = nums.size();

int l = 0;

int r = n - 1;

for (int i = 0; i < n; ++i) {

if (nums[i] == 0) {

swap(nums[i], nums[l++]);

} else if (nums[i] == 2 && i < r) {

swap(nums[i--], nums[r--]);

}

};

花花酱 LeetCode 1200. Minimum Absolute Difference

By zxi on September 22, 2019

Given an array of distinct integers arr, find all pairs of elements with the minimum absolute difference of any two elements.

Return a list of pairs in ascending order(with respect to pairs), each pair [a, b] follows

a, b are from arr
a < b
b - a equals to the minimum absolute difference of any two elements in arr

Example 1:

Input: arr = [4,2,1,3]
Output: [[1,2],[2,3],[3,4]]
Explanation: The minimum absolute difference is 1. List all pairs with difference equal to 1 in ascending order.

Example 2:

Input: arr = [1,3,6,10,15]
Output: [[1,3]]

Example 3:

Input: arr = [3,8,-10,23,19,-4,-14,27]
Output: [[-14,-10],[19,23],[23,27]]

Constraints:

2 <= arr.length <= 10^5
-10^6 <= arr[i] <= 10^6

Solution: Sorting

The min abs difference could only happen between consecutive numbers in sorted form.

Time complexity: O(nlogn)
Space complexity: O(1)

C++

// Author: Huahua

class Solution {

public:

vector<vector<int>> minimumAbsDifference(vector<int>& arr) {

sort(begin(arr), end(arr));

vector<vector<int>> ans;

int best = INT_MAX;

for (int i = 1; i < arr.size(); ++i) {

int d = abs(arr[i] - arr[i - 1]);

if (d < best) {

ans.clear();

best = d;

}

if (d == best) ans.push_back({arr[i - 1], arr[i]});

}

return ans;

}

};

花花酱 LeetCode 217. Contains Duplicate

By zxi on July 22, 2019

Given an array of integers, find if the array contains any duplicates.

Your function should return true if any value appears at least twice in the array, and it should return false if every element is distinct.

Example 1:

Input: [1,2,3,1]
Output: true

Example 2:

Input: [1,2,3,4]
Output: false

Example 3:

Input: [1,1,1,3,3,4,3,2,4,2]
Output: true

Solution 1: HashTable

Time complexity: O(n)
Space complexity: O(n)

C++

// Author: Huahua, 48ms/16.5MB

class Solution {

public:

bool containsDuplicate(vector<int>& nums) {

unordered_set<int> s;

for (int num : nums)

if (!s.insert(num).second) return true;

return false;

}

};

Solution 2: Sorting

Time complexity: O(nlogn)
Space complexity: O(1)

C++

// Author: Huahua, 28ms/11.4MB

class Solution {

public:

bool containsDuplicate(vector<int>& nums) {

sort(begin(nums), end(nums));

for (int i = 1; i < nums.size(); ++i)

if (nums[i] == nums[i - 1]) return true;

return false;

}

};

花花酱 1054. Distant Barcodes

By zxi on May 28, 2019

In a warehouse, there is a row of barcodes, where the i-th barcode is barcodes[i].

Rearrange the barcodes so that no two adjacent barcodes are equal. You may return any answer, and it is guaranteed an answer exists.

Example 1:

Input: [1,1,1,2,2,2]
Output: [2,1,2,1,2,1]

Example 2:

Input: [1,1,1,1,2,2,3,3]
Output: [1,3,1,3,2,1,2,1]

Note:

1 <= barcodes.length <= 10000
1 <= barcodes[i] <= 10000

Soluton: Sorting

Sort the element by their frequency in descending order. Fill the most frequent element first in even positions, if reach the end of the array, start from position 1 then 3, 5, …

Time complexity: O(nlogn)
Space complexity: O(n)

C++

// Author: Huahua, 216 ms, 18.2 MB

class Solution {

public:

vector<int> rearrangeBarcodes(vector<int>& barcodes) {

const int n = barcodes.size();

vector<int> f(10001);

for (int v : barcodes) ++f[v];

sort(begin(barcodes), end(barcodes), [&](const int a, const int b){

return f[a] == f[b] ? a > b : f[a] > f[b];

});

vector<int> ans(n);

int pos = 0;

for (int v : barcodes) {

ans[pos] = v;

if ((pos += 2) >= n) pos = 1;

}

return ans;

}

};

Solution 2: Find the most frequent

Actually, we only need to find the most frequent element and put in the even positions, then put the rest of the groups of elements in any order.

e.g. [1, 1, 2, 2, 2, 2, 2, 3, 4]
Can be
5*2 [2 – 2 – 2 – 2 – 2]
4*1 [2 4 2 – 2 – 2 – 2]
3*1 [2 4 2 3 2 – 2 – 2]
1*2 [ 2 3 2 3 2 1 2 1 2]

if we start with any other groups rather than 2, if will become:
[3 2 2 – 2 – 2 – 2 ] which is wrong…

Time complexity: O(n)
Space complexity: O(n)

C++

// Author: Huahua, 172 ms (99.89%), 18 MB (< 100%)

class Solution {

public:

vector<int> rearrangeBarcodes(vector<int>& barcodes) {

constexpr int kMaxV = 10001;

const int n = barcodes.size();

vector<int> f(kMaxV);

int max_f = 0;

int max_v = 0;

for (int v : barcodes)

if (++f[v] > max_f) {

max_f = f[v];

max_v = v;

}

vector<int> ans(n);

int pos = 0;

while (f[max_v]-- > 0) {

ans[pos] = max_v;

if ((pos += 2)>= n) pos = 1;

}

for (int v = 1; v < kMaxV; ++v) {

while (f[v]-- > 0) {

ans[pos] = v;

if ((pos += 2) >= n) pos = 1;

}

return ans;

}

};

花花酱 LeetCode 1051. Height Checker

By zxi on May 27, 2019

Students are asked to stand in non-decreasing order of heights for an annual photo.

Return the minimum number of students not standing in the right positions. (This is the number of students that must move in order for all students to be standing in non-decreasing order of height.)

Example 1:

Input: [1,1,4,2,1,3]
Output: 3
Explanation: 
Students with heights 4, 3 and the last 1 are not standing in the right positions.

Note:

1 <= heights.length <= 100
1 <= heights[i] <= 100

Solution: Sorting

Time complexity: O(nlogn)
Space complexity: O(n)

C++

class Solution {

public:

int heightChecker(vector<int>& heights) {

vector<int> h(heights);

sort(begin(h), end(h));

int ans = 0;

for (int i = 0; i < h.size(); ++i)

ans += (heights[i] != h[i]);

return ans;

}

};

Posts tagged as “sorting”

花花酱 LeetCode 75. Sort Colors

Solution 1: Counting sort

C++

Solution 2: Two pointers

C++

花花酱 LeetCode 1200. Minimum Absolute Difference

Solution: Sorting

C++

花花酱 LeetCode 217. Contains Duplicate

Solution 1: HashTable

C++

Solution 2: Sorting

C++

花花酱 1054. Distant Barcodes

Soluton: Sorting

C++

Solution 2: Find the most frequent

C++

花花酱 LeetCode 1051. Height Checker

Solution: Sorting

C++