数据结构栈和队列

系统栈         程序运行中使用的栈，由操作系统维护

栈区：1，保存局部变量

           2，函数的形参的返回值

           3，函数的调用关系         函数中调用函数时会把调用函数的下一条指定的首地址保存在栈区。       （保护现场和恢复现场）。

特点：先进后出，后进先出

数据结构中的栈 

只允许从一端进行数据的插入和删除的线性的存储结构

特点：先进后出，后进先出      FILO

      由自己开辟空间，维护

表尾称为栈顶,表头端称为栈底 。不含元素的空表称为空栈。栈的修改是按后进先出的原则进行的

满栈、空栈：栈顶所在位置是否存有元素

增栈：栈顶向内存高地址移动。

减栈：栈顶向内存低地址移动。

顺序栈：指利用顺序存储结构实现的栈（数组）

链式栈：指采用链式存储结构实现的栈

        以链表表头做栈顶

定义节点及栈对象：

typedef int DataType;

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

typedef struct stack
{
    SNode_t *ptop;
    int clen;
}Stack_t;

链式栈的操作

1. 创建栈
2. 入栈
3. 出栈
4. 清空栈
5. 判空
6. 获取栈顶元素
7.销毁栈

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

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

    pslink->clen++;
    return 0;
}

void print_stack(Stack_t *pslink)         // 遍历
{
    SNode_t *p = pslink->ptop;
    while(p != NULL)
    {
        printf("%d  ",p->data);
        p = p->pnext;
    }
    printf("\n");
}

int pop_stack(Stack_t *pslink,DataType *data)   //出栈
{
    if(!is_empty_stack(pslink))
    {
        SNode_t *p = pslink->ptop;
        pslink->ptop = p->pnext;
        if(data != NULL)
        {
            *data = p->data;
        }
        free(p);
    }
    pslink->clen--;
    return 1;
}

int get_stack_top(Stack_t *pslink,DataType *data)   //获取栈顶元素
{
    if(!is_empty_stack(pslink))
    {
        if(pslink != NULL)
        {
            *data = pslink->ptop->data;
            return 1;
        }
    }
    return 0;
}
void clear_stack(Stack_t *pslink)      //清空栈
{
    while(!is_empty_stack(pslink))
    {
        pop_stack(pslink,NULL);
    }
}
void destroy_stack(Stack_t *pslink)    //销毁栈
{
    clear_stack(pslink);
    free(pslink);
}

队列：先进先出，后进后出    FIFO

 允许从一端插入数据， 另一端删除数据的线性存储结构

允许插入的一端称为队尾，允许删除的一端则称为队头

顺序队列，存在假溢出，可以使用循环队列解决

链式队列：链队是指采用链式存储结构实现的队列。 通常链队用单链表来表
示。 选择链表表头做对头，表尾做队尾。

注意链表对象中pfront指向对头，prear指向队尾

定义节点及链表对象

typedef int QDataType;

typedef struct qnode
{
    QDataType data;
    struct qnode *pnext;
}Queue_Node_t;

typedef struct queue
{
    Queue_Node_t *pfront;
    Queue_Node_t *prear;
    int clen;
    pthread_mutex_t mutex;
}Queue_t;

l链式队列的操作:

1. 创建队列
2. 入队
3. 出队
4. 判空
5. 清空
6. 获取对头元素
7. 销毁

Queue_t *create_queue()     //创建队列
{
    Queue_t *pqueue = malloc(sizeof(Queue_t));
    if(pqueue == NULL)
    {
        perror("malloc fail");
        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 pqueue->pfront == NULL;
}

int push_queue(Queue_t *pqueue,QDataType data)     //入队
{
    Queue_Node_t *pnode = malloc(sizeof(Queue_Node_t));
    if(pnode == NULL)
    {
        perror("malloc fail");
        return -1;
    }
    pnode->data = data;
    pnode->pnext = NULL;
    if(!is_empty_queue(pqueue))
    {
        pqueue->prear->pnext = pnode;
        pqueue->prear = pnode;
    }
    else
    {
        pqueue->prear = pnode;
        pqueue->pfront = pnode;
    }
    pqueue->clen++;
    return 1;
}
int pop_queue(Queue_t *pqueue,QDataType *data)      //出队
{
    if(!is_empty_queue(pqueue))
    {
        Queue_Node_t *p = pqueue->pfront;
        pqueue->pfront = p->pnext;
        if(data != NULL)
        {
            *data = p->data;
        }
        if(p->pnext == NULL)
        {
            pqueue->prear = NULL;
        }
        free(p);
    }
    pqueue->clen--;

    return 1;
}

void print_queue(Queue_t *pqueue)     //遍历
{
    Queue_Node_t *p = pqueue->pfront;
    while(p != NULL)
    {
        printf("%d ",p->data);
        p = p->pnext;
    }
    printf("\n");
}

int get_queue_front(Queue_t *pqueue,QDataType *data)    //获取队头元素
{
    if(!is_empty_queue(pqueue))
    {
        if(data != NULL)
        {
            *data = pqueue->pfront->data;
        }
    }
    return 1;
}

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);
}