Maximum of all subarrays of size k - c++

Question

PROBLEM: Given an array arr[] of size N and an integer K. Find the maximum for each and every contiguous subarray of size K.
Why doesn't the following test case pass for the code below:-
Input: 5 4 1 2 3 4 5 Its Correct output is:
4 5
And my Code's output is: 4 5 5
int find_max(queue<int> q){
int max = 0;
while (!q.empty())
{
if (q.front() > max)
max = q.front();
q.pop();
}
return max;
}
vector<int> max_of_subarrays(int *arr, int n, int k){
// your code here
vector<int> res;
queue<int> q;
vector<int> temp;
int i = 0, j = 0;
//for cases where n = k
if(k == n){
sort(arr, arr+n);
temp.push_back(arr[n-1]);
return temp;
}
while(j < n)
{
q.push(arr[j]);
if ((j - i + 1) < k)
{
j++;
}
else if((j - i + 1) == k)
{
int x = find_max(q);
res.push_back(x);
//removing first entered element from queue
q.pop();
//pushing the next element to the queue
q.push(arr[i]);
i++;
j++;
}
}
//for last window
int x = find_max(q);
res.push_back(x);
return res;
}
Can someone tell what's going wrong here?

Answer 1

Yes, we can help.
The line q.push(arr[i]); is wrong. Index i will not be the last element. So, rather index j+1 should be used. But this will be pushed anyway in the next loop run.
So, you do not need this line at all. Delete it!
And in your while loop, you find already all results. So, you can simply delete the last 2 lines
int x = find_max(q);
res.push_back(x);
Then your function will work.
But for real C++ it is too complicated.
You could also use the following approach with a `````std::deque````:
auto maxOfContiguousSubArray(std::vector<int>& data, size_t subArraySize) {
// Here we will store the result
std::vector<int> result{};
// And this will hold our subarray. We use a deque, because we will have then have required iterators
std::deque<int> subArray{};
// Special case: Number of elements is less or equal the subarray size
if (data.size() <= subArraySize) {
// Get the one max element
result.push_back(*std::max_element(data.begin(), data.end()));
}
// Go over all numbers in data
else for (size_t index{}; index < data.size(); index++) {
// Store value in sub array
subArray.push_back(data[index]);
// If there are enough values in subarray, then
if (index >= subArraySize-1 ) {
// Get the max value
result.push_back(*std::max_element(subArray.begin(), subArray.end()));
// Remove the first value
subArray.pop_front();
}
}
return result;
}
int main() {
size_t n{}, k{};
// Read number of elements and size of subarray
if (std::cin >> n >> k) {
// Here we will store our numbers
std::vector<int> data{};
// copy n numbers from std::cin into data
std::copy_n(std::istream_iterator<int>(std::cin), n, std::back_inserter(data));
// Calculate the max values
auto max = maxOfContiguousSubArray2(data, k);
// Show the user output
std::copy(max.begin(), max.end(), std::ostream_iterator<int>(std::cout, " "));
}
return 0;
}
But basically, you do not need a subarray at all. You can simply build a sliding door with iterators or with indices.
Then the function would look like that:
auto maxOfContiguousSubArray2(std::vector<int>& data, size_t subArraySize) {
// Here we will store the result
std::vector<int> result{};
// Special case: Number of elements is less or equal the subarray size
subArraySize = std::min(data.size(), subArraySize);
// Find the max element of the window
for (auto first{ data.begin() }, last{ data.begin() + subArraySize-1 }; last != data.end(); ++first, ++last)
result.push_back(*std::max_element(first, last));
return result;
}

Answer 2

Problem - Given an array arr[] of size N and an integer K. Find the maximum for each and every contiguous subarray of size K.
This is how "Maximum of all subarrays of size k" problem is implemented in Java
class Solution
{
static ArrayList <Integer> max_of_subarrays(int arr[], int n, int k)
{
int i = 0,j = 0;
ArrayList <Integer> ans = new ArrayList <Integer>();
Deque<Integer> q = new LinkedList<Integer>();
while(j<n){
while(q.isEmpty() == false && q.peekLast() < arr[j])
q.removeLast();
q.addLast(arr[j]);
if(j-i+1 < k)
j++;
else if(j-i+1 == k){
ans.add(q.peekFirst());
if(arr[i] == q.peekFirst())
q.removeFirst();
i++;
j++;
}
}
return ans;
}
}