Open In App

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy

Reverse the elements only at odd positions in the given Array

Given an array arr[] containing N integers, the task is to rearrange the array such that the odd indexed elements are in reverse order.

Examples:



Input: arr[] = {5, 7, 6, 2, 9, 18, 11, 15} 
Output: {5, 15, 6, 18, 9, 2, 11, 7} 
Explanation: 
The elements at even index [5, 6, 9, 11] are unchanged and elements at odd index are reversed from [7, 2, 18, 15] to [15, 18, 2, 7].

Input: arr[] = {1, 2, 3, 4, 5, 6} 
Output: {1, 6, 3, 4, 5, 2} 
Explanation: 
The elements at even index are unchanged and elements at odd index are reversed from [2, 4, 6] to [6, 4, 2]. 



Approach: To solve the problem mentioned above follow the steps given below: 

Below is the implementation of the above approach: 




// C++ program to reverse the
// elements only at odd positions
// in the given Array
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to display elements
void show(int arr[], int n)
{
    cout << "{";
 
    for (int i = 0; i < n - 1; i++)
        cout << arr[i] << ", ";
 
    cout << arr[n - 1] << "}";
}
 
// Function to flip elements
// at odd indexes
void flipHalf(int arr[], int n)
{
    int c = 0;
    int dup = n;
 
    stack<int> st;
 
    // Pushing elements at odd indexes
    // of a array to a stack
    for (int i = 0; i < n; i++) {
        int x = arr[i];
 
        if (c % 2 == 1)
            st.push(x);
        c++;
    }
 
    c = 0;
 
    // Replacing current elements at odd
    // indexes with element at top of stack
    for (int i = 0; i < n; i++) {
        int x = arr[i];
 
        if (c % 2 == 1) {
            x = st.top();
            st.pop();
        }
        arr[i] = x;
        c++;
    }
}
 
// Driver Code
int main()
{
    int arr[] = { 1, 2, 3, 4, 5, 6 };
 
    int n = sizeof(arr) / sizeof(arr[0]);
 
    flipHalf(arr, n);
 
    show(arr, n);
 
    return 0;
}
 





                        























                                    



                                    




                                    




                                    


                                



















// Java program to reverse the 


// elements only at odd positions 


// in the given array 



import java.io.*; 




import java.util.*;



 



class GFG { 



 


// Function to count the valley points 


// in the given character array 



static void show(int arr[], int n) 



{



    System.out.print("{");




     



    for(int i = 0; i < n - 1; i++)




       System.out.print(arr[i] + ", ");



 



    System.out.print(arr[n - 1] + "}");         



} 


 


// Function to flip elements 


// at odd indexes 



public static void flipHalf(int arr[], int n) 



{ 



    int c = 0; 




    int dup = n; 




    Stack<Integer> st = new Stack<>(); 




     



    // Pushing elements at odd indexes




    // of a array to a stack 




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




    { 




       int x = arr[i]; 




        



       if (c % 2 == 1)




       {




           st.push(x);




       }




       c++; 




    } 




    c = 0; 




     



    // Replacing current elements at odd 




    // indexes with element at top of stack 




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




    { 




       int x = arr[i]; 




        



       if (c % 2 == 1) 




       { 




           x = st.peek(); 




           st.pop(); 




       } 




       arr[i] = x; 




       c++; 




    } 



} 


 


// Driver Code 



public static void main(String[] args) 



{ 



    int arr[] = { 1, 2, 3, 4, 5, 6 }; 




    int n = arr.length; 




     



    flipHalf(arr, n); 




    show(arr, n); 



}     


} 


 


// This code is contributed by Aman Kumar 27


















                        






                        























                                    



                                    




                                    




                                    


                                



















# Python3 program to reverse the


# elements only at odd positions


# in the given Array


 


# Function to get top of the stack



def peek_stack(stack):




     



    if stack:




        return stack[-1]



 


# Function to display elements



def show(arr, n):




     



    print("{", end = " ")




    for i in range(0, n - 1):




        print(arr[i], ",", end = " ")




     



    print(arr[n - 1] , "}")



 


# Function to flip elements


# at odd indexes



def flipHalf(arr, n):




     



    c = 0




    dup = n




    stack = []




     



    # Pushing elements at odd indexes




    # of a array to a stack




    for i in range(0, n): 




        x = arr[i]




         



        if c % 2 == 1:




            stack.append(x)




             



        c = c + 1




         



    c = 0



 



    # Replacing current elements at odd




    # indexes with element at top of stack




    for i in range(0, n):




        x = arr[i]




         



        if c % 2 == 1:




            x = peek_stack(stack)




            stack.pop()




     



        arr[i] = x




        c = c + 1



 


# Driver Code



if __name__ == "__main__":




     



  arr = [ 1, 2, 3, 4, 5, 6 ]




  n = len(arr)



 



  flipHalf(arr, n)



 



  show(arr, n)



 


# This code is contributed by akhilsaini


















                        






                        























                                    



                                    




                                    




                                    


                                



















// C# program to reverse the 


// elements only at odd positions 


// in the given array 



using System;




using System.Collections.Generic;



 



class GFG{ 



 


// Function to count the valley points 


// in the given character array 



static void show(int []arr, int n) 



{



    Console.Write("{");




     



    for(int i = 0; i < n - 1; i++)




    Console.Write(arr[i] + ", ");



 



    Console.Write(arr[n - 1] + "}");         



} 


 


// Function to flip elements 


// at odd indexes 



public static void flipHalf(int []arr, int n) 



{ 



    int c = 0; 




    int dup = n; 




    Stack<int> st = new Stack<int>(); 




     



    // Pushing elements at odd indexes




    // of a array to a stack 




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




    { 




        int x = arr[i]; 




             



        if (c % 2 == 1)




        {




            st.Push(x);




        }




        c++; 




    } 




    c = 0; 




     



    // Replacing current elements at odd 




    // indexes with element at top of stack 




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




    { 




        int x = arr[i]; 




             



        if (c % 2 == 1) 




        { 




            x = st.Peek(); 




            st.Pop(); 




        } 




        arr[i] = x; 




        c++; 




    } 



} 


 


// Driver Code 



public static void Main(String[] args) 



{ 



    int []arr = { 1, 2, 3, 4, 5, 6 }; 




    int n = arr.Length; 




     



    flipHalf(arr, n); 




    show(arr, n); 



}     


} 


 


// This code is contributed by 29AjayKumar


















                        






                        























                                    



                                    




                                    




                                    


                                



















<script>



    // Javascript program to reverse the




    // elements only at odd positions




    // in the given Array




     



    // Function to display elements




    function show(arr, n)




    {




        document.write("{");



 



        for (let i = 0; i < n - 1; i++)




            document.write(arr[i] + ", ");



 



        document.write(arr[n - 1] + "}");




    }



 



    // Function to flip elements




    // at odd indexes




    function flipHalf(arr, n)




    {




        let c = 0;




        let dup = n;



 



        let st = [];



 



        // Pushing elements at odd indexes




        // of a array to a stack




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




            let x = arr[i];



 



            if (c % 2 == 1)




                st.push(x);




            c++;




        }



 



        c = 0;



 



        // Replacing current elements at odd




        // indexes with element at top of stack




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




            let x = arr[i];



 



            if (c % 2 == 1) {




                x = st[st.length - 1];




                st.pop();




            }




            arr[i] = x;




            c++;




        }




    }




     



    let arr = [ 1, 2, 3, 4, 5, 6 ];




  



    let n = arr.length;




  



    flipHalf(arr, n);




  



    show(arr, n);



 


</script>


















                        






                        








Output: 

{1, 6, 3, 4, 5, 2}


 


Time complexity: O(N)
Auxiliary Space Complexity: O(N/2) 
 

	

        Article Tags : 
        

            Arrays
Data Structures
DSA
Stack        


		
	

	


      

      

          
Recommended Articles

      

      

          
          
1. Rearrange array by interchanging positions of even and odd elements in the given array

          
2. Make all the elements of array odd by incrementing odd-indexed elements of odd-length subarrays

          
3. Check if the array can be sorted only if the elements on given positions can be swapped

          
4. Find odd-length Subsequences containing only odd elements

          
5. Absolute difference between sum of even elements at even indices & odd elements at odd indices in given Array

          
6. Largest element in the longest Subarray consisting of only Even or only Odd numbers

          
7. Count subarrays having sum of elements at even and odd positions equal

          
8. Positive elements at even and negative at odd positions (Relative order not maintained)

          
9. Numbers with a Fibonacci difference between Sum of digits at even and odd positions in a given range

          
10. Maximize the difference of sum of elements at even indices and odd indices by shifting an odd sized subarray to end of given Array.

          
11. Reverse a string preserving space positions

          
12. Find the only positive or only negative number in the given Array

          
13. Construct Array of given size with elements at even positions divisible by their adjacent left

          
14. Count Numbers in Range with difference between Sum of digits at even and odd positions as Prime

          
15. Count N-digits numbers made up of even and prime digits at odd and even positions respectively

          
16. Minimum flips of odd indexed elements from odd length subarrays to make two given arrays equal

          
17. Find the nearest odd and even perfect squares of odd and even array elements respectively

          
18. Count subarrays consisting of only 0's and only 1's in a binary array

          
19. Count of unique pairs (i, j) in an array such that sum of A[i] and reverse of A[j] is equal to sum of reverse of A[i] and A[j]

          
20. Minimum count of starting elements chosen to visit whole Array depending on ratio of values to positions

          
21. Sort elements of an array A[] placed on a number line by shifting i-th element to (i + B[i])th positions minimum number of times

          
22. Construct an Array of length N containing exactly K elements divisible by their positions

          
23. Find elements in Array whose positions forms Arithmetic Progression

          
24. Find Level wise positions of given node in a given Binary Tree

          
25. Number of 0s and 1s at prime positions in the given array