栈的增删改查基本操作

栈的增删改查基本操作

1.顺序栈

//顺序栈结构体定义
#define STACKSIZE 64          //栈的大小
typedef int stackType;
typedef struct _snode
{
    stackType data[STACKSIZE];  //栈中的实际存储数据
    int top;            //栈顶指标，等价于数组下标。
}SeqStack,*pSeqStack; 
//创建栈
pSeqStack SeqStackCreat()
{
    pSeqStack node = (pSeqStack)malloc(sizeof(SeqStack));
    if(NULL == node)
    {
        perror("malloc err");
        return NULL;
    }
    memset((void*)(node->data), 0,STACKSIZE);
    node->top = -1;
    return node;

}
//判断栈是否满
int SeqStackisFull(pSeqStack S)
{
    if(S->top > STACKSIZE)
        return 1;
    else 
        return 0;
}
//入栈
int SeqStackPush(pSeqStack S,stackType data)
{
    if(S->top > STACKSIZE)
    {
        printf("SeqStack is Full\n");
        return -1;
    }
    S->top++;
    S->data[S->top] = data;

    return 0;
}
//出栈
int SeqStackPop(pSeqStack S,stackType *data)
{
    if(S->top < 0)
    {
        printf("SeqStack is Empty\n");
        return -1;
    }
    *data = S->data[S->top];
    S->top--;

    return 0;
}
//删除栈
int SeqStackFree(pSeqStack S)
{
    free(S);
    return 0;
}
int printSeqStack(pSeqStack S)
{
    int i = 0;
    for(i = 0;i <= S->top;i++)
    {

        printf("%4d ",S->data[i]);
    }
    printf("\r\n");
    return i;
}

2.共享栈

两个栈共享一个数组，建立两个栈的栈底，一个位于数组的始端data[0]，一个位于数组的末端data[N-1]
如果两个栈增长，向数组中间延伸

typedef struct _sdnode
{
    stackType data[STACKSIZE];  //栈中的实际存储数据
    int top1;           //栈1栈顶指标，等价于数组下标
    int top2;           //栈2栈顶指标
}SeqDStack,*pSeqDStack; 

//当 top1 + top2 = STACKSIZE;表示栈满
//或者当 top1 + 1 = top2; 也表示栈满
pSeqDStack SeqDStackCreat()
{
    pSeqDStack node = (pSeqDStack)malloc(sizeof(SeqDStack));
    if(NULL == node)
    {
        perror("malloc err");
        return NULL;
    }
    memset((void*)(node->data), 0,STACKSIZE);
    node->top1 = -1;
    node->top2 = STACKSIZE;
    return node;

}
//入栈
int SeqDStackPush(pSeqDStack S,stackType data,int stackNum)
{
    //if(S->top1 + S->top2 >= STACKSIZE)
    if(S->top1 + 1 > S->top2)
    {
        printf("SeqStack is Full\n");
        return -1;
    }
    if(stackNum == 1)
    {
        S->top1++;
        S->data[S->top1] = data;
    }
    else
    {
        S->top2--;
        S->data[S->top2] = data;
    }

    return 0;
}
//出栈
int SeqDStackPop(pSeqDStack S,stackType *data,int stackNum)
{
    if(S->top1 + 1 > S->top2)
    {
        printf("SeqStack is Full\n");
        return -1;
    }
    if(stackNum == 1)
    {
        if(S->top1 < 0)
            return -2;
        *data = S->data[S->top1--];
    }
    else
    {
        if(S->top2 > STACKSIZE)
            return -2;
        *data = S->data[S->top2++];
    }

    return 0;
}
int printSeqDStack(pSeqDStack S)
{
    int i = 0;
    printf("Top1:\n");
    for(i = 0;i <= S->top1;i++)
    {

        printf("%4d ",S->data[i]);
    }
    printf("\r\n");
    printf("Top2:\n");
    for(i = STACKSIZE - 1;i >= S->top2;i--)
    {

        printf("%4d ",S->data[i]);
    }
    printf("\r\n");
    return i;
}

3.链式栈

其数据结构还是同单链表，只是存取数据的方式变为类似栈的操作

//结构体
typedef struct _slnode  
{  
    dataType data;          //用每个结点存储数据
    struct _slnode *next;   //指向下一个结点
}StackNode,*pStackNode;     
typedef struct _stack
{
    pStackNode top;         //指向栈顶
    int count;              //计数
}LinkStack,*pLinkStack;     //仅仅是封装这两个变量
//创建结点
pStackNode LinkStackCreatNode(dataType data)
{
    pStackNode node = (pStackNode)malloc(sizeof(StackNode));
    if(NULL == node)
    {
        perror("LinkStackCreatNode malloc");
        return NULL;
    }
    node->data = data;
    node->next = NULL;

    return node;
}
//创建链式栈
pLinkStack LinkStackCreatList()
{
    pLinkStack s = (pLinkStack)malloc(sizeof(LinkStack));
    if(NULL == s)
    {
        perror("LinkStackCreatList malloc");
        return NULL;
    }
    s->count = 0;
    s->top = NULL;
}
//入栈
int LinkStackPush(pLinkStack S,dataType data)
{
    pStackNode p = LinkStackCreatNode(data);
    if(NULL == p)
    {
        perror("LinkStackCreatNode");
        return -1;
    }
    p->next = S->top;   //新插入的结点
    S->top = p;
    S->count++;
    return 0;
}

//出栈
int LinkStackPop(pLinkStack S,dataType *data)
{
    if(S->count < 1)
        return -1;
    pStackNode p = S->top;
    *data = p->data;
    S->top = p->next;
    S->count--;
    free(p);

}
int printLinkStack(pLinkStack S)
{
    int i = 0;
    pStackNode p = S->top;
    for(i = 0;i < S->count;i++)
    {

        printf("%4d ",p->data);
        p = p->next;
    }
    printf("\r\n");
    return i;
}

测试main函数

int main()
{
    //顺序栈
    pSeqStack s_Stack = NULL;
    int m_data = 0;
    s_Stack = SeqStackCreat();

    for(int i = 0;i < 20;i++)
    {
        SeqStackPush(s_Stack,i + 60);
    }
    printSeqStack(s_Stack);

    for(int i = 0;i < 20;i++)
    {
        SeqStackPop(s_Stack,&m_data);
        printf("Pop:%d\r\n",m_data);
    }
    SeqStackFree(s_Stack);

    //共享栈
    pSeqDStack s_dStack = SeqDStackCreat();
    int m_data = 0;
    for(int i = 0;i < 20;i++)
    {
        SeqDStackPush(s_dStack,i + 60,1);
        SeqDStackPush(s_dStack,i + 60,2);
    }
    printSeqDStack(s_dStack);

    for(int i = 0;i < 20;i++)
    {
        SeqDStackPop(s_dStack,&m_data,1);
        printf("Pop1:%d\r\n",m_data);
        SeqDStackPop(s_dStack,&m_data,2);
        printf("Pop2:%d\r\n",m_data);
    }
    free(s_dStack);

    //链式栈
    pLinkStack s_sLink = LinkStackCreatList();
    int m_data = 0;
    for(int i = 0;i < 20;i++)
        LinkStackPush(s_sLink,i+80);
    printLinkStack(s_sLink);

    for(int i = 0;i < 20;i++)
    {
        LinkStackPop(s_sLink,&m_data);
        printf("Pop:%d\n",m_data);
    }
    return 0;
}