Deque Deletion

Given a Deque d containing non-negative integers.

Complete below functions depending type of query as mentioned and provided to you (indexing starts from 0):
1. eraseAt(x): this function should remove the element from specified position x in deque.
2. eraseInRange(start, end): this function should remove the elements in range start (inclusive), end (exclusive) specified in the argument of the function.
Note: If start is equal to end then simply return.
3. eraseAll(): remove all the elements from the deque.

Examples:

Input: d = [1 2 4 5 6], eraseAt(2)
Output: 1 2 5 6
Explanation: We remove element at position 2. The element at position 2 is 1 2 4 5 6. So, we remove 4 and get 1 2 5 6.
Input: d = [1 2 3 4], eraseInRange(1, 3)
Output: 1 4
Explanation: Remember that end is exclusive. So the updated deque is 1 4.

C++

#include <deque>
#include <iostream>
using namespace std;

void eraseAt(deque<int> &d, int x)
{
    deque<int>::iterator itr;
    itr = d.begin() + x;
    d.erase(itr);
}

void eraseInRange(deque<int> &d, int start, int end)
{
    deque<int>::iterator itr1, itr2;
    itr1 = d.begin() + start;
    itr2 = d.begin() + end;
    d.erase(itr1, itr2);
}

void eraseAll(deque<int> &d)
{
    d.clear();
}

int main()
{
    deque<int> d = {1, 2, 4, 5, 6};

    eraseInRange(d, 1, 2);

    for (int i = 0; i < d.size(); i++)
    {
        cout << d[i] << " ";
    }
    cout << endl;

    return 0;
}

Java

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.Iterator;

public class GfG {
    public static void eraseAt(Deque<Integer> d, int x) {
        Iterator<Integer> itr = d.iterator();
        int index = 0;
        while (itr.hasNext()) {
            if (index == x) {
                itr.remove();
                break;
            }
            itr.next();
            index++;
        }
    }

    public static void eraseInRange(Deque<Integer> d, int start, int end) {
        for (int i = 0; i < end - start; i++) {
            eraseAt(d, start);  
        }
    }

    public static void eraseAll(Deque<Integer> d) {
        d.clear();
    }

    public static void main(String[] args) {
        Deque<Integer> d = new ArrayDeque<>();
        d.add(1);
        d.add(2);
        d.add(4);
        d.add(5);
        d.add(6);

        eraseAt(d, 2);  

        for (Integer num : d) {
            System.out.print(num + " ");
        }
        System.out.println();  
    }
}

Python

def erase_at(d, x):
    del d[x]

def erase_in_range(d, start, end):
    del d[start:end]


def erase_all(d):
    d.clear()

if __name__ == '__main__':
    d = [1, 2, 4, 5, 6]

    erase_in_range(d, 1, 2)

    for num in d:
        print(num, end=' ')
    print()

using System;
using System.Collections.Generic;

class GfG
{
    static void EraseAt(LinkedList<int> d, int x)
    {
        var node = d.First;
        for (int i = 0; i < x && node != null; i++)
        {
            node = node.Next;
        }

        if (node != null)
        {
            d.Remove(node);
        }
    }

    static void EraseInRange(LinkedList<int> d, int start, int end)
    {
        var node = d.First;
        for (int i = 0; i < start && node != null; i++)
        {
            node = node.Next;
        }

        for (int i = start; i < end && node != null; i++)
        {
            var nextNode = node.Next;
            d.Remove(node);
            node = nextNode;
        }
    }

    static void EraseAll(LinkedList<int> d)
    {
        d.Clear();
    }

    static void Main()
    {
        LinkedList<int> d = new LinkedList<int>(new[] { 1, 2, 4, 5, 6 });

        EraseInRange(d, 1, 2); 

        foreach (var item in d)
        {
            Console.Write(item + " ");
        }
        Console.WriteLine();  
    }
}

JavaScript

function eraseAt(d, x) {
    d.splice(x, 1);
}

function eraseInRange(d, start, end) {
    d.splice(start, end - start);
}

function eraseAll(d) {
    d.length = 0;
}

const d = [1, 2, 4, 5, 6];

eraseInRange(d, 1, 2);

for (let i = 0; i < d.length; i++) {
    console.log(d[i] + " ");
}
console.log();

Output

1 4 5 6

eraseAt(deque<int>& d, int x): Time Complexity: O(n), Auxiliary Space: O(1)
eraseInRange(deque<int>& d, int start, int end): Time Complexity: O(n), Auxiliary Space: O(1)
eraseAll(deque<int>& d): Time Complexity: O(n), Auxiliary Space: O(1)

Explore