Deque

#include <stdio.h>
#include <stdlib.h>

#define MAX_SIZE 100

// Struct representing a deque
typedef struct {
    int arr[MAX_SIZE];
    int front;
    int rear;
} Deque;

// Function to initialize the deque
void initDeque(Deque* dq) {
    dq->front = -1;
    dq->rear = -1;
}

// Function to check if deque is empty
int isEmpty(Deque* dq) {
    return (dq->front == -1);
}

// Function to check if deque is full
int isFull(Deque* dq) {
    return (dq->rear == MAX_SIZE - 1);
}

// Function to add element at the back
void push_back(Deque* dq, int val) {
    if (isFull(dq)) {
        printf("Deque is full\n");
        return;
    }
    if (dq->front == -1) {
        dq->front = 0;
    }
    dq->arr[++(dq->rear)] = val;
}

// Function to add element at the front
void push_front(Deque* dq, int val) {
    if (isFull(dq)) {
        printf("Deque is full\n");
        return;
    }
    if (dq->front == -1) {
        dq->front = 0;
        dq->rear = 0;
    } else {
        for (int i = dq->rear; i >= dq->front; i--) {
            dq->arr[i + 1] = dq->arr[i];
        }
        dq->arr[dq->front] = val;
        dq->rear++;
    }
}

// Function to remove element from the front
void pop_front(Deque* dq) {
    if (isEmpty(dq)) {
        printf("Deque is empty\n");
        return;
    }
    for (int i = dq->front; i < dq->rear; i++) {
        dq->arr[i] = dq->arr[i + 1];
    }
    dq->rear--;
    if (dq->rear == -1) {
        dq->front = -1;
    }
}

// Function to remove element from the back
void pop_back(Deque* dq) {
    if (isEmpty(dq)) {
        printf("Deque is empty\n");
        return;
    }
    dq->rear--;
    if (dq->rear == -1) {
        dq->front = -1;
    }
}

// Function to print elements of the deque
void printDequeElements(Deque* dq) {
    for (int i = dq->front; i <= dq->rear; i++) {
        printf("\t%d", dq->arr[i]);
    }
    printf("\n");
}

int main() {
    Deque dq;
    initDeque(&dq);

    // Using assign equivalent by adding elements to deque
    int a[] = {1, 2, 3, 4, 5};
    for (int i = 0; i < 5; i++) {
        push_back(&dq, a[i]);
    }

    printf("after using assign: ");
    printDequeElements(&dq);

    // Clearing the deque
    dq.front = dq.rear = -1;

    // Size of deque
    printf("size of deque: %d\n", (dq.front == -1) ? 0 : (dq.rear - dq.front + 1));

    // Using push_back and push_front
    push_back(&dq, 6);
    push_front(&dq, 9);
    push_back(&dq, 23);
    push_front(&dq, 8);

    printf("The deque dq is: ");
    printDequeElements(&dq);

    printf("dq.size(): %d\n", (dq.front == -1) ? 0 : (dq.rear - dq.front + 1));
    printf("dq.front(): %d\n", dq.arr[dq.front]);
    printf("dq.back(): %d\n", dq.arr[dq.rear]);

    // Removing from front and back
    printf("dq.pop_front(): ");
    pop_front(&dq);
    printDequeElements(&dq);

    printf("dq.pop_back(): ");
    pop_back(&dq);
    printDequeElements(&dq);

    return 0;
}

You can also try this code with Online C Compiler

Run Code

#include <bits/stdc++.h>

// C++ header which contains implementation of deque.
#include <deque>
 
using namespace std;
 
void printDequeElements(deque<int> g){
    deque<int>::iterator it;
    for (it = g.begin(); it != g.end(); ++it)
        cout << '\t' << *it;
    cout << '\n';
}

int main(){
    // Declaring a empty deque.
    deque<int>dq;

    // deque::assign()
    vector<int>a = {1, 2, 3, 4, 5};
    dq.assign(a.begin(), a.end());

    cout << "after using assign: ";
    printDequeElements(dq);

    // deque::clear()
    dq.clear();

    // deque::size();
    cout << "size of deque: " << dq.size() << endl;

    // deque::push_back() && deque::push_front()
    dq.push_back(6);
    dq.push_front(9);
    dq.push_back(23);
    dq.push_front(8);
    cout << "The deque dq is : ";
    printDequeElements(dq);
 
    cout << "dq.size() : " << dq.size() << endl;
    // deque::front()
    cout << "dq.front() : " << dq.front() << endl;
    // deque::back()
    cout << "dq.back() : " << dq.back() << endl;
 
    // deque::pop_front()
    cout << "dq.pop_front() : ";
    dq.pop_front();
    printDequeElements(dq);
 
    // deque::pop_back()
    cout << "dq.pop_back() : ";
    dq.pop_back();
    printDequeElements(dq);
}

You can also try this code with Online C++ Compiler

Run Code

import java.util.*;

public class Main {

    // Method to print elements of the deque
    public static void printDequeElements(Deque<Integer> dq) {
        for (Integer elem : dq) {
            System.out.print("\t" + elem);
        }
        System.out.println();
    }

    public static void main(String[] args) {
        // Declaring an empty deque
        Deque<Integer> dq = new ArrayDeque<>();

        // Using assign equivalent by adding elements to deque
        Integer[] a = {1, 2, 3, 4, 5};
        dq.addAll(Arrays.asList(a));

        System.out.print("after using assign: ");
        printDequeElements(dq);

        // Clearing the deque
        dq.clear();

        // Size of deque
        System.out.println("size of deque: " + dq.size());

        // Using push_back (add) and push_front (addFirst)
        dq.addLast(6);
        dq.addFirst(9);
        dq.addLast(23);
        dq.addFirst(8);

        System.out.print("The deque dq is: ");
        printDequeElements(dq);

        System.out.println("dq.size(): " + dq.size());
        System.out.println("dq.front(): " + dq.peekFirst());
        System.out.println("dq.back(): " + dq.peekLast());

        // Removing from front and back
        System.out.print("dq.pop_front(): ");
        dq.pollFirst();
        printDequeElements(dq);

        System.out.print("dq.pop_back(): ");
        dq.pollLast();
        printDequeElements(dq);
    }
}

You can also try this code with Online Java Compiler

Run Code

from collections import deque

# Function to print elements of deque
def print_deque_elements(dq):
    for elem in dq:
        print(f'\t{elem}', end="")
    print()

# Main function
def main():
    # Declaring an empty deque
    dq = deque()

    # Using assign equivalent by adding elements to deque
    a = [1, 2, 3, 4, 5]
    dq.extend(a)

    print("after using assign: ", end="")
    print_deque_elements(dq)

    # Clearing the deque
    dq.clear()

    # Size of deque
    print("size of deque:", len(dq))

    # Using push_back (append) and push_front (appendleft)
    dq.append(6)
    dq.appendleft(9)
    dq.append(23)
    dq.appendleft(8)

    print("The deque dq is:", end=" ")
    print_deque_elements(dq)

    print(f"dq.size(): {len(dq)}")
    print(f"dq.front(): {dq[0]}")
    print(f"dq.back(): {dq[-1]}")

    # Removing from front and back
    print("dq.pop_front():", end=" ")
    dq.popleft()
    print_deque_elements(dq)

    print("dq.pop_back():", end=" ")
    dq.pop()
    print_deque_elements(dq)

if __name__ == "__main__":
    main()

You can also try this code with Online Python Compiler

Run Code