数据结构：栈和队列（Stack & Queue）

栈

一、栈的基本概念

1、栈的定义

        栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。

        栈顶（Top）：线性表允许进行插入删除的那一端。
        栈底（Bottom）：固定的，不允许进行插入和删除的另一端。
        空栈：不含任何元素的空表。

        栈又称为先进后出、后进先出的线性表，简称FILO结构

2、栈的常见基本操作

Stack_t *create_stack();        创建
int push_stack(Stack_t *, DataType );        进栈
int pop_stack(Stack_t *, DataType *);        出栈
int get_stack_top(Stack_t *, DataType *);        查找栈顶元素
void clear_stack(Stack_t *);        清除
void destroy_stack(Stack_t *);        销毁
int is_empty_stack(Stack_t *);        判空
void stack_for_each(Stack_t *pstack);        

二、顺序栈

        采用顺序存储的栈称为顺序栈，它利用一组地址连续的存储单元存放自栈底到栈顶的数据元素，同时附设一个指针（top）指示当前栈顶元素的位置。

        若存储栈的长度为StackSize，则栈顶位置top必须小于StackSize。当栈存在一个元素时，top等于0，因此通常把空栈的判断条件定位top等于-1。

三、链式栈

        采用链式存储的栈称为链栈，链栈的优点是便于多个栈共享存储空间和提高其效率，且不存在栈满上溢的情况。通常采用单链表实现，并规定所有操作都是在单链表的表头进行的。这里规定链栈没有头节点，Lhead指向栈顶元素，如下图所示。

对于空栈来说，链表原定义是头指针指向空，那么链栈的空其实就是top=NULL的时候。

链栈的结构代码如下：

typedef int DataType;

typedef struct snode
{
    DataType data;
    struct snode *pnext;
}SNode_t;

typedef struct stack
{

    SNode_t *ptop;
    int clen;
}Stack_t;

链栈的基本算法

/*----------创建------------*/
Stack_t *create_stack()   
{
    Stack_t *pstack = (Stack_t *)malloc(sizeof(Stack_t));
    if(NULL == pstack)
    {
        perror("fail malloc");
        return NULL;
    }
    pstack->ptop = NULL;
    pstack->clen = 0;

    return pstack;
}
/*------------进栈--------------*/
int push_stack(Stack_t *pstack, DataType data)
{
    SNode_t *pnode = (SNode_t *)malloc(sizeof(SNode_t));
    if(NULL == pnode)
    {
        perror("fail malloc");
        return -1;
    }
    pnode->data = data;
    pnode->pnext = NULL;

    pnode->pnext = pstack->ptop;
    pstack->ptop = pnode;

    pstack->clen++;

    return 0;
}
/*-----------遍历----------*/
void stack_for_each(Stack_t *pstack)
{
    SNode_t *p = pstack->ptop;
    while(p)
    {
        printf("%d ", p->data);
        p = p->pnext;    
    }
    printf("\n");
}
/*-----------判空-----------*/
int is_empty_stack(Stack_t *pstack)
{
    return pstack->ptop == NULL;
}
/*------------出栈------------*/
int pop_stack(Stack_t *pstack, DataType *pdata)
{
    if(is_empty_stack(pstack))
    {
        return 0;
    }
    SNode_t *pdel = pstack->ptop;
    pstack->ptop = pdel->pnext;
    if(pdata != NULL)
    {
        *pdata = pdel->data;
    }
    free(pdel);
    pstack->clen--;

    return 1;
}
/*----------查找栈顶元素---------*/
int get_stack_top(Stack_t *pstack, DataType *pdata)
{
    if(is_empty_stack(pstack))
        return 0;

    if(pdata != NULL)
    {
        *pdata = pstack->ptop->data;
        return 1;
    }
    return 0;
}
/*------------清除--------------*/
void clear_stack(Stack_t *pstack)
{
    while(!is_empty_stack(pstack))
    {
        pop_stack(pstack, NULL);
    }
}
/*-----------销毁---------------*/
void destroy_stack(Stack_t *pstack)
{
    clear_stack(pstack);
    free(pstack);
}

队列

一、队列的基本概念

1.队列的定义

队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。

队列是一种先进先出、后进后出的线性表，简称FIFO。允许插入的一端称为队尾，允许删除的一端称为队头。

队头（Front）：允许删除的一端，又称队首。
队尾（Rear）：允许插入的一端。
空队列：不包含任何元素的空表。

2.队列的常见基本操作

extern Queue_t *create_queue();
extern int is_empty_queue(Queue_t *pqueue);
extern int push_queue(Queue_t *pqueue, QDataType data);
extern int pop_queue(Queue_t *pqueue, QDataType *pdata);
extern void queue_for_each(Queue_t *pqueue);
extern int get_queue_top(Queue_t *pqueue, QDataType *pdata);
extern void clear_queue(Queue_t *pqueue);
extern void destroy_queue(Queue_t *pqueue);

二、顺序队列

        队列的顺序实现是指分配一块连续的存储单元存放队列中的元素，并附设两个指针：队头指针 front指向队头元素，队尾指针 rear 指向队尾元素的下一个位置。

        初始状态（队空条件）：Q->front == Q->rear == 0。
        进队操作：队不满时，先送值到队尾元素，再将队尾指针加1。
        出队操作：队不空时，先取队头元素值，再将队头指针加1。

三、链式队列

        队列的链式存储结构表示为链队列，它实际上是一个同时带有队头指针和队尾指针的单链表，只不过它只能尾进头出而已。

队列的基本算法

/*----------创建--------*/
Queue_t *create_queue()
{
    Queue_t *pqueue = (Queue_t *)malloc(sizeof(Queue_t));
    if(NULL == pqueue)
    {
        perror("fail malloc");
        return NULL;
    }
    pqueue->pfront = NULL;
    pqueue->prear = NULL;
    pqueue->clen = 0;
    pthread_mutex_init(&(pqueue->mutex), NULL);

    return pqueue;
}
/*-------------判空--------------*/
int is_empty_queue(Queue_t *pqueue)
{
    return NULL == pqueue->pfront;
}
/*----------进队（尾插）----------*/
int push_queue(Queue_t *pqueue, QDataType data)
{
    QNode_t *pnode = (QNode_t *)malloc(sizeof(QNode_t));
    if(NULL == pnode)
    {
        perror("fail malloc");
        return -1;
    }
    pnode->data = data;
    pnode->pnext = NULL;

    if(is_empty_queue(pqueue))
    {
        pqueue->pfront = pnode;
        pqueue->prear = pnode;
    }
    else
    {
        pqueue->prear->pnext = pnode;
        pqueue->prear = pnode;
    }

    pqueue->clen++;

    return 0;
}
/*---------出队（头删）-----------*/
int pop_queue(Queue_t *pqueue, QDataType *pdata)
{
    if(is_empty_queue(pqueue))
    {
        return 0;
    }
    QNode_t *pdel = pqueue->pfront;
    pqueue->pfront = pdel->pnext;
    if(pdata != NULL)
    {
        *pdata = pdel->data;
    }
    free(pdel);
    if(NULL == pqueue->pfront)
    {
        pqueue->prear = NULL;
    }
    pqueue->clen--;

    return 1;
}
/*------------遍历-----------*/
void queue_for_each(Queue_t *pqueue)
{
    QNode_t *p = pqueue->pfront;
    while(p)
    {
        printf("%d ", p->data);
        p = p->pnext;
    }
    printf("\n");
}
/*------------查找-----------*/
int get_queue_top(Queue_t *pqueue, QDataType *pdata)
{
    if(is_empty_queue(pqueue))
        return 0;

    if(pdata != NULL)
    {
        *pdata = pqueue->pfront->data;
        return 1;
    }
    return 0;
}
/*------------清除------------*/
void clear_queue(Queue_t *pqueue)
{
    while(!is_empty_queue(pqueue))
    {
        pop_queue(pqueue, NULL);
    }
}
/*------------销毁--------------*/
void destroy_queue(Queue_t *pqueue)
{
    clear_queue(pqueue);
    free(pqueue);
}