Related Articles
Reduce the array by deleting elements which are greater than all elements to its left
• Last Updated : 26 Feb, 2021

Given an array arr[] of N integers, the task is to delete the element from the given array if element to it’s left is smaller than it. Keep on deleting the elements from the array until no element has a smaller adjacent left element. Print the resultant array after above operation.

Examples:

Input: arr[] = {2, 4, 1, 3, 4}
Output: 2 1
Explanation:
Since 4 is greater than 2 remove 4, and arr become {2, 1, 3, 4}.
Now 3 is greater than 1 so remove 3 and arr become {2, 1, 4}.
Now 4 is greater than 1 so remove 4 and arr become {2, 1}.
Now no elements satisfy the removing criteria so the resultant array is {2, 1}.

Input: arr[] = {5, 4, 3, 2, 1}
Output: 5 4 3 2 1

Approach: The idea is to use the concept of Merge Sort.

1. Divide the input array into sub-arrays till the size of each sub-array becomes 1.
2. Start merging the element.
3. While merging, delete elements from the left subarray till it’s rightmost element, which have a value greater than the leftmost element of the right subarray.
4. Repeat the above steps in each merging step such all elements with value smaller to it’s left have been deleted.
5. Finally print the resultant array.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include``using` `namespace` `std;` `// Function to implement merging of arr[]``vector<``int``> merge(vector<``int``> x, vector<``int``> y)``{``    ``for``(``auto` `i : y)``    ``{``        ``if` `(x[x.size() - 1] > i)``            ``x.push_back(i);``    ``}``    ``return` `x;``}` `// Function to delete all elements which``// satisfy the condition A[i] > A[i-1]``vector<``int``> mergeDel(vector<``int``> l)``{``    ` `    ``// Divide array into its subarray``    ``if` `(l.size() == 1)``        ``return` `l;` `    ``int` `m = l.size() / 2;``    ` `    ``vector<``int``> temp1 = {l.begin() + 0,``                         ``l.begin() + m};``    ``vector<``int``> temp2 = {l.begin() + m,``                         ``l.end()};``    ` `    ``// Getting back merged array with all ``    ``// its right element greater than``    ``// left one.``    ``return` `merge(mergeDel(temp1),``                 ``mergeDel(temp2));``}` `// Driver Code``int` `main()``{``    ` `    ``// Given array arr[]``    ``vector<``int``> arr({ 5, 4, 3, 2, 1 });``    ``vector<``int``> ans = mergeDel(arr);``    ` `    ``cout << ``"[ "``;``    ``for``(``auto` `x: ans)``        ``cout << x << ``", "``;``        ` `    ``cout << ``"]"``;``}` `// This code is contributed by SURENDRA_GANGWAR`

## Java

 `// Java program for the above approach``import` `java.util.ArrayList;``import` `java.util.Arrays;` `class` `GFG{``    ` `// Function to implement merging of arr[]``static` `ArrayList merge(ArrayList x,``                                ``ArrayList y)``{``    ``for``(Integer i : y)``    ``{``        ``if` `(x.get(x.size() - ``1``) > i)``            ``x.add(i);``    ``}``    ``return` `x;``}` `// Function to delete all elements which``// satisfy the condition A[i] > A[i-1]``static` `ArrayList mergeDel(ArrayList l)``{``    ` `    ``// Divide array into its subarray``    ``if` `(l.size() == ``1``)``        ``return` `l;` `    ``int` `m = l.size() / ``2``;` `    ``ArrayList temp1 = ``new` `ArrayList<>(``        ``l.subList(``0``, m));``    ``ArrayList temp2 = ``new` `ArrayList<>(``        ``l.subList(m, l.size()));` `    ``// Getting back merged array with all``    ``// its right element greater than``    ``// left one.``    ``return` `merge(mergeDel(temp1), mergeDel(temp2));``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ` `    ``// Given array arr[]``    ``Integer[] ar = { ``5``, ``4``, ``3``, ``2``, ``1` `};``    ` `    ``ArrayList arr = ``new` `ArrayList<>(``        ``Arrays.asList(ar));``    ``ArrayList ans = mergeDel(arr);``    ` `    ``System.out.print(``"[ "``);``    ``for``(Integer x : ans)``        ``System.out.print(x + ``", "``);``        ` `    ``System.out.println(``"]"``);``}``}` `// This code is contributed by sanjeev2552`

## Python3

 `# Python3 program for the above approach` `# Function to delete all elements which``# satisfy the condition A[i] > A[i-1]``def` `mergeDel(l):` `    ``# Divide array into its subarray``    ``if` `len``(l) ``=``=` `1``:` `        ``return` `l` `    ``m ``=` `int``( ``len``(l) ``/` `2``)` `    ``# Getting back merged array with all``    ``# its right element greater than left one.``    ``return` `merge(mergeDel(l[ ``0` `: m ]),``                 ``mergeDel(l[ m : ``len``(l)]) )`  `# Function to implement merging of arr[]``def` `merge(x, y):` `    ``for` `i ``in` `y:` `        ``if` `x[``-``1``] > i :` `            ``x ``=` `x ``+` `[i]` `    ``return` `x``  ` `# Driver Code` `# Function defination for main()``def` `main():` `# Given array arr[]``    ``arr ``=` `[``5``, ``4``, ``3``, ``2``, ``1``]``    ``print``(mergeDel(arr))` `main()`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG{` `// Function to implement merging of arr[]``static` `List<``int``> merge(List<``int``> x, List<``int``> y)``{``    ``foreach``(``int` `i ``in` `y)``    ``{``        ``if` `(x[x.Count - 1] > i)``            ``x.Add(i);``    ``}``    ``return` `x;``}` `// Function to delete all elements which``// satisfy the condition A[i] > A[i-1]``static` `List<``int``> mergeDel(List<``int``> l)``{``    ` `    ``// Divide array into its subarray``    ``if` `(l.Count == 1)``        ``return` `l;` `    ``int` `m = l.Count / 2;` `    ``List<``int``> temp1 = l.GetRange(0, m);``    ``List<``int``> temp2 = l.GetRange(m, l.Count - m);` `    ``// Getting back merged array with all``    ``// its right element greater than``    ``// left one.``    ``return` `merge(mergeDel(temp1),``                 ``mergeDel(temp2));``}` `// Driver Code``public` `static` `void` `Main(``string``[] args)``{``    ` `    ``// Given array arr[]``    ``List<``int``> arr = ``new` `List<``int``>{ 5, 4, 3, 2, 1 };` `    ``List<``int``> ans = mergeDel(arr);` `    ``Console.Write(``"[ "``);``    ``foreach``(``int` `x ``in` `ans)``        ``Console.Write(x + ``", "``);` `    ``Console.Write(``"]"``);``}``}` `// This code is contributed by chitranayal`
Output:
`[5, 4, 3, 2, 1]`

Time Complexity: O(N*log N)
Auxiliary Space: O(1) My Personal Notes arrow_drop_up