Problem:
Doubly Linked List

Your task is to implement a double linked list.

Write a program which performs the following operations:

insert x: insert an element with key x into the front of the list.

delete x: delete the first element which has the key of x from the list. If there is not such element, you need not do anything.

deleteFirst: delete the first element from the list.

deleteLast: delete the last element from the list.

Input

The input is given in the following format:

n

command1

command2

...

commandn

In the first line, the number of operations n is given. In the following n lines, the above mentioned operations are given in the following format:

insert x

delete x

deleteFirst

deleteLast

Output

Print all the element (key) in the list after the given operations. Two consequtive keys should be separated by a single space.

Constraints

The number of operations ≤ 2,000,000

The number of delete operations ≤ 20

0 ≤ value of a key ≤ 109

The number of elements in the list does not exceed 106

For a delete, deleteFirst or deleteLast operation, there is at least one element in the list.

Sample Input 1

7
insert 5
insert 2
insert 3
insert 1
delete 3
insert 6
delete 5

Sample Output 1

6 1 2

Sample Input 2

9
insert 5
insert 2
insert 3
insert 1
delete 3
insert 6
delete 5
deleteFirst
deleteLast

Sample Output 2

1

Solution in C (judge verdict: Accepted)

#include <stdio.h>
#include <stdlib.h>
 
typedef struct LLIST LList;
struct LLIST {
  LList *prev, *next;
  int v;
};

void add(LList *prev, LList *e);
void removeElem(LList *e);
LList *findElem(LList *root, int v);
void printList(LList *root);



int main(int argc, char *argv[]) {
  int n;
  char s[16];
  scanf("%d", &n);
  LList root;
  root.next = &root;
  root.prev = &root;
 
  for (int i = 0; i < n; i++) {
    scanf("%s", s);
    if (s[0] == 'i') {
      LList *e = malloc(sizeof(LList));
      scanf("%d", &e->v);
      add(&root, e);
    } else if (s[0] == 'd') {
      if (s[6] == 'F') {
        removeElem(root.next);
      } else if (s[6] == 'L') {
        removeElem(root.prev);
      } else {
        int v;
        scanf("%d", &v);
        LList *e = findElem(&root, v);
        if (e) {
          removeElem(e);
        }
      }
    }
  }
  printList(&root);
  return 0;
}

void add(LList *prev, LList *e) {
  e->next = prev->next;
  e->prev = prev;
  prev->next->prev = e;
  prev->next = e;
}

void removeElem(LList *e) {
  LList *prev = e->prev, *next = e->next;
  prev->next = next;
  next->prev = prev;
  free(e);
}


LList *findElem(LList *root, int v) {
  LList *p = root->next;
  while (p != root) {
    if (p->v == v) return p;
    p = p->next;
  }
  return NULL;
}


void printList(LList *root) {
  LList *p = root->next;
  while (p != root) {
    printf("%d", p->v);
    p = p->next;
    if (p != root) putchar(' ');
  }
  putchar('\n');
}