栈和队列

一. 栈

1.栈的概念及结构

栈是一种特殊的线性表，只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端，称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出的原则。 

压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。

出栈：栈的删除操作叫做出栈。出数据也在栈顶。

2.栈的实现

栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组在尾上插入数据的 代价比较小。

//静态栈
typedef int STDataType;
#define N 10
typedef struct Stack
{
       STDataType _a[N];  
       int _top; // 栈顶
}Stack;
// 支持动态增长的栈
typedef int STDataType;
typedef struct Stack
{   
       STDataType* _a;
       int _top;       // 栈顶  
       int _capacity;  // 容量
}Stack;

 

二. 队列

1.队列的概念及结构

队列是只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列遵守先进先出的原则。

入队列：进行插入操作的一端称为队尾。

出队列：进行删除操作的一端称为队头。

2.队列的实现

队列也可以用数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较。

typedef int QDataType;
typedef struct QueueNode
{
       QDataType _data;
       struct QueueNode* _next;
}QueueNode;
typedef struct Queue
{
       struct QueueNode* _front;
       struct QueueNode* _back;
}Queue;
void QueueInit(Queue* q)//初始化
{
       assert(q);
       q->_back = q->_front = NULL;
}
void QueuePush(Queue* q, QDataType data)//插入
{
       assert(q);
       QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
       newnode->_data = data;
       newnode->_next = NULL;
       if (q->_back == NULL)
       {
              q->_back = q->_front = newnode;
       }
       else {
              q->_back->_next = newnode;
              q->_back = newnode;
       }
}
void QueuePop(Queue* q)//队头出队列
{
       assert(q);
       if (q->_front->_next == NULL)
       {
              free(q->_front);
              q->_back = q->_front = NULL;
       }
       else
       {
              QueueNode* next = q->_front->_next;
              free(q->_front);
              q->_front = next;
       }
}
QDataType QueueFront(Queue* q)//获取队头元素
{
       assert(q);
       return q->_front->_data;
}
QDataType QueueBack(Queue* q)//获取队尾元素
{
       assert(q);
       return q->_back->_data;
}
int QueueSize(Queue* q)//获取队列元素个数
{
       int n = 0;
       QueueNode* cur = q->_front;
       while (cur)
       {
              n++;
              cur = cur->_next;
       }
       return n;
}
int QueueEmpty(Queue* q)//判断是否为空
{
       return q->_front = NULL ? 1 : 0;
}
void QueueDestory(Queue* q)//销毁
{
       QueueNode* cur = q->_front;
       while (cur)
       {
              QueueNode* next = cur->_next;
              free(cur);
              cur = next;
       }
       q->_front = q->_back = NULL;
}

3.环形队列

实现：

typedef struct
{
       int* _array;
       int _size;//大小
       int front;//队头
       int back;//队尾
}MyCircularQueue;
MyCircularQueue* muyCircularQueueCreate(int k)
{
       MyCircularQueue* cq = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
       cq->_array = (int*)malloc(sizeof(int)*(k+1));
       cq->_size = k+1;
       cq->front = cq->back = 0;
       cq->back = 0;
       cq->front = 0;
       return cq;
}
//插入
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value)
{
       if (myCircularQueueIsFull(obj))
       {
              return false;
       }
       obj->_array[obj->back] = value;
       obj->back++;
       if (obj->back == obj->_size)
       {
              obj->back = 0;
       }
       return true;
}
bool myCircularQueueDeQueue(MyCircularQueue* obj)
{
       if (myCircularQueueIsEmpty(obj))
              return false;
       obj->front++;
       if (obj->front == obj->_size)
              obj->front = 0;
       return true;
}
int myCircularQueueFront(MyCircularQueue* obj)//找队头
{
       if(myCircularQueueIsEmpty(obj))
              return -1;
       return obj->_array[obj->front];
}
int myCircularQueueRear(MyCircularQueue* obj)//找队尾
{
       if (myCircularQueueIsEmpty(obj))
              return -1;
       int prevBack = obj->back - 1;
       if (obj->back == 0)
              prevBack = obj->_size - 1;
       return obj->_array[prevBack];
}
bool myCircularQueueIsEmpty(MyCircularQueue* obj)
{
       return obj->front == obj->back;
}
bool myCircularQueueIsFull(MyCircularQueue* obj)
{
       if (obj->back + 1 == obj->front)
              return true;
       if ((obj->back + 1) % (obj->_size) == obj->front)
              return true;
       return false;
}
void myCircularQueueFree(MyCircularQueue* obj)
{
       free(obj->_array);
       free(obj);
}