# Delete Array Elements which are Smaller than Next or Become Smaller

Last Updated : 29 Mar, 2024

Given an array arr[] and a number k. The task is to delete k elements which are smaller than next element (i.e., we delete arr[i] if arr[i] < arr[i+1]) or become smaller than next because next element is deleted.

Example:

Input : arr[] = { 3, 100, 1 }, k = 1
Output : 100, 1
Explanation : arr[0] < arr[1] means 3 is less than 100, so delete 3

Input : arr[] = {20, 10, 25, 30, 40}, k = 2
Output : 25 30 40
Explanation : First we delete 10 because it follows arr[i] < arr[i+1]. Then we delete 20 because 25 is moved next to it and it also starts following the condition.

Input: arr[] = { 23, 45, 11, 77, 18}, k = 3
Output : 77, 18
Explanation : We delete 23, 45 and 11 as they follow the condition arr[i] < arr[i+1]

Approach:

Stack is used to solving this problem. First we push arr[0] in stack S and then initialize count as 0, then after traverse a loop from 1 to n and then we check that s.top() < arr[i] if condition is true then we pop the element from stack and increase the count if count == k then we stop the loop and then store the value of stack in another array and then print that array.

Below is the Implementation of the above idea:

## C++

 `// C++ program to delete elements from array. ` `#include ` `using` `namespace` `std; ` ` `  `// Function for deleting k elements ` `void` `deleteElements(``int` `arr[], ``int` `n, ``int` `k) ` `{  ` `    ``// Create a stack and push arr[0] ` `    ``stack<``int``> s; ` `    ``s.push(arr[0]); ` ` `  `    ``int` `count = 0; ` `     `  `    ``// traversing a loop from i = 1 to n ` `    ``for` `(``int` `i=1; i v(m); ``// Size of vector is m ` `    ``while` `(!s.empty()) { ` `         `  `        ``// push element from stack to vector v ` `        ``v[--m] = s.top(); ` `        ``s.pop(); ` `    ``} ` `     `  `    ``// printing result ` `    ``for` `(``auto` `x : v) ` `        ``cout << x << ``" "``; ` `         `  `    ``cout << endl; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `n = 5, k = 2; ` `    ``int` `arr[] = {20, 10, 25, 30, 40};  ` `    ``deleteElements(arr, n, k); ` `    ``return` `0; ` `} `

## Java

 `import` `java.util.*; ` ` `  `//Java program to delete elements from array. ` `class` `GFG { ` ` `  `// Function for deleting k elements ` `    ``static` `void` `deleteElements(``int` `arr[], ``int` `n, ``int` `k) { ` `        ``// Create a stack and push arr[0] ` `        ``Stack s = ``new` `Stack<>(); ` `        ``s.push(arr[``0``]); ` ` `  `        ``int` `count = ``0``; ` ` `  `        ``// traversing a loop from i = 1 to n ` `        ``for` `(``int` `i = ``1``; i < n; i++) { ` ` `  `            ``// condition for deleting an element ` `            ``while` `(!s.empty() && s.peek() < arr[i] ` `                    ``&& count < k) { ` `                ``s.pop(); ` `                ``count++; ` `            ``} ` ` `  `            ``s.push(arr[i]); ` `        ``} ` ` `  `        ``// Putting elements of stack in a vector ` `        ``// from end to begin. ` `        ``int` `m = s.size(); ` `        ``Integer[] v = ``new` `Integer[m]; ``// Size of vector is m ` `        ``while` `(!s.empty()) { ` ` `  `            ``// push element from stack to vector v ` `            ``v[--m] = s.peek(); ` `            ``s.pop(); ` `        ``} ` ` `  `        ``// printing result ` `        ``for` `(Integer x : v) { ` `            ``System.out.print(x + ``" "``); ` `        ``}; ` ` `  `        ``System.out.println(``""``); ` `    ``} ` ` `  `// Driver code ` `    ``public` `static` `void` `main(String[] args) { ` `        ``int` `n = ``5``, k = ``2``; ` `        ``int` `arr[] = {``20``, ``10``, ``25``, ``30``, ``40``}; ` `        ``deleteElements(arr, n, k); ` `    ``} ` `} ` `// This code is contributed by PrinciRaj1992 `

## Python3

 `# Function to delete elements ` `def` `deleteElements(arr, n, k): ` `     `  `    ``# create an empty stack st ` `    ``st ``=` `[] ` `    ``st.append(arr[``0``]) ` `     `  `    ``# index to maintain the top  ` `    ``# of the stack ` `    ``top ``=` `0` `    ``count ``=` `0` ` `  `    ``for` `i ``in` `range``(``1``, n): ` `         `  `        ``# pop till the present element  ` `        ``# is greater than stack's top ` `        ``# element ` `        ``while``(``len``(st) !``=` `0` `and` `count < k ` `                   ``and` `st[top] < arr[i]): ` `            ``st.pop() ` `            ``count ``+``=` `1` `            ``top ``-``=` `1` ` `  `        ``st.append(arr[i]) ` `        ``top ``+``=` `1` ` `  `    ``# print the remaining elements ` `    ``for` `i ``in` `range``(``0``, ``len``(st)): ` `        ``print``(st[i], ``" "``, end``=``"") ` ` `  `# Driver code ` `k ``=` `2` `arr ``=` `[``20``, ``10``, ``25``, ``30``, ``40``]  ` `deleteElements(arr, ``len``(arr), k) ` ` `  `# This code is contributed by himan085. `

## C#

 `// C# program to delete elements from array. ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `class` `GFG { ` ` `  `    ``// Function for deleting k elements ` `    ``static` `void` `deleteElements(``int` `[]arr, ``int` `n, ``int` `k)  ` `    ``{ ` `        ``// Create a stack and push arr[0] ` `        ``Stack<``int``> s = ``new` `Stack<``int``>(); ` `        ``s.Push(arr[0]); ` ` `  `        ``int` `count = 0; ` ` `  `        ``// traversing a loop from i = 1 to n ` `        ``for` `(``int` `i = 1; i < n; i++) ` `        ``{ ` ` `  `            ``// condition for deleting an element ` `            ``while` `(s.Count != 0 && s.Peek() < arr[i] ` `                    ``&& count < k)  ` `            ``{ ` `                ``s.Pop(); ` `                ``count++; ` `            ``} ` ` `  `            ``s.Push(arr[i]); ` `        ``} ` ` `  `        ``// Putting elements of stack in a vector ` `        ``// from end to begin. ` `        ``int` `m = s.Count; ` `        ``int``[] v = ``new` `int``[m]; ``// Size of vector is m ` `        ``while` `(s.Count != 0)  ` `        ``{ ` ` `  `            ``// push element from stack to vector v ` `            ``v[--m] = s.Peek(); ` `            ``s.Pop(); ` `        ``} ` ` `  `        ``// printing result ` `        ``foreach` `(``int` `x ``in` `v)  ` `        ``{ ` `            ``Console.Write(x + ``" "``); ` `        ``}; ` ` `  `        ``Console.Write(``""``); ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `Main()  ` `    ``{ ` `        ``int` `n = 5, k = 2; ` `        ``int` `[]arr = {20, 10, 25, 30, 40}; ` `        ``deleteElements(arr, n, k); ` `    ``} ` `} ` ` `  `// This code is contributed by 29AjayKumar `

## Javascript

 ``

Output

```25 30 40
```

Time Complexity: O(n)
Auxiliary Space: O(n + m)

Another Approach

In the previous approach, we used a stack that took an extra space. So in this approach, we are not going to use stack.

Here first we will store all elements of the array into a vector. Now we will run a for loop from 0 to (n-2)th index on that vector. So that in the worst case if we have to remove all the first n-1 elements then we can remove that. Now there will be a nested loop in that loop we checks if an element is less than its next element then that element will be deleted.

We have a count variable that is initially initialized to 0 and whenever we delete any element then we will increment the count by 1 and when the count will be equal to “k” then we will stop the loop and print that vector.

Code-

## C++

 `// C++ program to delete elements from array. ` `#include ` `using` `namespace` `std; ` ` `  `// Function for deleting k elements ` `void` `deleteElements(``int` `arr[], ``int` `n, ``int` `k) ` `{  ` `  ``vector<``int``> vec; ` `  ``for``(``int` `i=0;i

## Java

 `import` `java.util.*; ` ` `  `public` `class` `Main { ` `    ``// Function for deleting k elements ` `    ``public` `static` `void` `deleteElements(``int``[] arr, ``int` `n, ` `                                      ``int` `k) ` `    ``{ ` `        ``ArrayList vec = ``new` `ArrayList<>(); ` `        ``for` `(``int` `i = ``0``; i < n; i++) { ` `            ``vec.add(arr[i]); ` `        ``} ` `        ``int` `count = ``0``, i = ``0``; ` `        ``while` `(i < n - ``1``) { ` `            ``int` `ptr = ``0``; ` `            ``for` `(``int` `j = ``1``; j < vec.size(); j++) { ` `                ``if` `(vec.get(ptr) < vec.get(j)) { ` `                    ``count++; ` `                    ``vec.remove(ptr); ` `                    ``break``; ` `                ``} ` `                ``else` `{ ` `                    ``ptr++; ` `                ``} ` `            ``} ` `            ``if` `(count == k) { ` `                ``break``; ` `            ``} ` `            ``i++; ` `        ``} ` `        ``// printing result ` `        ``for` `(``int` `x : vec) { ` `            ``System.out.print(x + ``" "``); ` `        ``} ` `        ``System.out.println(); ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``int` `n = ``5``, k = ``2``; ` `        ``int``[] arr = { ``20``, ``10``, ``25``, ``30``, ``40` `}; ` `        ``deleteElements(arr, n, k); ` `    ``} ` `}`

## Python3

 `# Python program to delete elements from array. ` `from` `typing ``import` `List` ` `  `# Function for deleting k elements ` `def` `deleteElements(arr: ``List``[``int``], n: ``int``, k: ``int``) ``-``> ``None``: ` `    ``vec ``=` `[] ` `    ``for` `i ``in` `range``(n): ` `        ``vec.append(arr[i]) ` ` `  `    ``count ``=` `0` `    ``i ``=` `0` `    ``while` `i < n``-``1``: ` `        ``ptr ``=` `0` `        ``for` `j ``in` `range``(``1``, ``len``(vec)): ` `            ``if` `vec[ptr] < vec[j]: ` `                ``count ``+``=` `1` `                ``del` `vec[ptr] ` `                ``break` `            ``else``: ` `                ``ptr ``+``=` `1` ` `  `        ``if` `count ``=``=` `k: ` `            ``break` `        ``i ``+``=` `1` ` `  `    ``# printing result ` `    ``for` `x ``in` `vec: ` `        ``print``(x, end``=``" "``) ` ` `  `    ``print``() ` ` `  `# Driver code ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``n ``=` `5` `    ``k ``=` `2` `    ``arr ``=` `[``20``, ``10``, ``25``, ``30``, ``40``] ` `    ``deleteElements(arr, n, k) `

## C#

 `using` `System; ` `using` `System.Collections.Generic; ` ` `  `class` `Program { ` `    ``// Function for deleting k elements ` `    ``public` `static` `void` `deleteElements(``int``[] arr, ``int` `n, ``int` `k) ` `    ``{ ` `        ``List<``int``> vec = ``new` `List<``int``>(); ` `        ``for` `(``int` `j = 0; j < n; j++) { ` `            ``vec.Add(arr[j]); ` `        ``} ` `        ``int` `count = 0, i = 0; ` `        ``while` `(i < n - 1) { ` `            ``int` `ptr = 0; ` `            ``for` `(``int` `j = 1; j < vec.Count; j++) { ` `                ``if` `(vec[ptr] < vec[j]) { ` `                    ``count++; ` `                    ``vec.RemoveAt(ptr); ` `                    ``break``; ` `                ``} ` `                ``else` `{ ` `                    ``ptr++; ` `                ``} ` `            ``} ` `            ``if` `(count == k) { ` `                ``break``; ` `            ``} ` `            ``i++; ` `        ``} ` `        ``// printing result ` `        ``foreach` `(``int` `x ``in` `vec) { ` `            ``Console.Write(x + ``" "``); ` `        ``} ` `        ``Console.WriteLine(); ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `Main(``string``[] args){ ` `        ``int` `n = 5, k = 2; ` `        ``int``[] arr = { 20, 10, 25, 30, 40 }; ` `        ``deleteElements(arr, n, k); ` `    ``} ` `}`

## Javascript

 `function` `deleteElements(arr, n, k) { ` `  ``let vec = []; ` `  ``for` `(let i = 0; i < n; i++) { ` `    ``vec.push(arr[i]); ` `  ``} ` ` `  `  ``let count = 0, ` `    ``i = 0; ` `  ``while` `(i < n - 1) { ` `    ``let ptr = 0; ` `    ``for` `(let j = 1; j < vec.length; j++) { ` `      ``if` `(vec[ptr] < vec[j]) { ` `        ``count++; ` `        ``vec.splice(ptr, 1); ` `        ``break``; ` `      ``} ``else` `{ ` `        ``ptr++; ` `      ``} ` `    ``} ` `    ``if` `(count == k) { ` `      ``break``; ` `    ``} ` `    ``i++; ` `  ``} ` ` `  `  ``// printing result ` `  ``console.log(vec.join(``" "``)); ` `} ` ` `  `// Driver code ` `let n = 5, ` `  ``k = 2; ` `let arr = [20, 10, 25, 30, 40]; ` `deleteElements(arr, n, k); `

Output

```25 30 40
```

Time Complexity: O(n2),because of nested for loops
Auxiliary Space: O(n),because of vector

Previous
Next