构建栈和队列

栈的头文件Stack.h
#pragma once

#include<stdio.h>
#include<windows.h>
#include<assert.h>

#define SInitsize 2  //栈初始分配内存
#define SExpend 4   //栈扩大增量

typedef int DataType;

typedef struct Stack
{
DataType* _array;
size_t _top;//栈顶
size_t _base;//栈底

}Stack;

// 栈的实现接口
void StackInit(Stack* s);//栈的初始化
void StackPush(Stack* s, DataType x);//入栈
void StackPop(Stack* s); //出栈
DataType StackTop(Stack* s); //求栈顶元素
size_t StackSize(Stack* s);//栈的长度
int StackEmpty(Stack* s); //判断是否为空栈

Stack.c
#define  _CRT_SECURE_NO_WARNINGS 1

#include"Stack.h"

void StackInit(Stack* s)//栈的初始化
{
assert(s);
s->_array = (DataType *)malloc(SInitsize * sizeof(DataType));
if (!s->_array)
{
printf("malloc failure\n");
}
s->_base = SInitsize;
s->_top = 0;
}
void StackPush(Stack* s, DataType x)//入栈
{
assert(s);
if (s->_top == s->_base)
{
s->_array = (DataType *)realloc(s->_array, (SInitsize + SExpend)*sizeof(DataType));
if (!s->_array)
{
printf("malloc failure\n");
}
s->_base = SInitsize + SExpend;
}
s->_array[s->_top++] = x;
}
void StackPop(Stack* s)//出栈
{
assert(s);
if (s->_top > 0)
{
--s->_top;
}
}
DataType StackTop(Stack* s)//求栈顶元素
{
assert(s);
return s->_array[s->_top - 1];
}
size_t StackSize(Stack* s)//栈的长度
{
assert(s);
return s->_top;
}
int StackEmpty(Stack* s) //判断是否为空栈
{
assert(s);
if (s->_top == 0)
{
return 0;
}
return 1;
}

Queue.h

#pragma once

#include<stdio.h>
#include<windows.h>
#include<assert.h>

typedef int DataType;

typedef struct QueueNode
{
DataType _data;
struct QueueNode* _next;
}QueueNode;

typedef struct Queue
{
QueueNode* _head;
b4fc

QueueNode* _tail;
}Queue;

void QueueInit(Queue* q);//队列的初始化
void QueuePush(Queue* q, DataType x);//队列的插入
void QueuePop(Queue* q);//队列删除
DataType QueueFront(Queue* q);//返回队列头
DataType QueueBack(Queue* q);//返回队列尾
size_t QueueSize(Queue* q);//队列的长度
int QueueEmpty(Queue* q);//判断队列是否为空

Queue.c

#define  _CRT_SECURE_NO_WARNINGS 1
#include"Queue.h"

void QueueInit(Queue* q)
{
assert(q);
q->_head = NULL;
q->_tail = NULL;
}
void QueuePush(Queue* q, DataType x)
{
QueueNode *node = NULL;
node = (QueueNode *)malloc(sizeof(QueueNode));
assert(node);
node->_data = x;
node->_next = NULL;
if (q->_tail == NULL)//队列为空时
{
q->_head = q->_tail = node;
}
else//队列不为空时
{
q->_tail->_next = node;
q->_tail = node;
}
}
void QueuePop(Queue* q)
{
assert(q);
QueueNode * next = NULL;
if (q->_head == q->_tail)
{
if (q->_head)
{
free(q->_head);
q->_head = q->_tail = NULL;
}
}
else
{
next = q->_head->_next;
free(q->_head);
q->_head = next;
}

}
DataType QueueFront(Queue* q)
{
assert(q);
return q->_head->_data;
}
DataType QueueBack(Queue* q)
{
assert(q);
return q->_tail->_data;
}
size_t QueueSize(Queue* q)
{
assert(q);
size_t size = 0;
QueueNode *cur = NULL;
cur = q->_head;
while (cur != NULL)
{
size++;
cur = cur->_next;
}
return size;
}
int QueueEmpty(Queue* q)
{
assert(q);
return q->_head == NULL ? 0 : 1;
}

#define  _CRT_SECURE_NO_WARNINGS 1
#include"Stack.h"
#include"Queue.h"

Test1()
{
Stack s;
StackInit(&s);
StackPush(&s, 1);
StackPush(&s, 2);
StackPush(&s, 3);
StackPush(&s, 4);
while (StackEmpty(&s))
{
printf("%d ", StackTop(&s));
StackPop(&s);
}
printf("\n");

}
Test2()
{
Queue q;
QueueInit(&q);
QueuePush(&q, 1);
QueuePush(&q, 2);
QueuePush(&q, 3);
QueuePush(&q, 4);
printf("队列的长度为：%d\n", QueueSize(&q));
while (QueueEmpty(&q))
{
printf("%d ", QueueFront(&q));
QueuePop(&q);
}
printf("\n");

}

int main()
{
Test1();
Test2();
system("pause");
return 0;
}