스 택 과 대기 열의 데이터 구조 와 관련 작업 총화

창고 작업
1. 스 택 구조의 순서 저장 정의:

typedef struct Sqstack{
	int data[MAXSIZE];
	int top; //top            
};

스 택 작업:

#define OK 1;
#define ERROR 0;
#define MAXSIZE 20;
int Push(Sqstack *s, int e){
	if (s->top == MAXSIZE - 1)  //  
		return ERROR;
	s->top++;
	s->data[s->top] = e;
	return OK;
}

창고 출하 작업;

int Pop(Sqstack *s, int *e){
	if (s->top == -1) //  
		return ERROR;
	*e = s->data[s->top]；
		s->top--;
	return OK;
}

두 스 택 공유 공간 (즉, 두 개의 top 포인터 로 하나의 배열 공간 을 공유 합 니 다)

typedef struct Sqdoublestack{
	int data[MAXSIZE];
	int top1;
	int top2;
};

나머지 조작 은 유사 하 며, top 1 과 top 2 의 중첩 여 부 를 판별 하면 된다.
2. 스 택 의 체인 저장 구조

typedef struct StackNode{   //       
	int data;
	struct StackNode *next;
}*LinkPtr; 
typedef struct LinkStack{  //      
	LinkPtr top;  //      top
	int count;   //     ；
};

창고 에 넣다

nt Push(LinkStack *s, int e){
	LinkPtr p = (LinkPtr)malloc(sizeof(StackNode));
	if (!p)
		exit(OVERFLOW);  //   
	p->data = e;
	p->next = s->top;
	s->top = p;
	s->count++;
	return OK;

창고 에서 나오다

int Pop(Linkstack *s, int *e){
	LinkPtr p;
	if (s->top == NULL)  //  
		return ERROR;
	*e = s->top->data;
	p = s->top;
	s->top = p->next;
	free(p);
	s->count--;
	return OK;
}

2. 순환 대기 열의 조작
순환 대기 열 은 저장 공간 이 뒤쪽 위치 에서 가득 찬 후에 앞의 빈 위치 로 순환 적 으로 저장 할 수 있 는 대기 열 입 니 다.따라서 머리 와 꼬리 를 가리 키 는 두 개의 지침 이 필요 하 다.
1. 순서 저장 구조 정의:

//           
typedef struct SqQueue{
	int data[MAXSIZE];
	int front; //            ,         
	int rear; //                   ，          
};

초기 화:

#define OK 1;
#define ERROR 0;
#define MAXSIZE 20;
//     
int IniQueue(SqQueue *Q){
	Q->front = 0;
	Q->rear = 0;
	return OK;

대기 열 진입:

int EnQueue(SqQueue *Q, int e){
	if((Q->rear+1)%MAXSIZE==Q->front)  //   
		return ERROR;
	Q-data[Q-rear]=e;
	Q->rear=(Q->rear+1)%MAXISIZE;
	return OK;

대기 열:

int DeQueue(SqQueue *Q, int *e){
	if (Q->front==Q->rear) //   
		return ERROR;
	*e=Q->data[Q-front]；
	Q->front=(Q->front+1)%MASIZE;
	return OK;
}

2. 체인 대기 열 구조 정의

typedef struct QNode{   //        
	int data;
	struct QNode *next;
}*QPtr; 
typedef struct LinkQueue{  //        
	QPtr front;  //   front         ，     data  
	QPtr rear;   //   rear             ，            
};

대기 열 입력:

int EnQueue(LinkQueue *Q, int e){
	QPtr p = (QkPtr)malloc(sizeof(QNode));
	if (!p)
		exit(OVERFLOW);  //   
	p->data = e;
	Q->rear->next=p;  //                 
	Q->rear = p;   // rear      
	p->next=NULL;
	return OK;

출력 대기 열:

int DeQueue(LinkQueue *Q, int *e){
	QPtr p;
	if (Q->front == Q->rear)  //   
		return ERROR;
	p = Q->front->next;
	*e = p->data;
	Q->front->next=p->next;
	if (Q->rear == p)
		Q->rear = Q->front;  //       ，    ，     ，  rear     
	free(p);
	return OK;
}