Posts published in “Array”

花花酱 LeetCode 31. Next Permutation

By zxi on October 2, 2018

Problem

Implement next permutation, which rearranges numbers into the lexicographically next greater permutation of numbers.

If such arrangement is not possible, it must rearrange it as the lowest possible order (ie, sorted in ascending order).

The replacement must be in-place and use only constant extra memory.

Here are some examples. Inputs are in the left-hand column and its corresponding outputs are in the right-hand column.

1,2,3 → 1,3,2
3,2,1 → 1,2,3
1,1,5 → 1,5,1

Solution

Find the last acceding element x, swap with the smallest number y, y is after x that and y is greater than x.

Reverse the elements after x.

Time complexity: O(n)

Space complexity: O(1)

C++

// Author: Huahua, 8 ms

class Solution {

public:

void nextPermutation(vector<int>& nums) {

int i = nums.size() - 2;

while (i >= 0 && nums[i + 1] <= nums[i]) --i;

if (i >= 0) {

int j = nums.size() - 1;

while (j >= 0 && nums[j] <= nums[i]) --j;

swap(nums[i], nums[j]);

}

reverse(begin(nums) + i + 1, end(nums));

}

};

Python3

# Author: Huahua, 48 ms

class Solution:

def nextPermutation(self, nums):

n = len(nums)

i = n - 2

while i >= 0 and nums[i] >= nums[i + 1]: i -= 1

if i >= 0:

j = n - 1

while j >= 0 and nums[j] <= nums[i]: j -= 1

nums[i], nums[j] = nums[j], nums[i]

nums[i + 1:] = nums[i+1:][::-1]

花花酱 LeetCode 27. Remove Element

By zxi on October 2, 2018

Problem

Given an array nums and a value val, remove all instances of that value in-place and return the new length.

Do not allocate extra space for another array, you must do this by modifying the input array in-place with O(1) extra memory.

The order of elements can be changed. It doesn’t matter what you leave beyond the new length.

Example 1:

Given nums = [3,2,2,3], val = 3,

Your function should return length = 2, with the first two elements of nums being 2.

It doesn't matter what you leave beyond the returned length.

Example 2:

Given nums = [0,1,2,2,3,0,4,2], val = 2,

Your function should return length = 5, with the first five elements of nums containing 0, 1, 3, 0, and 4. Note that the order of those five elements can be arbitrary. It doesn't matter what values are set beyond the returned length.

Clarification:

Confused why the returned value is an integer but your answer is an array?

Note that the input array is passed in by reference, which means modification to the input array will be known to the caller as well.

Internally you can think of this:

// nums is passed in by reference. (i.e., without making a copy)
int len = removeElement(nums, val);

// any modification to nums in your function would be known by the caller.
// using the length returned by your function, it prints the first len elements.
for (int i = 0; i < len; i++) {
    print(nums[i]);
}

Solution:

Time complexity: O(n)

Space complexity: O(1)

C++

// Author: Huahua

class Solution {

public:

int removeElement(vector<int>& nums, int val) {

int len = 0;

for (int num : nums)

if (num != val) nums[len++] = num;

return len;

}

};

Python3

class Solution:

def removeElement(self, nums, val):

l = 0

for num in nums:

if num != val:

nums[l], l = num, l + 1

return l

Problem

Given a sorted array nums, remove the duplicates in-place such that each element appear only once and return the new length.

Do not allocate extra space for another array, you must do this by modifying the input array in-place with O(1) extra memory.

Example 1:

Given nums = [1,1,2],

Your function should return length = 2, with the first two elements of nums being 1 and 2 respectively. It doesn't matter what you leave beyond the returned length.

Example 2:

Given nums = [0,0,1,1,1,2,2,3,3,4],

Your function should return length = 5, with the first five elements of nums being modified to 0, 1, 2, 3, and 4 respectively. It doesn't matter what values are set beyond the returned length.

Clarification:

Confused why the returned value is an integer but your answer is an array?

Note that the input array is passed in by reference, which means modification to the input array will be known to the caller as well.

Internally you can think of this:

// nums is passed in by reference. (i.e., without making a copy)
int len = removeDuplicates(nums);

// any modification to nums in your function would be known by the caller.
// using the length returned by your function, it prints the first len elements.
for (int i = 0; i < len; i++) {
    print(nums[i]);
}

Solution:

Time complexity: O(n)

Space complexity: O(1)

C++

// Author: Huahua

class Solution {

public:

int removeDuplicates(vector<int>& nums) {

const int n = nums.size();

if (n <= 1) return n;

int ans = 0;

int i = 0;

while (i < n) {

nums[ans++] = nums[i];

int j = i + 1;

while (j < n && nums[j] == nums[j - 1]) ++j;

i = j;

}

return ans;

}

};

花花酱 LeetCode 88. Merge Sorted Array

By zxi on September 27, 2018

Problem

Given two sorted integer arrays nums1 and nums2, merge nums2 into nums1 as one sorted array.

Note:

The number of elements initialized in nums1 and nums2 are m and n respectively.
You may assume that nums1 has enough space (size that is greater or equal to m + n) to hold additional elements from nums2.

Example:

Input:
nums1 = [1,2,3,0,0,0], m = 3
nums2 = [2,5,6],       n = 3

Output: [1,2,2,3,5,6]

Solution:

Fill nums1 from back to front

Time complexity: O(m + n)

Space complexity: O(1) in-place

C++

// Author: Huahua

class Solution {

public:

void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {

int i = m - 1;

int j = n - 1;

int tail = m + n - 1;

while (j >= 0)

nums1[tail--] = (i >= 0 && nums1[i] > nums2[j]) ? nums1[i--] : nums2[j--];

}

};

花花酱 LeetCode 905. Sort Array By Parity

By zxi on September 15, 2018

Problem

Given an array A of non-negative integers, return an array consisting of all the even elements of A, followed by all the odd elements of A.

You may return any answer array that satisfies this condition.

Example 1:

Input: [3,1,2,4]

Output: [2,4,3,1]

The outputs [4,2,3,1], [2,4,1,3], and [4,2,1,3] would also be accepted.

Note:

1 <= A.length <= 5000
0 <= A[i] <= 5000

Solution 1: Split Odd/Even

Time complexity: O(n)

Space complexity: O(n)

C++

// Author: Huahua, 44 ms

class Solution {

public:

vector<int> sortArrayByParity(vector<int>& A) {

vector<int> even;

vector<int> odd;

for (int a : A) {

if (a % 2) odd.push_back(a);

else even.push_back(a);

}

even.insert(end(even), begin(odd), end(odd));

return even;

}

};

Solution 2: Stable sort by key % 2

Time complexity: O(nlogn)

Space complexity: O(1) in-place

C++

// Author: Huahua, 52 ms

class Solution {

public:

vector<int> sortArrayByParity(vector<int>& A) {

stable_sort(begin(A), end(A), [](int a, int b){

return a % 2 < b % 2;

});

return A;

}

};

Posts published in “Array”

花花酱 LeetCode 31. Next Permutation

Problem

Solution

C++

Python3

花花酱 LeetCode 27. Remove Element

Problem

Solution:

C++

Python3

Related Problems

花花酱 LeetCode 26. Remove Duplicates from Sorted Array

Problem

Solution:

C++

花花酱 LeetCode 88. Merge Sorted Array

Problem

Solution:

C++

花花酱 LeetCode 905. Sort Array By Parity

Problem

Solution 1: Split Odd/Even

C++

Solution 2: Stable sort by key % 2

C++