编写一个算法程序实现在一个顺序栈中把一个字符串逆置的运算，要求使用入栈和出栈运算来完成。

试设计一个算法，利用栈和队的基本运算，将队列 Q 中的全部元素逆置存放。~

算法思想很简单，就是输入字符串依次入队列b，然后在把队列中元素依次做出对操作并把返回值入栈a，然后再依次出栈并把返回值入队列c。
最后输出逆置操作前，即b中的元素；
输出逆置操作后，即c中的元素；

代码如下：
//---------------------------------------------------------------------------

#include
#include

typedef struct node{
char data;
struct node *next;
}node;

typedef struct {
node *top;
unsigned int size;
} stack;

typedef struct{
node *front;
node *back;
unsigned int size;
} queue;

char pops(stack *a)
{
node *tf=NULL;
char rt=0;
if (a->size) {
tf=a->top;
a->top=a->top->next;
--a->size;
rt=tf->data;
free(tf);
}

return rt;
}

char popq(queue *a)
{
node *tf=NULL;
char rt=0;
if (a->size) {
tf=a->front;
a->front=a->front->next;
--a->size;
rt=tf->data;
free(tf);
}
return rt;
}

void push(stack *a,const char c)
{
node *t=(node*)malloc(sizeof(node));
if (t) {
t->data=c;
t->next=a->top;
a->top=t;
++a->size;
}
}
void push_back(queue *a,const char c)
{
node *t=(node*)malloc(sizeof(node));
if (t) {
t->data=c;
t->next=NULL;
if (!a->size) {
a->front=a->back=t;
}
else
{
a->back->next=t;
a->back=t;
}

++a->size;
}
}

int isempty(void *a,int tp)
{
if (tp==1) return !(((stack *)a)->size);
else return !(((queue *)a)->size);
}
void initqs(void *a,int tp)
{
if (tp==1) {
((stack*)a)->top=NULL;
((stack*)a)->size=0;
}
else{
((queue*)a)->front=((queue*)a)->back=NULL;
((queue*)a)->size=0;
}
}

void del(void *a,int tp)
{
node *t;
if (tp==1) {
while (((stack*)a)->top){
t= ((stack*)a)->top;
((stack*)a)->top=((stack*)a)->top->next;
free(t);
}
free(a);
}
else {
while (((queue*)a)->front){
t= ((queue*)a)->front;
((queue*)a)->front=((queue*)a)->front->next;
free(t);
}
free(a);
}
}
void chk()
{
char ch;
int fg=1,rt=0;

stack *a=(stack*)malloc(sizeof(stack));
queue *b=(queue*)malloc(sizeof(queue));
queue *c=(queue*)malloc(sizeof(queue));
queue *temp = (queue *)malloc(sizeof(queue));
if (!a||!b||!c||!temp) {
fprintf(stderr,"MEMORY ERROR");
exit(-1);
}
initqs(a,1);
initqs(b,0);
initqs(c,0);
initqs(temp,0);

puts("Enter a string ,end with @");
while ((ch=getchar())!='@')
{
push_back(b,ch);
push_back(temp,ch);
}
while (!isempty(temp, 0))
push(a, popq(temp));

while (!isempty(a,1))
push_back(c, pops(a));

printf("执行逆序算法前：");
while (!isempty(b, 0))
{
printf("%c ", popq(b));
}
printf("
执行逆序算法后：");

while (!isempty(c, 0))
printf("%c ", popq(c));
printf("
");

del(a,1);
del(b,0);
del(c,0);
del(temp,0);

}
int main(void)
{
chk();

return 0;
}

C语言版，其他语言类似，思想就这样了
void reverse(int a[],int n)
{
int i;
for(i=0;i<n/2;i++)
{
push(s,a[i]);
a[i]=a[n-i-1];
pop(s,a[n-i-1]);
}
}

void ReverseString(char *a,int lenth) //逆转函数
{
int i;
char c;
initstack(&s);
for(i=0;i<lenth;i++) Push(&s,a[i]);
for(i=0;i<lenth;i++) {Pop(&s,&c);a[i]=c;}
}

---------------------------------------------------------------------
typedef struct //循环队列定义
{
int data[4];
int front;
int rear;
}SeqQueue;

void InitQueue(SeqQueue *Q) //初始化函数
{
Q->front=Q->rear=0;
}
int EnterQueue(SeqQueue *Q,int x) //入队函数
{
if((Q->rear+1)%4==Q->front) return 0;
Q->data[Q->rear]=x;
Q->rear=(Q->rear+1)%4
return 1;
}

写个main函数调用两次入队即可！

用什么语言写呢

typedef char ElemType;

typedef struct {
ElemType *stack;
ElemType * top;
int MaxSize;
} Stack；

typedef struct {
ElemType *queue;
int front, rear;
} Queue;

void HuiWen(char str[ ]){
Queue myQueue;
Stack myStack;
char x, y;
int i, length;
length = strlen(str);
InitQueue (myQueue);
InitStack (myStack);
for ( i=0; i<length; i++ ) {
EnQueue ( myQueue, str[i] );
Push( myStack, str[i] );
}
while ( ! EmptyQueue( myQueue ) && ! EmptyStack( myStack ) )
{
x = DeQueue( myQueue ) ;
y = Pop( myStack );
if ( x!=y )
{
cout<<str<<“不是回文”<<endl;
return;
}
}
cout<<str<<“是回文”<<endl;
}

---

阳山县13617471246： 栈的基本运算程序编写一个程序,实现顺序栈的如下各种基本运算,并在此基础上设计一个主程序验证其正确性:(1)初如化栈S.(2)判断栈S是否非空.... - ？
慕苑胰酶：[答案] #includetypedef struct node{ int num; struct node *next;}*link,LINK;void empty(link top){ top=NULL;}int pd(link top){ if(top==NULL) { return 0; } else {...

阳山县13617471246： 1、编写一个算法程序实现在一个顺序栈中把一个字符串逆置的运算,要求使用入栈和出栈运算来完成.求牛人给 - ？
慕苑胰酶： typedef char ElemType;typedef struct {ElemType *stack;ElemType * top;int MaxSize; } Stack;typedef struct {ElemType *queue;int front, rear; } Queue;void HuiWen(char str[ ]){Queue myQueue;Stack myStack;char x, y;int i, length;length =...

阳山县13617471246： 栈的操作编写实现顺序栈的各种基本操作的算法,并在此基础上完成如下功能:(1)初始化栈S;(2)判断栈S是否为空;(3)依次将元素a,b,c,d,e进栈S;(4)判... - ？
慕苑胰酶：[答案] 头文件: #ifndef _SeStack_struct_h #define _SeStack_struct_h // void visit(SElemType &); Status InitStack(SqStack &S); /* 构造一个空栈S */ Status DestroyStack(SqStack &S); /* 销毁栈S,S不再存在 */ Status ClearStack(SqStack &S); /* 把S置为...

阳山县13617471246： 编写算法,利用栈将字符串逆置. - ？
慕苑胰酶： 思路就是这样啊 栈的特点就是先进后出 所以完全可以用单向链表来模拟,只要是pop、push函数正确就可以 所以这个问题就可以简化为单向链表反转的问题了 两种方式 非递归 pQueue converse(pQueue t) { tp p1, p2, tmp; int flag = 0; ...

阳山县13617471246： 用c语言编写一个程序实现顺序栈的初始化,出栈和入栈.急需,谢谢 - ？
慕苑胰酶： #define STACK_SIZE 100 #define PUSH_POP_SUCCESS 1 #define PUSH_POP_ERROR 0struct _stackbuf {int _collection[STACK_SIZE];int _top; }; typedef struct _stackbuf S_STACK; typedef unsigned int u_int_f;// 入栈 u_int_f push(S_...

阳山县13617471246： 用C语言编程实现顺序栈的基本操作. - ？
慕苑胰酶： # include# include # define M 10 struct student { int number; struct student *next,*prev; }; struct student *p,*pp,*fornt,*po,*q,*top=NULL; struct student *del(struct student *top); struct student *add(struct student *top); void main() { int i=1; while(i<=M) { ...

阳山县13617471246： 编写一个算法利用顺序栈判断一个字符串是否是对称串 - ？
慕苑胰酶： ElemType ch[]={'a','a','a'}; // 没有加字符串结束标记,导致比较的字符串为随机值 应改为 ElemType ch[]={'a','a','a', '\0'};

阳山县13617471246： 编写算法实现将一个顺序栈中的所有元素一次取出并输入? - ？
慕苑胰酶： memcpy(目的变量,顺序栈,栈大小);

阳山县13617471246： C++: 编写程序,求一个顺序栈的判空操作,清空操作与求栈长操作,入栈操作和出栈操作, - ？
慕苑胰酶： template<class Type> Stack<Type>::Stack() {count=0;maxSaveCount=8;data=new Type[maxSaveCount]; //默认初始化分配可以存储8个数据大小的内存空间 }template<class Type> bool Stack<Type>::isEmputy() //判断栈是否为空 {return ...

阳山县13617471246： 用顺序栈实现回文完整的程序编写 - ？
慕苑胰酶： /*** 判断是否是回文对*/public static boolean judge(final String str){ Stack stack = new Stack();int length =str.length()/2;char[] ch=str.toCharArray();//一半的元素入栈for(int i=0;istack.push(ch[i]); } //根据字符串长度的奇偶决定比较开始的...