PTA笔记 Data Structures and Algorithms (English) 6-1 Deque (25 分)

**PTA笔记 Data Structures and Algorithms (English) 6-1 Deque (25 分) **

• 实际上就是完成一个双端队列的插入和删除

• 双端队列定义的初始化状态图解
  

• EmptyNode是个哑节点，不含任何信息

• Front永远指向哑节点。

• Rear永远指向链表中的最后一个节点

• 当Front和Rear同时指向哑节点的时候表示双端队列为空

• 双端队列定义的含有元素的状态
  

• 双端队列的插入和删除本质上就是对双向链表的操作

• 实现代码

#define ElementType int
#define ERROR 1e5
typedef enum {
    
     push, pop, inject, eject, end } Operation;

typedef struct Node *PtrToNode;
struct Node {
    
    
    ElementType Element;
    PtrToNode Next, Last;
};
typedef struct DequeRecord *Deque;
struct DequeRecord {
    
    
    PtrToNode Front, Rear;
};
Deque CreateDeque();
int Push( ElementType X, Deque D );
ElementType Pop( Deque D );
int Inject( ElementType X, Deque D );
ElementType Eject( Deque D );

Deque CreateDeque(){
    
    
	//这里对双端队列定义，设置一个空节点，作为头数据节点的之前的首节点，
	Deque deq = (Deque)malloc(sizeof(struct DequeRecord));
	//专用的空节点 
	PtrToNode node_empty = (PtrToNode)malloc(sizeof(struct Node));

	deq->Front = node_empty;
	deq->Rear = node_empty;
	
	node_empty->Last = NULL;
	node_empty->Next = NULL;

	return deq; 
}


int Push( ElementType X, Deque D ){
    
     
	//赋值 
	PtrToNode newNode = (PtrToNode)malloc(sizeof(struct Node));
	newNode->Element = X;	
	//定位空节点
	PtrToNode node_empty = D->Front; 	
	//先判断此时是否为空 
	if(D->Front == D->Rear){
    
    
		newNode->Last = node_empty;
		newNode->Next = node_empty->Next;
		
		node_empty->Next = newNode; 
		
		D->Rear = newNode; 
		
		return 1;
	}else{
    
    		
		PtrToNode P = node_empty->Next;
		
		newNode->Last = node_empty;
		newNode->Next = P;
		
		P->Last = newNode;
		node_empty->Next = newNode;
		  
		return 1;		
	}
	return 1; 	 
}


ElementType Pop( Deque D ){
    
    
	//判空
	if(D->Front == D->Rear){
    
    
		return ERROR;
	}
	
	PtrToNode node_empty = D->Front;
	PtrToNode P = node_empty;
	
	ElementType x = P->Element;
	
	//已经空 
	if(P->Next == NULL){
    
    
		node_empty->Next = NULL;
		D->Rear = node_empty; 
	}else{
    
    
		node_empty->Next = P->Next;
		PtrToNode P2 = P->Next;
		P2->Last = node_empty; 
	}
	
	free(P);
	return x; 

}


int Inject( ElementType X, Deque D ){
    
    
	//赋值 
	PtrToNode newNode = (PtrToNode)malloc(sizeof(PtrToNode));
	newNode->Element = X;
	
	//插入节点
	PtrToNode R = D->Rear;
	R->Next = newNode;
	newNode->Last = R; 
	
	D->Rear = newNode;
	
	return 1; 

}

ElementType Eject( Deque D ){
    
    
	//判空
	if(D->Front == D->Rear){
    
    
		return ERROR;
	}

	PtrToNode R = D->Rear; 
	ElementType x = R->Element;
	
	PtrToNode preR = R->Last;
	preR->Next = NULL;
	
	D->Rear = preR; 
	
	free(R);
	return x;
	
}