急!!!!!求一栈队列的程序..简单的就行..

[yt271]

求一栈队列的程序..简单的就行..

[中国007程序员]

请问你用来做什么？什么样的数据结构，基本数据类型就简单，结构体就要复杂一点。还有你的队列是定长的，还是动态的？(^_^)

[周药师]

言简意不赅

[yt271]

基本的就行了。。上课的题目。。

[yt271]

3楼的大哥、、我要的是栈。队列的。。谢谢

[aleyn]

#include<iostream.h>

#define MAXS 100
typedef char ElemType;
typedef struct stack
{
ElemType data[MAXS];
int top;
}SqStack;
int InitStack(SqStack &S)
{
S.top=-1;
return 1;
}
int ClearStack(SqStack &S)
{
S.top=-1;
return 1;
}
int StackEmpty(SqStack S)
{
if(S.top==-1)
return 1;
return 0;
}
int StackFull(SqStack S)
{
if(S.top==MAXS-1)
return 1;
return 0;
}
int StackLength(SqStack S)
{
return S.top+1;
}
int GetTop(SqStack S,ElemType &e)
{
if(S.top==-1)
return 0;
e=S.data[S.top];
return 1;
}
int Push(SqStack &S,ElemType e)
{
if(S.top==MAXS-1)
return 0;
S.data[++S.top]=e;
return 1;
}
int Pop(SqStack &S,ElemType &e)
{
if(S.top==-1)
return 0;
e=S.data[S.top--];
return 1;
}
//访问栈中元素
void StackPrint(SqStack S)
{
SqStack p=S;
if(p.top==-1)
return ;
while(p.top!=-1)
{
cout<<p.data[p.top--]<<" ";
}
}
//用栈来判断一个字符串是否为回文
int Huiwen(ElemType str[])
{
SqStack S;
int i=0;
InitStack(S);
ElemType ch,temp;
while ((ch=str[i++])!='\0')
Push(S,ch);
i=0;
while (!StackEmpty(S))
{
Pop(S,temp);
if(temp!=str[i++])
return 0;
}
return 1;
}
//12． 利用栈的基本信息，编写一个算法输入若干整数，以0标识输入结束。然后按与输入相反的次序输出这些数。
int Reverse()
{
SqStack S;
InitStack(S);
ElemType ch;
cin>>ch;
while(ch!=48)
{
Push(S,ch);
cin>>ch;
}
while(S.top!=-1)
{
Pop(S,ch);
cout<<ch<<" ";
}
return 1;
}







void main()
{
ElemType str[]="abcddcba";
cout<<"回文判断:"<<Huiwen(str)<<endl;
cout<<"请输入你要输入的整数(输入0结束):"<<endl;
Reverse();cout<<endl;
SqStack S;
InitStack(S);
Push(S,'a');
Push(S,'b');
Push(S,'c');
Push(S,'d');
cout<<"访问栈中元素:"<<endl;StackPrint(S);cout<<endl;



}

[aleyn]

#include<stdio.h>
#include<iostream.h>
#include<stdlib.h>
#include<malloc.h>
typedef char ElemType;
typedef struct stack
{
ElemType data;
struct stack *top;
}LinkStack;
int InitStack(LinkStack *&ls)
{
ls=NULL;
return 1;
}
int ClearStack(LinkStack *&ls)
{
LinkStack *p;
if(ls==NULL)
return 0;
while(ls!=NULL)
{
p=ls;
ls=p->top;
free(p);
}
return 1;
}
int StackEmpty(LinkStack *ls)
{
if(ls==NULL)
return 1;
else return 0;
}
int StackLength(LinkStack *ls)
{
int i=0;
LinkStack *p=ls;
while(p!=NULL)
{
p=p->top;
i++;
}
return i;
}
ElemType GetTop(LinkStack *ls)
{
ElemType e;
if(ls==NULL)
return 0;
e=ls->data;
return e;
}
int Push(LinkStack *&ls,ElemType e)
{
LinkStack *p;
p=new struct stack[sizeof(LinkStack)];
p->data=e;
p->top=ls;
ls=p;
return 1;
}
int Pop(LinkStack *&ls,ElemType &e)
{
LinkStack *p;
if(ls==NULL)
return 0;
else
{
p=ls;
e=p->data;
ls=p->top;
free(p);
}
return 1;
}
//8． 访问栈中元素
void StackPrint(LinkStack *ls)
{
LinkStack *p=ls;
if(ls==NULL)
return ;
while(p!=NULL)
{

cout<<p->data<<" ";
p=p->top;
}

}
//9． 写一算法，利用栈操作判断一字符串是否是回文。
int huiwen(ElemType str[])
{
int i=0;
ElemType ch,temp;
LinkStack *ls;
InitStack(ls);
while((ch=str[i++])!='\0')
Push(ls,ch);
i=0;
while(!StackEmpty(ls))
{
Pop(ls,temp);
if(temp!=str[i++])
return 0;
}
return 1;
}
//10． 利用栈的基本信息，编写一个算法输入若干整数，以0标识输入结束。然后按与输入相反的次序输出这些数。
int Reverse()
{

ElemType ch;
LinkStack *ls;
InitStack(ls);
cout<<"请输入你要输入的整数:";
cin>>ch;
while(ch!=48)
{
Push(ls,ch);
cin>>ch;
}
while(!StackEmpty(ls))
{
Pop(ls,ch);
cout<<ch<<" ";
}
return 1;
}



//12． 利用栈进行括号匹配检验。
int Match(char str[])
{
int i=0;
LinkStack *ls;
InitStack(ls);
ElemType ch,e;
while(str[i]!='\0')
{
if(str[i]=='('||str[i]=='[')
{
Push(ls,str[i]);
ch=GetTop(ls);
}
else if(ch=='('&&str[i]==')')
{ Pop(ls,e);ch=GetTop(ls);}
else if(ch=='['&&str[i]==']')
{ Pop(ls,e);ch=GetTop(ls);}
else
return 0;
i++;
}
if(StackEmpty(ls))
return 1;
else
return 0;
}



//13． 利用栈计算，从键盘上输入任意十进制数，求其p进制数。
static char SwitchResult[100];
void Transform(int nDecimal,int nBase)
{
LinkStack *ls;
char ch;
int i=0;
if(nBase<=1||nBase>36||nBase==10)
{
printf("待转换的进制错误!\n");
exit(1);
}
InitStack(ls);
while(nDecimal!=0)
{
ch=(char)(nDecimal%nBase);
ch=ch+(ch<10?48:65-10);
Push(ls,ch);
nDecimal=nDecimal/nBase;
}
while(!StackEmpty(ls))
{
Pop(ls,ch);
SwitchResult[i++]=ch;
}
SwitchResult[i]='\0';
cout<<SwitchResult<<endl;
}


//////////////////////////////////////////////////////////////////////////////
////////////////
int In(char c) ////////////判断输入是否是运算符 //////////////////////
{
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='#')
return 1;
else
return 0;
}
char Precede(char x,char y) ///////判断优先权
{
if(x=='+'&&(y=='+'||y=='-'||y==')'||y=='#'))
return '>';
else if(x=='+'&&(y=='*'||y=='/'||y=='('))
return '<';
else if(x=='-'&&(y=='+'||y=='-'||y==')'||y=='#'))
return '>';
else if(x=='-'&&(y=='*'||y=='/'||y=='('))
return '<';
else if(x=='*'&&y!='(')
return '>';
else if(x=='*'&&y=='(')
return '<';
else if(x=='/'&&y!='(')
return '>';
else if(x=='/'&&y=='(')
return '<';
else if(x=='('&&y!=')'&&y!='#')
return '<';
else if(x==')'&&y!='(')
return '>';
else if(x=='#'&&y!=')'&&y!='#')
return '<';
else if((x=='('&&y==')')||(x=='#'&&y=='#'))
return '=';
else
{ cout<<"表达式错误"<<endl;return 0;}
}
int Operate(char a,char theta,char b) /////////计算出值
{
if(theta=='+')
return (((int)a-48)+((int)b-48));
else if(theta=='-')
return (((int)a-48)-((int)b-48));
else if(theta=='*')
return (((int)a-48)*((int)b-48));
else if(theta=='/')
return (((int)a-48)/((int)b-48));
else
{ cout<<"表达式错误"<<endl;return -9999;}

}
//11． 利用栈求表达式的值。////////////////////////////

double EvalueateExpression()
{
LinkStack *OPTR,*OPND;
char c,a,b,theta;
InitStack(OPTR);Push(OPTR,'#');
InitStack(OPND);c=getchar();
while (c!='#'||GetTop(OPTR)!='#')
{
if(!In(c))
{
Push(OPND,c);c=getchar();
}
else
switch(Precede(GetTop(OPTR),c))
{
case '<':
Push(OPTR,c);c=getchar();break;
case '=':
Pop(OPTR,c);c=getchar();break;
case '>':
Pop(OPTR,theta);
Pop(OPND,b);Pop(OPND,a);
// cout<<(char)(Operate(a,theta,b)+48)<<endl;
// cout<<Operate(a,theta,b)<<endl;
Push(OPND,(char)(Operate(a,theta,b)+48));
break;
default:break;
}
}
return ((int)GetTop(OPND)-48);
}
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////






void main()
{
cout<<"请输入你要计算的表达式:"<<endl;
cout<<EvalueateExpression()<<endl;
system("pause");///////////////////////////////////////////////////////////////////
cout<<"回文判断:"<<endl;
ElemType str1[]="abcdcba";
cout<<huiwen(str1)<<endl;
cout<<"逆序输出:"<<endl;
Reverse();
cout<<endl<<"括号匹配:"<<endl;
ElemType str2[]="[[[]()()]]()([])(([]))";
cout<<Match(str2);
cout<<endl<<"进制转换:"<<endl;
Transform(456,16);

ElemType e,a;
LinkStack *ls;
InitStack(ls);
Push(ls,'a');
Push(ls,'b');
Push(ls,'c');
Push(ls,'d');
Push(ls,'e');
cout<<"栈的访问:"<<endl;
StackPrint(ls);
cout<<"栈的长度为:"<<StackLength(ls)<<endl;
Pop(ls,e);
cout<<e<<endl;
Push(ls,'x');
Push(ls,'j');
Pop(ls,e);
cout<<e<<endl;
Pop(ls,e);
cout<<e<<endl;
ClearStack(ls);
cout<<"栈空与否:"<<StackEmpty(ls)<<endl;
Pop(ls,a);
cout<<a<<endl;
}

[tanchao90]

这是一个栈的类：


template<class T>
class CSeqStack
{
public:
CSeqStack(int sz=50);
~CSeqStack();

void Push(const T & x); //压栈
bool Pop(T &x); //弹出
bool getTop(T &x); //得到栈顶元素的值
bool IsEmpty()const;
bool IsFull()const;
int getSize()const;
void MakeEmpty();

private:
T * elements;
int top;
int maxSize;
void overflowProcess();

};

#endif // !defined(AFX_SEQSTACK_H__8CB25C80_4D13_46BE_8A90_5FC273CDD084__INCLUDED_)


template<class T>
CSeqStack<T>::CSeqStack(int sz):top(-1),maxSize(sz)
{
elements=new T[maxSize];
ASSERT(elements!=NULL);
}


template<class T>
CSeqStack<T>::~CSeqStack()
{
delete []elements;
}


template<class T>
void CSeqStack<T>::Push(const T & x) //压栈
{
if (IsFull()==true)
{
overflowProcess();
}
elements[++top]=x;
}


template<class T>
bool CSeqStack<T>::Pop(T &x) //弹出
{
if (IsEmpty()==true)
{
return false;
}
x=elements[top--];
return true;
}


template<class T>
bool CSeqStack<T>::getTop(T &x) //得到栈顶元素的值
{
if (IsEmpty()==true)
{
return false;
}
x=elements[top];
return true;
}


template<class T>
bool CSeqStack<T>::IsEmpty()const
{
return (top==-1)?true:false;
}


template<class T>
bool CSeqStack<T>::IsFull()const
{
return (top==maxSize-1)?true:false;
}


template<class T>
int CSeqStack<T>::getSize()const
{
return top+1;
}


template<class T>
void CSeqStack<T>::MakeEmpty()
{
top=-1;
}


template<class T>
void CSeqStack<T>::overflowProcess() //扩充栈的存储空间
{
T *newArray=new T[maxSize+10];
if (newArray==NULL)
{
cerr<<"存储分配失败！"<<endl;
// AfxMessageBox("存储分配失败！);
// return ;
exit(1);
}
for (int i=0;i<=top;i++)
{
newArray[i]=elements[i];
}
maxSize=maxSize+10;
delete []elements;
elements=newArray;
}

[Eleven]

STL queue or deque

[yt271]

各位大侠在发的时候加上标注吧，，我是菜鸟。。。谢谢。。拜托啦。。。