数据结构_栈和队列

栈

typedef int DataType;

typedef struct Stack
{
DataType* _array;
size_t _top; //栈顶
size_t _end;
}Stack;

void StackInit(Stack* s)
{
assert(s);
s->_array = NULL;
s->_end = 0;
s->_top = 0;
}

void StackPush(Stack* s, DataType x)
{
assert(s);

//if (s->_end == 0)
//{
//  s->_end = 3;
//  s->_array = (DataType*)realloc(s->_array, s->_end*sizeof(DataType));
//}
//else if (s->_top < s->_end)
//{
//  s->_array[s->_top++] = x;
//}
//else
//{
//  s->_end *= 2;
//  s->_array = (DataType*)realloc(s->_array, s->_end*sizeof(DataType));
//  s->_array[s->_top++] = x;
//}

if (s->_top == s->_end)
{
size_t size = s->_end > 0 ? s->_end * 2 : 3;
s->_array = (DataType*)realloc(s->_array, size*sizeof(DataType));
assert(s->_array);
s->_end = size;
}

s->_array[s->_top++] = x;
}

void StackPop(Stack* s)
{
assert(s);
if (s->_top > 0)
{
s->_top--;
}
}

DataType StackTop(Stack* s)
{
assert(s);

if (s->_top > 0)
{
return s->_array[s->_top - 1];
}
else return 0;
}

size_t StackSize(Stack* s)
{
assert(s);

return s->_top;
}

int StackEmpty(Stack* s)  //拍单端栈是否为空
{
assert(s);

return s->_top;
}

void TestStack()
{
Stack s1;
StackInit(&s1);
StackPush(&s1, 1);
StackPush(&s1, 2);
StackPush(&s1, 3);
StackPush(&s1, 4);
StackPush(&s1, 5);

while (StackEmpty(&s1))
{
printf("%d ", StackTop(&s1));
StackPop(&s1);
}
printf("\n");
}

队列

typedef int DataType;

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

typedef struct Queue
{
QueueNode* _head;
QueueNode* _tail;
}Queue;

void QueueInit(Queue* q)
{
assert(q);

q->_head = NULL;
q->_tail = NULL;
}

void QueuePush(Queue* q, DataType x)
{
assert(q);

QueueNode* node;
node = (QueueNode*)malloc(sizeof(QueueNode));
node->_data = x;
node->_next = NULL;
assert(node);

if (q->_head == NULL)
{
q->_head = q->_tail = node;
}
else
{
q->_tail->_next = node;
q->_tail = node;
}
}

void QueuePop(Queue* q)
{
assert(q);

if (q->_head != NULL)
{
if (q->_head == q->_tail)
{
free(q->_head);
q->_head = q->_tail = NULL;
}
else
{
QueueNode* tail = q->_head;
q->_head = q->_head->_next;
free(tail);
}
}
}

DataType QueueFront(Queue* q)
{
assert(q);

if (q->_head != NULL)
{
return q->_head->_data;
}
else return 0;
}

DataType QueueBack(Queue* q)
{
assert(q);

if (q->_tail != NULL)
{
return q->_tail->_data;
}
else return 0;
}

size_t QueueSize(Queue* q)
{
assert(q);

QueueNode* tail = q->_head;
size_t x = 1;
if (tail == NULL)
return 0;
while (tail != q->_tail)
{
x++;
tail = tail->_next;
}
return x;
}

int QueueEmpty(Queue* q)  //判断队列是否为空
{
assert(q);

return q->_head == NULL ? 0 : 1;
}

void TestQueue()
{
Queue q;
QueueInit(&q);
QueuePush(&q, 1);
QueuePush(&q, 2);
QueuePush(&q, 3);
QueuePush(&q, 4);
QueuePush(&q, 5);

while (QueueEmpty(&q))
{
printf("%d ", QueueFront(&q));
QueuePop(&q);
}
printf("\n");
}