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 MAX_COMMAND_NUM 2000000
#define MAX_LIST_NUM 1000000

typedef struct ST_LinkedList LinkedList_t;

struct ST_LinkedList{
    int           key_value;     /* Key Value */
    LinkedList_t  *before;       /* Before Point */
    LinkedList_t  *next;         /* Next Point */
}LINKED_LIST;

LinkedList_t tLinkedListBuffer[MAX_COMMAND_NUM];

int main(void)
{
    int  cn;					/* Command Num */
	char command[12];			/* Command Name */
	int  kv;					/* Key Value */
	int  ln = 0;				/* List Num */
	int  loop = 0;
	
    LinkedList_t *ptLinkedListFirst;     /* List First Pointer */
    LinkedList_t *ptLinkedListLast;      /* List Last  Pointer */
    LinkedList_t *ptLinkedListNow;       /* List Now   Pointer */
    LinkedList_t *ptLinkedListSwap;      /* List Swap  Pointer */
	
	/* initilize data */
	ptLinkedListFirst = NULL;
	ptLinkedListLast  = NULL;
	tLinkedListBuffer[0].next   = NULL;
	tLinkedListBuffer[0].before = NULL;
	
	/* get "Command Num" */
    scanf("%d", &cn);
    
	if(cn <= MAX_COMMAND_NUM)
	{
        /* get Name & time */
        while((scanf("%s %d", &(command[0]), &kv) != EOF) && loop < cn)
        {
        	if( strcmp(command, "insert") == 0 ) /* Insert Process */
        	{
        		tLinkedListBuffer[ln].key_value = kv; /* Insert at the beginning of the list */
        		tLinkedListBuffer[ln].before = ptLinkedListFirst;
        		tLinkedListBuffer[ln].next = NULL;
        		
        		if(ptLinkedListFirst != NULL) /* One or more data */
        		{
	        		ptLinkedListFirst->next = &(tLinkedListBuffer[ln]);
        		}
        		else /* None Input Data */
        		{
        			ptLinkedListLast = &(tLinkedListBuffer[ln]);
        		}
	        	ptLinkedListFirst = &(tLinkedListBuffer[ln]); /* Set First List Input */
	        	ln++;
            }
        	else if( strcmp(command, "delete") == 0 && ptLinkedListFirst != NULL ) /* Delete Process */
        	{
        		if(ptLinkedListFirst->key_value == kv) /* If deleate First List Input */
        		{
        			ptLinkedListFirst = ptLinkedListFirst->before;
        			ptLinkedListFirst->next = NULL;
        		}
        		else
        		{
	        		ptLinkedListNow = ptLinkedListFirst->before;
	        		while(ptLinkedListNow != ptLinkedListLast)
	        		{
	        			if(ptLinkedListNow->key_value == kv)
	        			{
	        				/* change next pointer */
	        				ptLinkedListSwap = ptLinkedListNow->before;
	        				ptLinkedListSwap->next = ptLinkedListNow->next;
	        				/* change before pointer */
	        				ptLinkedListSwap = ptLinkedListNow->next;
	        				ptLinkedListSwap->before = ptLinkedListNow->before;
	        				break;
	        			}
	        			ptLinkedListNow = ptLinkedListNow->before;
	        		}
	        		if(ptLinkedListNow == ptLinkedListLast && ptLinkedListLast->key_value == kv) /* If delete Last List Input */
	        		{
	        			ptLinkedListLast = ptLinkedListLast->next;
	        			ptLinkedListLast->before = NULL;
	        		}
        		}
        		
            }
        	else if( strcmp(command, "deleteFirst") == 0 ) /* Delete First Process */
        	{
        		if(ptLinkedListFirst->before != NULL)
        		{
	        		ptLinkedListFirst = ptLinkedListFirst->before;
	        		ptLinkedListFirst->next = NULL;
        		}
        		else
        		{
        			ptLinkedListFirst = NULL;
        			ptLinkedListLast = NULL;
        		}
            }
        	else if( strcmp(command, "deleteLast") == 0 ) /* Delete Last Process */
        	{
        		if(ptLinkedListLast->next != NULL)
        		{
	        		ptLinkedListLast = ptLinkedListLast->next;
	        		ptLinkedListLast->before = NULL;
        		}
        		else
        		{
        			ptLinkedListFirst = NULL;
        			ptLinkedListLast = NULL;
        		}
            }
        	else
        	{
        		/* error command */
        	}
        	loop++;
        }
		
		ptLinkedListNow = ptLinkedListFirst;
		/* print result */
		while(ptLinkedListNow != ptLinkedListLast)
		{
			printf("%d ", ptLinkedListNow->key_value);
			ptLinkedListNow = ptLinkedListNow->before;
		}
		printf("%d\n", ptLinkedListNow->key_value);
	}
    else
    {
        /* error input */
    }
     
    return 0;
}