栈的顺序存储和链式存储

#include<malloc.h>
#include<iostream>
using namespace std;
#ifndef SEQSTACK
#define SEQSTACK
#define MaxNum 10
typedef int elemtype;




//顺序栈结构体
struct seqstack
{
elemtype sk[MaxNum];
elemtype top;
};


//创建一个空栈
seqstack* CreateSeqStack()
{
seqstack *s;
s = (seqstack*)malloc(sizeof(struct seqstack));
if(!s)
{
printf("malloc error \n");
return NULL;
}
else
{
s->top = -1;
}
}
//入栈
void PushSeqStack(seqstack *sp, elemtype value)
{
if(sp->top == MaxNum - 1)
{
printf("seqstack if full \n");
}
else
{
sp->top+=1;
sp->sk[sp->top] = value;
}

}
//出栈
void PopSeqStack(seqstack *sp)
{
if(sp->top == -1)
{
printf("empty seqstack \n");
}
else
{
sp->top-=1;
printf("pop seqstack seccuss \n");
}
}


//打印栈内所有元素
void DisplaySeqStack(seqstack *s)
{
if(s->top == -1)
{
printf("empty seqstack \n");
}
else
{
cout << "======================================================" << endl;
for(elemtype i = s->top;i >= 0;i --)
{
printf("the %d value is %d \n", i, s->sk[i]);
}
cout << "======================================================" << endl;
}
}


//取栈顶元素
elemtype GetTopValue(seqstack *sp)
{
if(sp->top == -1)
{
printf("empty seqstack \n");
return -1;
}
else
{
return sp->sk[sp->top];
}
}




#endif




/*
seqstack *sp;
sp = CreateSeqStack();
DisplaySeqStack(sp);
int tmp;
while(cin>>tmp)
{
if(999 == tmp)
break;
PushSeqStack(sp,tmp);
}
DisplaySeqStack(sp);
cout << "======================================================" << endl;
cout << "begin pop seqstack" << endl;
PopSeqStack(sp);
cout << "end pop seqstack" << endl;
cout << "======================================================" << endl;
DisplaySeqStack(sp);


cout << "begin get top value" << endl;
tmp = GetTopValue(sp);
cout << tmp << endl;
cout << "end get top seqstack" << endl;

*/

#include<iostream>
#include<malloc.h>
using namespace std;
#ifndef LINKSTACK
#define LINKSTACK


typedef int elemtype;
struct linkstack
{
elemtype data;
linkstack* next;
};


//创建空栈


linkstack* CreateLinkStack()
{
linkstack *sp=NULL;
return sp;
}


//入栈


void PushLinkStack(linkstack* &sp,elemtype eInputValue)
{
linkstack* lSk;
lSk = (linkstack*)malloc(sizeof(linkstack));
if(!lSk)
{
printf("malloc error \n");
return;
}

//判断当前栈是否为空
if(NULL == sp)
{
lSk->data = eInputValue;
lSk->next = NULL;
sp = lSk;
}
else
{
lSk->data = eInputValue;
lSk->next = sp;
sp = lSk;
}
}


//按顺序打印栈内数据元素


void DisplayLinkStack(linkstack* sp)
{
if(NULL == sp)
{
printf("empty linkstack \n");
}
else
{
linkstack *p = sp;
int iLocateValue = 1;
printf("====================================================================\n");
while(p != NULL)
{
printf("the %d value is %d \n", iLocateValue, p->data);
p = p->next;
iLocateValue += 1;
}
printf("====================================================================\n");
}
}


//出栈
void PopLinkStack(linkstack* &sp)
{
if(NULL == sp)
{
printf("pop error empty linkstack \n");
}
else
{
linkstack* p;
p = sp;
sp = p->next;
free(p);
printf("pop success  linkstack \n");
}
}
//取栈顶元素
elemtype GetTopValue(linkstack *sp)
{
elemtype eTmp;
if(NULL == sp)
{
printf("empty linkstack \n");
return -1;
}
else
{
return sp->data;
}
}




#endif