栈和队列的实现

栈的实现

1.结构的定义和一些基本函数的命名

使用typedef，使栈的数据类型具有多样性

typedef int stackdate;
typedef struct stack
{
	stackdate* p;
	int top;
	int cy;
}stack;
stack* stackinit();
void stackpush(stack* pc, stackdate x);
void stackdestroy(stack* pc);
void stackpop(stack* pc);
int stacksize(stack* pc);
bool stackempty(stack* pc);
stackdate stacktop(stack* pc);

2.函数的实现

栈与顺序表类似，大多数函数的实现和顺序表大致相同

stack* stackinit()
{
	stack* pc=(stack*)malloc(sizeof(stack));
	pc->p = NULL;
	pc->cy = 0;
	pc->top = 0;
	return pc;
}
void stackdestroy(stack* pc)
{
	assert(pc);;
	free(pc->p);
	pc->p = NULL;
	pc->cy = 0;
	pc->top = 0;
}
void stackpush(stack* pc, stackdate x)
{
	assert(pc);
	if (pc->top == pc->cy)
	{
		int newcy = pc->cy == 0 ? 4 : pc->cy * 2;
		stackdate* temp = (stackdate*)realloc(pc->p, sizeof(stackdate) * newcy);
		if (temp == NULL)
		{
			perror("stackpush");
			exit(-1);
		}
		pc->p = temp;
		pc->cy = newcy;
	}
	pc->p[pc->top] = x;
	pc->top++;
}
void stackpop(stack* pc)
{
	assert(pc);
	assert(pc->top);
	pc->top--;
}
int stacksize(stack* pc)
{
	assert(pc);
	return pc->top;
}
bool stackempty(stack* pc)
{
	assert(pc);
	return pc->top == 0;
}
stackdate stacktop(stack* pc)
{
	assert(pc);
	assert(pc->top);
	return pc->p[pc->top - 1];
}

队列的实现

1.结构的定义和一些基本函数的命名

使用typedef，使队列的数据类型具有多样性

在定义一个结构体进行结构体的嵌套，利用第二个结构体去实现和维护queue的功能

typedef int queuedate;
typedef struct queuenode
{
	struct queuenode* next;
	queuedate date;
}queuenode;
typedef struct que
{
	queuenode* head;
	queuenode* tail;
	int size;
}que;
void queueinit(que* pc);
void queuedestroy(que* pc);
void queuepushback(que* pc, queuedate x);
void queuepop(que* pc);
bool queueempty(que* pc);
queuedate queuefront(que* pc);
queuedate queueback(que* pc);
int queuesize(que* pc);

2.函数的实现

使用链表的结构去实现

void queueinit(que* pc)
{
	assert(pc);
	pc->head = pc->tail = NULL;
	pc->size = 0;
}
void queuepushback(que* pc, queuedate x)
{
	assert(pc);
	queuenode* newnode = (queuenode*)malloc(sizeof(queuenode));
	if (newnode == NULL)
	{
		perror("queeupushback");
		exit(-1);
     }
	newnode->date = x;
	newnode->next = NULL;
	if (pc->tail == NULL)
		pc->head = pc->tail = newnode;
	else
	{
		pc->tail->next = newnode;
		pc->tail = newnode;
	}
	pc->size++;
}
bool queueempty(que* pc)
{
	return pc->size == 0;
}
void queuepop(que* pc)
{
	assert(pc);
	assert(!queueempty(pc));
	queuenode* next = pc->head->next;
	if (next == NULL)
	{
		pc->head = pc->tail = NULL;
		
     }
	else {
		free(pc->head);
		pc->head = next;
	}
	pc->size--;
}
queuedate queuefront(que* pc)
{
	assert(pc);
	assert(!queueempty(pc));
	return pc->head->date;
}
queuedate queueback(que* pc)
{
	assert(pc);
	assert(!queueempty(pc));
	return pc->tail->date;
}
int queuesize(que* pc)
{
	assert(pc);
	return pc->size;
}
void queuedestroy(que* pc)
{
	assert(pc);
	queuenode* cur = pc->head;
	while (cur)
	{
		queuenode* next = cur->next;
		free(cur);
		cur = next;
	}
	pc->head = pc->tail = NULL;
	pc->size = 0;
}

总结

栈和队列都可以用顺序表和链表实现，但大多数来说，栈一般用顺序表，队列用链表去实现，

牢记栈先进后出，队列先进先出