13518219792
#include "stdio.h"
薛城ssl适用于网站、小程序/APP、API接口等需要进行数据传输应用场景，ssl证书未来市场广阔！成为创新互联的ssl证书销售渠道，可以享受市场价格4-6折优惠！如果有意向欢迎电话联系或者加微信：18982081108（备注：SSL证书合作）期待与您的合作！
#include "malloc.h"
typedef struct node1{
int *data;
int top;
void init(void);
void del(void);
int pop(int);
void push(int);
}s;
void node1::init(){
data=(int*)malloc(sizeof(int)*100);
top=0;
}
void node1::del(){
free(data);
top=0;
}
int node1::pop(int e){
if(top==0)return 0;
e=data[--top];
return 1;
}
void node1::push(int e){
if(top==100)return;
data[top++]=e;
}
typedef struct node2{
int *data;
int top;
int bottom;
void init(void);
void del(void);
int pop(int);
void push(int);
void format(s);
}q;
void node2::init(){
data=(int*)malloc(sizeof(int)*100);
top=bottom=0;
}
void node2::del(){
free(data);
top=bottom=0;
}
int node2::pop(int e){
if(top==bottom)return 0;
e=data[top++];
return 1;
}
void node2::push(int e){
if(bottom==100)return;
data[bottom++]=e;
}
void node2::format(s e){
int a;
while(e.pop(a)){
push(a);
}
}
int main(){
s b;q c;
int a;
b.init();c.init();
printf("输入栈中的数,以0结尾\n");
while(1){
scanf("%d",a);
if(a==0)break;
b.push(a);
}
c.format(b);
while(c.pop(a)){
printf("%d\n",a);
}
b.del();
c.del();
return 0;
}//b为栈,c为队列,c.format(b)为转换函数
栈（stack）又名堆栈，它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。
队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。
以上是从数据结构角度来看，从操作系统角度来看，所有的数据结构都是对虚拟内存的操作，堆是堆，栈是栈，栈指的是C语言函数所使用的自动有函数回收的虚拟内存空间，而堆则有操作系统堆管理器来管理的那部分虚拟内存，从C语言角度来看，使用malloc函数动态分配的内存，就是堆内存。
给你看下栈的头文件
你自己添加判断是否是回文的方法吧
#ifndef STACK_H
#define STACK_H
#include iostream
using std::ostream;
//template class Type
//class Stack;
//template class Type
//ostream operator (ostream , const StackType );
template class Type
class Stack {
friend ostream operator (ostream , const StackType );
public:
static const int DefaultSize;
Stack(int = DefaultSize); //创建一个最大容量为MaxStackSize的空栈
Stack(Type[], int, int = DefaultSize); //用数组初始化栈
~Stack(){ delete [] stack; }
bool IsFull(); //若元素个数等于栈的最大容量则返回TRUE,否则返回FALSE
void Add(const Type ); //若IsFull()为TRUE,则调用StackFull,否则将item插入栈顶
bool IsEmpty(); //若栈中元素个数等于0则返回TRUE,否则返回FALSE
Type * Delete(Type); //若IsEmpty()为TRUE，则调用StackEmpty并返回0，
//否则删除栈顶元素并返回其指针
void StackFull(); //将栈的最大容量扩大一倍
void StackEmpty(); //输出警告：栈已空， 不能弹出变量
void Empty(); //将栈清空
int GetSize(); //获得栈内元素数目
private:
Type * stack;
int MaxSize;
int top;
};
template class Type
const int StackType::DefaultSize = 10;
template class Type
StackType::Stack(int pMaxSize) {
MaxSize = pMaxSize;
stack = new Type[MaxSize];
top = -1;
}
template class Type
StackType::Stack(Type pArray[], int pLen, int pMaxSize) {
stack = new Type[pMaxSize];
for ( int i = 0; i pLen; i++ )
{
stack[i] = pArray[i];
}
top = pLen - 1;
MaxSize = pMaxSize;
}
template class Type
inline bool StackType::IsFull() {
if (top == MaxSize - 1) return true;
else return false;
}
template class Type
inline bool StackType::IsEmpty() {
if (top == -1) return true;
else return false;
}
template class Type
void StackType::Add(const Type pX) {
if (IsFull())
{
StackFull();
stack[++top] = pX;
}
else stack[++top] = pX;
}
template class Type
Type * StackType::Delete(Type pX) {
if (IsEmpty())
{
StackEmpty();
return 0;
}
pX = stack[top--];
return pX;
}
template class Type
void StackType::StackEmpty() {
cout "栈已空，不能进行弹出操作！" endl;
}
template class Type
void StackType::StackFull() {
Type * nStack = new Type[MaxSize * 2];
for ( int i = 0; i = top; i++ )
{
nStack[i] = stack[i];
}
MaxSize = MaxSize * 2;
delete [] stack;
stack = nStack;
cout "栈已满，栈的自动容量自动扩充为原来的两倍 (" MaxSize ")" endl;
}
template class Type
ostream operator (ostream pOutput, const StackType pS) {
if (pS.top == -1)
{
pOutput "空栈" endl;
return pOutput;
}
for ( int i = 0; i = pS.top; i++ )
{
pOutput pS.stack[i] " ";
}
return pOutput;
}
template class Type
void StackType::Empty() {
top = -1;
}
template class Type
int StackType::GetSize() {
return top + 1;
}
#endif
栈(Stack)是仅限制在表的一端进行插入和删除运算的线性表，称插入、删除这一端为栈顶，另一端称为栈底。表中无元素时为空栈。栈 的修改是按后进先出的原则进行的，我们又称栈为LIFO表(Last In First Out)。通常栈有顺序栈和链栈两种存储结构。 栈的基本运算有六种： ·构造空栈：InitStack(S) ·判栈空: StackEmpty(S) ·判栈满： StackFull(S) ·进栈： Push(S,x) ·退栈： Pop(S) ·取栈顶元素：StackTop(S) 在顺序栈中有"上溢"和"下溢"的现象。 ·"上溢"是栈顶指针指出栈的外面是出错状态。 ·"下溢"可以表示栈为空栈,因此用来作为控制转移的条件。 顺序栈中的基本操作有六种：·构造空栈·判栈空·判栈满·进栈·退栈·取栈顶元素 链栈则没有上溢的限制，因此进栈不要判栈满。链栈不需要在头部附加头结点，只要有链表的头指针就可以了。 链栈中的基本操作有五种：·构造空栈·判栈空·进栈·退栈·取栈顶元素 队列(Queue)是一种运算受限的线性表，插入在表的一端进行，而删除在表的另一端进行，允许删除的一端称为队头(front)，允许插入的 一端称为队尾(rear) ,队列的操作原则是先进先出的，又称作FIFO表(First In First Out) 。队列也有顺序存储和链式存储两种存储结 构。 队列的基本运算有六种： ·置空队：InitQueue(Q) ·判队空：QueueEmpty(Q) ·判队满：QueueFull(Q) ·入队：EnQueue(Q,x) ·出队：DeQueue(Q) ·取队头元素：QueueFront(Q) 顺序队列的"假上溢"现象：由于头尾指针不断前移，超出向量空间。这时整个向量空间及队列是空的却产生了"上溢"现象。 为了克服"假上溢"现象引入循环向量的概念，是把向量空间形成一个头尾相接的环形，这时队列称循环队列。 判定循环队列是空还是满，方法有三种： ·一种是另设一个布尔变量来判断； ·第二种是少用一个元素空间，入队时先测试（(rear+1)%m = front）? 满：空； ·第三种就是用一个计数器记录队列中的元素的总数。 队列的链式存储结构称为链队列，一个链队列就是一个操作受限的单链表。为了便于在表尾进行插入(入队)的操作，在表尾增加一个尾指 针，一个链队列就由一个头指针和一个尾指针唯一地确定。链队列不存在队满和上溢的问题。在链队列的出队算法中，要注意当原队中只 有一个结点时，出队后要同进修改头尾指针并使队列变空。
#define OVERFLOW -1
#define OK 1
#define ERROR 0
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
#define N 20
typedef char SElemType;
typedef int Status;typedef struct {
SElemType *base;
SElemType *top;
int stacksize;
}SqStack;#includestdio.h
#includestdlib.hStatus CreatStack(SqStack S){
//创建栈
S.base=(SElemType*)malloc(STACK_INIT_SIZE*sizeof(SElemType));
if(!S.base)exit(OVERFLOW);
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
return OK;
}//CreatStackStatus Push(SqStack S,SElemType e){
//插入e为新的栈顶元素
if(S.top-S.base=S.stacksize){//栈满，追加存储空间
S.base=(SElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SElemType));
if(!S.base)exit (OVERFLOW);//存储空间分配失败
S.top=S.base+S.stacksize;
S.stacksize+=STACKINCREMENT;
}
*S.top++=e;
return OK;
}//PushStatus Pop(SqStack S ,SElemType e){
//若栈不空，删除栈顶元素，并用e返回其值
if(S.top==S.base) return ERROR;
e=*--S.top;
return OK;
}//Pop typedef char QElemType;
typedef struct QNode{
QElemType data;
struct QNode *next;
}QNode,*QNodePtr;typedef struct{
QNodePtr front;
QNodePtr rear;
}LinkQueue;Status CreatQueue(LinkQueue Q){
//建立一个空的链式栈
Q.front=Q.rear=(QNodePtr)malloc(sizeof(QNode));
if(!Q.front)exit(OVERFLOW);
Q.front-next=NULL;
return OK;
}Status EnQueue(LinkQueue Q,QElemType e){ QNodePtr p;
p=(QNodePtr)malloc(sizeof(QNode));
if(!p)exit(OVERFLOW);
p-data=e;p-next=NULL;
Q.rear-next=p;
Q.rear=p;
return OK;
}Status DeQueue(LinkQueue Q,QElemType e){QNodePtr p;brif(Q.front==Q.rear) return ERROR;brp=Q.front-next; e=p-data;brQ.front-next=p-next;brif(Q.rear==p) Q.rear=Q.front;brfree(p);brreturn OK;br}int stackPalindrom_Test()//判别输入的字符串是否回文序列,是则返回1,否则返回0
{
printf("栈练习，请输入要判断的字符串以#作为结束符，不要超过二十个字符\n");
SqStack S;
CreatStack(S);
char c;
SElemType a;
SElemType b[N];
int count = 0;
fgets( b, N, stdin );
while((b[count])!='#')
{
Push(S,b[count]); //进栈
count++;
}
int i = 0;
while(i count)
{
Pop(S,a);
if(a!=b[i])
return ERROR;
i++;
}
return OK;}//stackPalindrom_Test int queuePalindrom_Test()//判别输入的字符串是否回文序列,是则返回1,否则返回0
{
printf("队列练习，请输入要判断的字符串以#作为结束符，不要超过二十个字符\n");
LinkQueue Q;
CreatQueue(Q); char c;
SElemType a;
SElemType b[N];
int count = 0;
fgets( b, N, stdin );
while((b[count])!='#')
{
EnQueue(Q,b[count]);; //入列
count++;
} while(count-- 0)
{
DeQueue(Q,a);
if(a!=b[count])
return ERROR;
}
return OK;
}//queuePalindrom_Test Status main(){ if(stackPalindrom_Test()==1)
printf("是回文\n");
else printf("不是回文\n"); if(queuePalindrom_Test()==1)
printf("是回文\n");
else printf("不是回文\n");
return OK;
}
