栈的增删改查基本操作
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;
}