嵌入式学习的第二十二天-数据结构-栈+队列

一、栈

1.定义：栈是限定仅在表尾进行插入和删除操作的线性表。先进后出、后进先出。

2.栈顶（top）:允许操作的一端  栈底(bottom):不允许操作的一端

3.栈的插入操作叫做进栈，也叫压栈、入栈；栈的删除操作叫做出站，也叫弹栈。

注：链式结构只支持头删和头插

4.栈的一般操作

（1）.创建 CreateSeqStack

LinkStack*CreateLinkStack()
{
    LinkStack*ls = (LinkStack*)malloc(sizeof(LinkStack));
    if(NULL == ls)
    {
        fprintf(stderr,"CreateLinkStack malloc\n");
        return NULL;
    }
    ls->top =NULL;
    ls->clen = 0;
    return ls;
}

（2）.销毁 DestroySeqStack

int DestoryLinkStack(LinkStack*ls)
{
    int len = GetSizeLinkStack(ls);
    int i = 0;
    for(i = 0;i < len;++i)
    {
       PopLinkStack(ls);
    }
    free(ls);
    ls->top = NULL;
    return 0;
}

（3）.判断是否为空栈 IsEmptySeqStack

int IsEmptyLinkStack(LinkStack*ls)
{
    return 0 == ls->clen;
}

（4）.获取栈顶元素

DATATYPE*GetTopLinkStack(LinkStack*ls)
{
    if(IsEmptyLinkStack(ls))
    {
        return NULL;
    }
    return &ls->top->data;
}

（5）.进栈 PushSeqStack

int PushLinkStack(LinkStack*ls,DATATYPE*data)
{
    LinkStackNode *newnode = malloc(sizeof(LinkStackNode));
    if(NULL == ls)
    {
        fprintf(stderr,"PushLinkStack malloc\n");
        return 1;
    }
    memcpy(&newnode->data, data, sizeof(DATATYPE));
    newnode->next =NULL;

    newnode->next = ls->top;
    ls->top = newnode;
    ls->clen++;
    return 0;
}

（6）.出栈 PopSeqStack

int PopLinkStack(LinkStack*ls)
{
    if(IsEmptyLinkStack(ls))
    {
        return 1;
    }
    LinkStackNode *tmp = ls->top;
    ls->top = ls->top->next;
    free(tmp);
    ls->clen--;
    return 0;
}

二、队列

1.定义：队列是只允许在一段进行插入，而在另一端进行删除操作的线性表。

2.允许插入的称谓队尾，允许删除的一端队头。

3.特性：先进先出

4.队列的一般操作

(1)满队和空队的判断

满队：(tail+1)%tlen=head;空对：tail = head;

(2）创建 CreateSeQue

SeqQueue* CreateSeqQue(int len)
{
    SeqQueue*sq = (SeqQueue*)malloc(sizeof(SeqQueue));
    if(NULL == sq)
    {
        fprintf(stderr, "CreateSeQueue malloc\n");
        return NULL;
    }
    sq->array = (malloc(sizeof(DATATYPE)*len));
    if(NULL == sq->array)
    {
        fprintf(stderr, "CreateSeQueue malloc\n");
        return NULL;
    }
    sq->head = 0;
    sq->tail = 0;
    sq->tlen =len;
    return sq;
    
}

(3)判空

int IsEmptySeqQue(SeqQueue*sq)
{
    return sq->head==sq->tail;
}

（4）判满

int IsFullSeqQue(SeqQueue*sq)
{
    return (sq->tail+1)%sq->tlen == sq->head;
}

（5）进队

int EnterSeqQue(SeqQueue*sq,DATATYPE*data)
{
    if(IsFullSeqQue(sq))
    {
        fprintf(stderr,"EnterSeqQue,SeqQue full\n");
        return 1;
    }
    memcpy(&sq->array[sq->tail], data, sizeof(DATATYPE));
    sq->tail = (sq->tail+1)%sq->tlen;
    return 0;;
}

（6）出队

int QuitSeqQue(SeqQueue*sq)
{
     if(IsEmptySeqQue(sq))
    {
        fprintf(stderr,"QuitSeqQue SeqQue empty\n");
        return 1;
    }
    sq->head =(sq->head+1)%sq->tlen;
    return 0;
}

（7）获得队头元素

DATATYPE* GetHeadSeqQue(SeqQueue*sq)
{
    if(IsEmptySeqQue(sq))
    {
        return NULL;
    }
    return &sq->array[sq->head];
}

（9）销毁

int DestroySeqQue(SeqQueue*sq)
{
    free(sq->array);
    free(sq);
    return 0;
}