栈
#include<stdio.h>
#include<windows.h>
#include<assert.h>
typedef int DataType;
#define Stack_size 10
typedef struct Stack
{
DataType* _array;
size_t _top;
size_t _end;
}Stack;
-----------------------------------------------------------
void StackInit(Stack* s)
{
assert(s);
s->_array = (DataType*)malloc(sizeof(DataType)*Stack_size);
s->_end = Stack_size;
s->_top = 0;
}
-----------------------------------------------------------
void StackPush(Stack* s, DataType x)
{
assert(s);
if (s->_end == s->_top)
{
s->_end *= 2;
s->_array = (DataType*)realloc(s->_array, sizeof(DataType)*(s->_end));
s->_array[s->_top] = x;
(s->_top)++;
}
else
{
s->_array[s->_top] = x;
(s->_top)++;
}
}
---------------------------------------------------------
void Stack_print(Stack *s)
{
if (s == NULL)
{
return;
}
while ((s->_top)--)
{
printf("%d\t", s->_array[s->_top]);
}
}
---------------------------------------------------------
void StackPop(Stack* s)
{
assert(s);
if (s->_top == 0)
{
printf("the stack is empty");
}
else
{
s->_top--;
}
}
---------------------------------------------------------
DataType StackTop(Stack* s)
{
assert(s);
if (s->_top == 0)
{
printf("the stack is empty");
return;
}
else
{
int num = s->_top;
int i = s->_array[(--num)];
return i;
}
}
---------------------------------------------------------
size_t StackSize(Stack* s)
{
assert(s);
return s->_end;
}
---------------------------------------------------------
int StackEmpty(Stack* s)
{
if (s->_top == 0)
{
return 1;
}
else
{
return 0;
}
}
队列
#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;
QueueNode* _tail;
}Queue;
------------------------------------------------
void QueueInit(Queue* q)
{
q->_head = (QueueNode*)malloc(sizeof(QueueNode));
assert(q->_head);
q->_tail = q->_head;
q->_tail->_next = NULL;
}
-------------------------------------------------
void QueuePush(Queue* q, DataType x)
{
assert(q);
QueueNode *newnode = (QueueNode*)malloc(sizeof(QueueNode));
assert(newnode);
newnode->_data = x;
newnode->_next = NULL;
q->_tail->_next = newnode;
q->_tail = newnode;
}
---------------------------------------------------
void QueuePop(Queue* q)
{
assert(q);
if (q->_head == q->_tail)
{
printf("the queue is empty.");
return;
}
QueueNode *p = q->_head->_next;
q->_head = p;
}
---------------------------------------------------
DataType QueueFront(Queue* q)
{
assert(q);
if (q->_head == q->_tail)
{
printf("the queue is empty.");
return 0;
}
return (q->_head->_next)->_data;
}
----------------------------------------------------
DataType QueueBack(Queue* q)
{
assert(q);
if (q->_head == q->_tail)
{
printf("the queue is empty.");
return 0;
}
QueueNode *p = q->_head->_next;
while (p != q->_tail)
{
p = p->_next;
}
return p->_data;
}
-------------------------------------------------
size_t QueueSize(Queue* q)
{
assert(q);
if (q->_head == q->_tail)
{
return 0;
}
QueueNode *flag = q->_head->_next;
size_t i = 0;
while (flag != q->_tail)
{
flag = flag->_next;
i++;
}
return i+1 ;
}
-----------------------------------------------
int QueueEmpty(Queue* q)
{
assert(q);
if (q->_head == q->_tail)
{
printf("the queue is empty.");
return 0;
}
return 1;
}