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<string.h>

#define MAXLEN 1000000

struct sDLL {
    int key;
    int pre;
    int next;
};

int ghead, gtail, gemhead, gemtail, gcnt;
struct sDLL list[MAXLEN+1];

void dllOperation( char *command, int key )
{
	int i;
	int pre;

   	if( 0 == strcmp( "insert", command ) ) {
   		pre=ghead;
		if( gcnt <= (ghead+1) && gcnt < MAXLEN ) {
			ghead=gcnt++;
		} else {
			ghead=gemhead;
			gemhead=list[gemhead].next;
			 if( -1 == gemhead ) {
				gemtail=-1;
			}
		}
		
		if( -1 == pre ) {
   			gtail=0;		
		} else {
   			list[pre].pre=ghead;
   		}
   		list[ghead].key=key;
		list[ghead].pre=-1;
		list[ghead].next=pre;
   	} else if( 0 == strcmp( "delete", command ) ) {
    	i=ghead;
	   	while( -1 != i  ) {
	   		if( key == list[i].key ) {
	   			if( ghead == i ) {
	   				ghead = list[i].next;
                    list[ghead].pre=-1; 
	   			} else if( gtail == i ) {
	   				gtail=pre;
	   				list[gtail].next=-1;
	   			} else {
					list[pre].next = list[i].next;
	   				list[ list[i].next ].pre=list[i].pre;
	   			}
				if( -1 == gemtail ) {
					gemhead=i;
				} else {
					list[gemtail].next=i;
				}
				list[i].pre=gemtail;
				gemtail=i;	
				list[gemtail].next=-1;
	   			break;
	   		}
	   		pre=i;
	   		i=list[i].next;
	   	}
   	} else if( 0 == strcmp( "deleteFirst", command ) ) {

      	if( -1 == gemtail ) {
      		gemhead=ghead;
      	} else {
			list[gemtail].next=ghead;
		}
		list[ghead].pre=gemtail;
		gemtail=ghead;
		
		ghead=list[ghead].next;
 		if( -1 == ghead ) {
			gtail=-1;
		} else {
		   	list[ghead].pre=-1;
		}
 		
   		list[gemtail].next=-1;  		   		
   	} else {
   		if( -1 == gemtail ) {
			gemhead=gtail;
		} else {
			list[gemtail].next=gtail;
		}
   		pre=list[gtail].pre;
		list[gtail].pre=gemtail;
		gemtail=gtail;
		
		list[gemtail].next=-1;
		gtail=pre;
		if( -1 == pre ) {
			ghead=-1;
		} else {
			list[gtail].next=-1;	
		}	
   	}

	return;
}   	

int main( void ) 
{
    int i;
    int n;
    char command[12];
    int key;
     
    scanf( "%d", &n );
    gemhead=gemtail=ghead=gtail=-1;
    gcnt=0;
    for( i=0; i<n; i++ ) {
        scanf( "%s", command );
        if( 0 == strcmp( "deleteFirst", command ) ) {
        	key=0;        
        } else if( 0 == strcmp( "deleteLast", command ) ) {
        	key=0;
        } else {
        	scanf( "%d", &key );
        }
        dllOperation( command, key );
    }
    

    i=ghead;
    while( -1 != i ) {
      	printf( "%d", list[i].key );
       	if( -1 == (i=list[i].next) ) {
     		break;
     	} else {
     		printf( " " );
     	}
    }
	printf( "\n" );
	
	return 0;
}