We are given a n size array and you have to reverse the array using O(N) time complexity. So, we would try to solve 2 questions here :

• Reverse the array

• Reverse the array after position m

The size of the given array is n = 6

Approach

The simplest approach which any programmer could think of is (including me also :) ) the brute force approach, i.e. Traversing the array from the back and then printing the array one by one.

Starting from i = 5 and we will go till i = 0 and voila we got our reverse array.

Time Complexity : O(n) because we are traversing from i = 5 till i = 0, if we had n sized array then we would have traversed from i = n till i = 0. Therefore the time complexity is O(n) .

Code

#include <iostream>
#include <vector>
using namespace std;
int main()
{
  vector<int> arr = {2,5,8,1,7,3};
  //made another array to store the answer and then print the output
  vector<int> ans;
  int n = arr.size();

  //starting from n-1 and going till 0
  for(int i = n-1; i >= 0; i--){
    ans.push_back(arr[i]);
  }
  cout<<"The reversed array is ";
  //for printing the array
  for(int i = 0; i < ans.size(); i++){
    cout<<ans[i]<<" ";  
  }
  return 0;
}

The solution to the given problem is correct but let's think out another or more good, optimized approach than this. (The more ways we find to solve the same problem it benefits our brain to do more practice and our problem-solving skills also improve simultaneously).

Approach 2

In this approach, we will use the concept of two pointer technique. (I know I know two pointer technique is a new term for you but don't worry I'll explain this).

Two Pointer Technique : This is not some high-level concept, here two pointers i.e. variables or index(start and end indexes) are assigned one pointer is assigned at the start while the other is assigned at the end of the array, these two pointers which are assigned travel towards each other until and unless they meet each other.

Here two indexes i.e. start index and end index would be assigned and then we would swap the start values with the end values, and this would give our reverse array.

This way we will get our reverse array

Code

#include <iostream>
#include <vector>
using namespace std;
int main()
{
  vector<int> arr = {2,5,8,1,7,3,4};
  int n = arr.size();

  //pointer one starting from 0
  int start = 0;

  //pointer second starting from the end of the array
  int end = n-1;
  while(start < end){
      swap(arr[start], arr[end]);
      start++;
      end--;
  }
  cout<<"The reverse array is ";
  for(int i = 0; i < n; i++){
    cout<<arr[i]<<" ";
  }
  return 0;
}

Time Complexity : O(n/2) which is nearly O(n)

Question 2

Till here we have solved the first question, now let's come on to the second question Reverse the array after the m position. This question can be done using the approach 2 of the first question i.e. two pointer technique. Here we have to reverse the array after a particular given position or index.

So, the major change we would do here is assigning start = m + 1, where m is the index after which the array needs to be reversed, the rest of the code would be the same here.

Code

#include <iostream>
#include <vector>
using namespace std;
int main()
{
  vector<int> arr = {2,5,8,1,7,3,4};
  int n = arr.size();
  int m = 3;//the position after which the array needs to be revered

  //pointer one starting after m
  int start = m+1;

  //pointer second starting from the end of the array
  int end = n-1;
  while(start < end){
      swap(arr[start], arr[end]);
      start++;
      end--;
  }
  cout<<"The reverse array is ";
  for(int i = 0; i < n; i++){
    cout<<arr[i]<<" ";
  }
  return 0;
}

Hurray!, we have completed both the questions by understanding the concepts and then coding the problems.

So, here are some suggestions to solve DSA problems :

• Don't just read and code the question, first take a pen a paper and try to solve the problem by yourself, ask yourself that are you able to build the logic which is needed to solve the problem.

• Don't worry if you aren't able to solve at first attempt only, even sometimes I also need more time to solve a problem or can't able to solve the problem at one go. So, it's OK

• After spending a sufficient amount of time on that question and, then also you can't able to solve it then take a break for some time and come fresh and then give a try to that question or maybe you can search for the question's solution on YouTube, different coding platforms or seek out to your friends to take some hint of the question and then solve it again by yourself.

• Don't hesitate to ask for help from your friends, because it's ok if you don't know that question. It's ok.

Feel free to reach out on Twitter for any problems and questions.