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 _node{
	struct _node *prev;
	struct _node *next;

	int val;

}Node;


void insert(Node **head, Node **tail,  int val ){

	Node *ptr;


	ptr = (Node*)malloc(sizeof(Node));
	ptr->val = val;

	ptr->prev = NULL;
	ptr->next = *head;

	if( *head != NULL ) {
		(*head)->prev = ptr;
		*head = ptr;
	}else{
		*head = ptr;
		*tail = ptr;
	}
	
}

void delete_first( Node **head, Node **tail ){
	
	Node *ptr = *head;

	if( ptr->next != NULL ){
		ptr->next->prev = NULL;
		*head = ptr->next;
	}else{
		*head = NULL;
		*tail = NULL;
	}

	free(ptr);
}


void delete_last( Node **head, Node **tail ){

	Node *ptr = *tail;

	if( ptr->prev != NULL ){
		ptr->prev->next = NULL;
		*tail = ptr->prev;
	}else{
		*head = NULL;	
		*tail = NULL;
	}
	free( ptr );
}

void delete(Node **head, Node **tail, int val ){

	Node *ptr = *head;
	if(*head == NULL) return;

	//Seek for matching node
	while( ptr->next!=NULL && ptr->val!=val  )
		ptr = ptr->next;

	// delete
	if( ptr->val == val ){

		if( ptr->next == NULL ){
			delete_last(head, tail);
		}else if( ptr->prev == NULL ){
			delete_first(head, tail);
		}else{
			ptr->prev->next = ptr->next;
			ptr->next->prev = ptr->prev;
			free(ptr);
		}
	}
}





void print( Node * node ){

		
	if(node==NULL) return;
	
	do{
		printf( "%d%c", node->val, (node->next!=NULL)?' ':'\n' );
		node  = node->next;
	}while( node != NULL  );
}

int main( ){

	int i, n, val;
	char cmd[33];
	Node *head=NULL, *tail=NULL;
	

	scanf( "%d\n", &n );
	
	for( i=0; i<n; i++ ){
		fgets( cmd, sizeof(cmd), stdin );

		if( cmd[0]=='d' && cmd[6]=='F' ){
			delete_first( &head, &tail );
		}
		else if( cmd[0]=='d' && cmd[6]=='L' ){
			delete_last( &head, &tail );
		}
		else if( cmd[0] == 'd' ){
			val = atoi( &cmd[7] );
			delete( &head, &tail, val );
		}
		if( cmd[0]=='i' ){
			val = atoi( &cmd[7] );
			insert( &head, &tail, val );
		}
	}

	print(head);
	
	return 0;
}