#include<stdio.h>
#include<stdlib.h>
#include <unistd.h>

typedef struct Stack
{
	int *sp;
	int *bp;
	int size;
}Stack;

typedef int Status;
typedef int Bool;

int read_int();
Stack* creat_stack(int size);
Bool is_empty(Stack *s);
Status push(Stack *s, int data);
Status pop(Stack *s, int *reg);
int get_top(Stack *s);
void show(Stack *s);
Status destory(Stack *s);

int read_int()
{
    char buf[8];
    read(0,buf,8);
    return atoi(buf);
}

Stack* creat_stack(int size)
{
	Stack *s = (Stack*)malloc(sizeof(Stack));
	s->bp = (int*)malloc(size*sizeof(int));
	if(s->bp == NULL)
	{
		puts("malloc error");
		return NULL;
	}
	s->sp = s->bp;
	s->size = size;
	return s;
}

Bool is_empty(Stack *s)
{
	return s->bp == s->sp;
}

Status push(Stack *s, int data)
{
	if(s->sp - s->bp == s->size)
	{
		puts("overflow");
		s->bp = (int*)realloc(s->bp,(s->size+1)*sizeof(int));
		if(s->bp == NULL)
		{
			puts("realloc error");
			return 1;
		}
		s->size += 1;
	}
	*s->sp = data;
	s->sp++;
	return 0;
}

Status pop(Stack *s, int *reg)
{
	if(is_empty(s))
	{
		puts("empty");
		return 1;
	}
	s->sp--;
	*reg = *s->sp;
	*s->sp = 0;
	return 0;
}

int get_top(Stack *s)
{
	if(is_empty(s))
	{
		puts("empty");
		return 1;
	}
	return *(s->sp-1);
}

void show(Stack *s)
{
	int *p = s->sp-1;
	while(p != s->bp-1)
	{
		printf("%d ", *p);
		p--;
	}
	puts("");
	return;
}

Status destory(Stack *s)
{
	free(s->bp);
	return 0;
}

int main(int argc, char const *argv[])
{
	Stack *p;
	int reg;
	p = creat_stack(3);
	push(p,1);
	push(p,2);
	push(p,3);
	show(p);
	pop(p,&reg);

	return 0;
}

#include<stdio.h>
#include<stdlib.h>
#include <unistd.h>

typedef struct Queue
{
	int *base;
	int head;
	int tail;
	int size;
	int len;
}Queue;

typedef int Status;
typedef int Bool;

int read_int();
Queue* creat_queue(int size);
Bool is_empty(Queue *q);
Status enter(Queue *q, int data);
Status quit(Queue *q, int *reg);
void show(Queue *q);
Status destory(Queue *q);

int read_int()
{
    char buf[8];
    read(0,buf,8);
    return atoi(buf);
}

Queue* creat_queue(int len)
{
	Queue *q = (Queue*)malloc(sizeof(Queue));
	q->len = len;
	q->size = len + 1;
	q->base = (int*)malloc(q->size*sizeof(int));
	if(q->base == NULL)
	{
		puts("malloc error");
		return NULL;
	}
	q->head = 0;
	q->tail = 0;
	return q;
}

Bool is_empty(Queue *q)
{
	return q->head == q->tail;
}

Status enter(Queue *q, int data)
{
	printf("tail:%d\n",q->tail);
	if((q->tail+1)%q->size == q->head)
	{
		puts("full");
		return 1;
	}
	*(q->base + q->tail) = data;
	q->tail = (q->tail+1)%q->size;
	return 0;
}

Status quit(Queue *q, int *reg)
{
	if(is_empty(q))
	{
		puts("empty");
		return 1;
	}
	*reg = *(q->base + q->head);
	*(q->base + q->head) = 0;
	q->head = (q->head+1)%q->size;
	return 0;
}

void show(Queue *q)
{
	int idx = q->head;
	while(idx != q->tail)
	{
		printf("%d ", *(q->base + idx));
		idx = (idx+1)%q->size;
	}
	puts("");
	return;
}

Status destory(Queue *q)
{
	free(q->base);
	return 0;
}

int main(int argc, char const *argv[])
{
	Queue *p;
	int reg;
	p = creat_queue(3);
	enter(p,1);
	enter(p,2);
	enter(p,3);
	show(p);
	quit(p,&reg);
	printf("%d\n", reg);
	show(p);
	destory(p);
	return 0;
}