Open In App

# Delete array elements which are smaller than next or become smaller

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.

Examples:

```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.

## 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(n2)
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