1:实现栈和队列
typedef int DataType;
typedef struct Stack
{
DataType* _array;
size_t _top; //栈顶
size_t _end;
}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);
typedef int DataType;
typedef struct QueueNode
{
DataType _data;
struct QueueNode* _next;
}QueueNode;
typedef struct Queue
{
QueueNode* _head;
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);
#include"stack.h"
#define STACKSIZE 5
// 栈的实现接口
void StackInit(Stack* s)
{
assert(s);
s->_array = (DataType*)calloc(STACKSIZE, sizeof(DataType));
s->_top = STACKSIZE ;
s->_end = STACKSIZE ;
}
void StackPush(Stack* s, DataType x)
{
assert(s);
//栈溢出
if (s->_top == 0)
{
printf("栈满\n");
return;
}
s->_top--;
s->_array[s->_top] = x;
}
void StackPop(Stack* s)
{
assert(s);
if (s->_top == s->_end)
{
printf("栈为空\n");
return;
}
s->_top++;
}
DataType StackTop(Stack* s)
{
assert(s);
return (s->_array[s->_top]);
}
size_t StackSize(Stack* s)
{
assert(s);
return (s->_end - (s->_top));
}
int StackEmpty(Stack* s)
{
assert(s);
return (s->_top == s->_end);
}
void PrintStack(Stack* s)
{
size_t i;
assert(s);
for (i = s->_top; i < s->_end; i++)
printf("%d ", s->_array[i]);
printf("\n");
}
void QueueInit(Queue* q)
{
assert(q);
q->_head = NULL;
q->_tail = NULL;
}
QueueNode* BuyNode(DataType d)
{
QueueNode* tmp = (QueueNode*)malloc(sizeof(QueueNode));
if (tmp == NULL)
exit(0);
tmp->_data = d;
tmp->_next = NULL;
return tmp;
}
void QueuePush(Queue* q, DataType x)
{
QueueNode* tmp = BuyNode(x);
assert(q);
if (q->_head == NULL)
{
q->_head = tmp;
q->_tail = tmp;
}
else
{
q->_tail->_next=tmp ;
q->_tail = tmp;
}
}
void QueuePop(Queue* q)
{
QueueNode* del;
assert(q);
if (q->_head == NULL)
{
return;
}
//剩一个结点
else if (q->_head->_next == NULL)
{
free(q->_tail);
q->_tail = NULL;
q->_head = NULL;
}
else
{
del = q->_head;
q->_head = q->_head->_next;
free(del);
del = NULL;
}
}
DataType QueueFront(Queue* q)
{
assert(q);
if (q->_head == NULL)
{
printf("队列空\n");
return 0;
}
return q->_head->_data;
}
DataType QueueBack(Queue* q)
{
assert(q);
if (q->_tail == NULL)
{
printf("队列空\n");
return 0;
}
return q->_tail->_data;
}
size_t QueueSize(Queue* q)
{
QueueNode* cur = q->_head;
size_t ret=0;
assert(q);
while (cur != NULL)
{
ret++;
cur = cur->_next;
}
return ret;
}
int QueueEmpty(Queue* q)
{
assert(q);
return (q->_head == NULL);
}
void PrintfQueue(Queue* q)
{
QueueNode* cur = q->_head;
assert(q);
while (cur != NULL)
{
printf("%d ",cur->_data);
cur = cur->_next;
}
printf("\n");
}