栈和队列

1. 什么是栈，栈有什么特性？
   答：栈是一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作，进行数据插入和删除操作的一端称为栈顶，另一端称为栈底，栈的特性是先进后出。
2. 请用C语言实现一个动态栈
   typedef int SDataType;

typedef struct Stack
{
SDataType* _array;
int _capacity;
int _size; // 表示栈中有效元素的个数 代表栈顶位置
}Stack;

void StackInit(Stack* ps);
{
assert(ps);
ps->_arry = (SDataType*)malloc(sizeof(SDataType * 3));
if (NULL == ps->_array)
{
asser(0);
return;
}
ps->_capacity = 3;
ps->_size = 0;
}
void StackPush(Stack* ps, SDataType data);
{
CheckCapacity(ps)
ps->_array[ps->_size++] = data;
}
void StackPop(Stack* ps);
{
assert(ps);
if (StackEmpty(ps))
return;
ps->_size -= 1;
}
void StackPop(Stack* ps);
{
assert(ps);
if (StackEmpty(ps))
return;
ps->_size -= 1;
}
DataType StackTop(Stack* ps);
{
assert(ps);
return ps->_array[ps->_size - 1];
}
int StackSize(Stack* ps);
{
assert(ps);
return ps->_size;
}
int StackEmpty(Stack* ps);
{
assert(ps);
return 0 = ps->_size;
}

void StackDestroy(Stack* ps);
{
assert(ps);
if (ps->_array)
{
free(ps->_array);
ps-> - capacity = 0;
ps->_size = 0;

}

}
4. 栈和程序运行时的栈区有什么区别？
答：栈是静态的，就是你编好一个程序，它所定义的的栈区就是静态的，程序运行时的栈区是动态的，它在不停的push pop.
5. 为什么将递归程序转化成循环时需要用到栈？
答：递归是借助于系统栈来实现的。每次递归调用，系统都要为该次调用分配一系列的栈空间用于存放此次调用的相关信息：返回地址，局部变量等。当调用完成时，就从栈空间内释放这些单元，在该函数没有完成前，分配的这些单元将一直保存着不被释放。

6.什么是队列，队列有什么特性？栈和队列有什么区别？
答：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，进行删除的一端称为队头，进行插入的一端称为队尾。队列的特性是先入先出。栈的特性是陷入后出。
7. 请用C语言实现一个队列
typedef int QDataType;
typedef struct QNode
{
struct QNode* _pNext;
QDataType _data;
}QNode;

typedef struct Queue
{
QNode* _front; // 指向队头元素
QNode* _back; // 指向队尾元素
}Queue;

void QueueInit(Queue* q);
{
assert(q);
q->_front = q->_back = NULL;
}
void QueuePush(Queue* q, QDataType data);
{
assert(q);
QNode* pNewNode = BuyQueueNode(data);
if (QueueEmpty(q))
q->_front = q->_back = pNewNode;
else
{
q->_back->_pNext = pNewNode;
q->_back = pNewNode;
}
}
QNode* pDelNode = q->_front;
void QueuePop(Queue* q)
{
if (QueueEmpty(q))
return;
if (q->_front == q->_rear)
{
free(q->_front);
q->_front = q->_back = NULL;
}
else
{
q->_front = pDelNode->_pNext;
free(pDelNode);

}

}
QDataType QueueFront(Queue* q);
{
assert(q);
return q->_front->_data;
}
QDataType QueueBack(Queue* q);
{
assert(q);
return q->_back->_data;
}
int QueueSize(Queue* q);
{
assert(q);
if (QueueEmpty（q))
return 0;
else
{
int count = 0;
QNode* pCur = q->_front;
while (pCur)
{
count++;
pCur = pCur->_pNext;
}
return count;
}
}
int QueueEmpty(Queue* q);
{
assert(q);
NULL == q->_front;
}
void QueueDestroy(Queue* q);
{
QNode* pCur = q->_front;
while (pCur)
{
q->_front = pCur->_pNext;
free(pCur);
pCur = q->_front;
}
q->_front = q->_back = NULL;
}