出栈的算法

① 1，2，3，4依次进栈，出栈随时，写一算法求出所有可能出栈序列

代码如下：

#define N 4

int m=0,a=0,b=N;/*m表示种数，a表示栈中元素个数，b表示外面还有需要进栈的个数*/

main()

{

inS(a,b);/*首先入栈*/

printf("%d",m);

getch();

}

int inS(int a,int b)/*入栈*/

{

a++;b--;/*入栈栈中元素+1，栈外元素-1 */

if(b>0)/*若栈外有元素，可以入栈*/

inS(a,b);

if(a>0)/*若栈中有元素，可以出栈*/

outS(a,b);

}

int outS(int a,int b)/*出栈*/

{

a--;/*出栈栈中元素-1*/

if(a==0&&b==0)/*若栈中元素和栈外元素都为0个*/

{

m++;/*则此种情况的序列满足条件，种数+1*/

return;

}

if(b>0)

inS(a,b);

if(a>0)

outS(a,b);

}

(1)出栈的算法扩展阅读

栈的相关知识点：

顺序栈内容包含数据和栈顶指针(int)，因此采用结构体。

注意：

1、初始时，top指向-1；

2、入栈让敏橡时，先判断顺序栈是否已满（判断条件：top=maxsize-1）;如果没满，则top++，并将元素值赋给s.top;

3、出栈时，先判断顺序栈是否已拿圆空（判断条件：top=-1）;如果没空，则先返回栈顶元素，再top- -。

共享栈

两个顺序栈共坦旁享一个一维数组空间，而栈底位置相对不变，两个栈底分别设为一维数组的两端。

note:

(1)栈空：top1==-1&&top2==maxsize;

(2)栈满：top2-top1= 1(此时两个栈顶指针相邻)；

(3)入栈：S.data[++top1]=x或S.data[–top2]=x;

(4)出栈：x=S.data[top1–]或x=S.data[top2++];

(5)共享栈可以更好的利用存储空间，整个存储空间被占满时发生上溢。

② 栈的运算遵循什么原则

栈的运算遵循（先进后出、后进先出）的原则。

例如从输入序列ABCDE中，先将A入栈， 然后接下来是要想办法让E先入栈。

首先，将B、C、D、E依次入栈， 这时候栈的输出序列数E、D、C、B、A，然后将E、D、C、B依次出栈， 现在输入的序列就是E、D、C、B （这里利用了栈的特点： 输入的序列经过了入栈出栈后，序列的携郑次序会颠倒）， 最后E、D、C、B依次入栈， 这时候，输出序列就是B、C、D、E、A。

(2)出栈的算法扩展阅读：

基本算法

进栈（PUSH）算法

1、若TOP≥n时，则给出溢出信息，作出错处理（进栈前首袭伍先检查栈是否已满，满则溢出；不满则作2）

2、置TOP=TOP+1（栈指针加1，指向进栈地址）

3、S(TOP)=X，结束（X为新进栈的元素）

退栈（POP）算法

1、若TOP≤0，则给出下溢信息，作出错处理(退栈前先检查是否已为空栈， 空则下溢；不空则作2)

2、X=S(TOP)，（退栈后拍隐或的元素赋给X）

3、TOP=TOP-1，结束（栈指针减1，指向栈顶）

③ 栈的出栈序列口诀是什么

出栈的顺序规律是排在前面的先出，排在后面的后出。

①若TOP≤0，则给出下溢信息，作出错处理(退栈亏缓前先检查是否已为空栈， 空雹空岩则下溢；不空则作②)；

②X=S(TOP)，（退栈后的元素赋给X）：

③TOP=TOP-1，结束（栈指针减1，指向栈顶）。

(3)出栈的算法扩展阅读：

栈是允许在同一端进行插入和删除操作的特殊线性表。允许进行插入和删除操作的一端称为栈顶(top)，另一端为栈底(bottom)；栈底固定，而栈顶浮动；栈中元素个数为零时称为空栈。插入一般称为进栈（PUSH），删除则称源御为出栈（POP）。栈也称为后进先出表。

④ 急求 共用堆栈的出栈算法

class LinkedList //定义双项链表{char data;LinkedList back;LinkedList forward;}interface Access //定义从队列和栈存取操作的接口{void put(char c);char get();}class Queue implements Access //定义队列类{private LinkedList QHead=new LinkedList();private LinkedList QRear=QHead; //初始化队头和队尾public void put(char c) //实现向队列存数的方法{QRear.forward=new LinkedList();QRear.forward.data=c;QRear.forward.back=QRear;QRear=QRear.forward;}public char get() //实现从队列取数的方法{if(QHead!=QRear) //如果队列不为空则取数{QHead.forward.back=null;QHead=QHead.forward;return QHead.data;}else{System.out.println("The queue is empty! ");return '\兆虚0';}}}class Stack implements Access //定义栈类{private LinkedList bottom=new LinkedList();private LinkedList top=bottom; //初始化栈顶与斩底public void put(char c) //实现从栈中存数的方法{top.forward=new LinkedList();top.forward.data=c;top.forward.back=top;top=top.forward;}public char get() //实现从栈族芦燃中取数的方法{if(top!=bottom) //如果栈不为空则取数{char ch=top.data;top.back.forward=null;top=top.back;return ch;}else{System.out.println("The stack is empty! ");return '\0';}}}public class StackQueue{public static void main(String[] args){char ch;Queue q=new Queue(); //创建一个队列qStack s=new Stack(); //创建一个栈sq.put('x');q.put('y');q.put('z'); //向队列q存入3个字符s.put('x');s.put('y');s.put('z'); //向栈s存入3个字符System.out.println("Queue: ");if((ch=q.get())!='\0')System.out.println(ch);if((ch=q.get())!='\0')System.out.println(ch);if((ch=q.get())!='\0')System.out.println(ch);if((ch=q.get())!='\0')System.out.println(ch);//从队列q中取数并显示System.out.println("Stack: ");if((ch=s.get())!='\0')System.out.println(ch);if((ch=s.get())!='\0')System.out.println(ch);if((ch=s.get())!='\0')System.out.println(ch);if((ch=s.get())!='\0')System.out.println(ch);//从哗档栈s中取数并显示}}引自：http://wenwen.soso.com/z/q104863.htm?ch=w.xg.ll

⑤ 链栈的入栈和出栈运算

1、栈（stack）又名堆栈，它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。2、例程：
#include <stdio.h>
#include <stdlib.h>
#define Max 100
typedef char T;

typedef struct MyStack
{
T aa[Max];
unsigned int p;

} stack;

/哪闹/创建空栈
stack* createEmptyStack()
{
stack* st = (stack *)malloc(sizeof(stack));
int i=0;
for(i=0;i<Max;i++)
st->aa[i]=0;
st->p=0;
return st;
};

//栈判空
int isEmpty(const stack* st)
{
if(st->p==0) return 1;
else return 0;
};

//求栈的大小
unsigned int size(const stack* st)
{
return st->p;
};

//push操作
void push(stack* st,const T a)
{
st->p=st->p+1;
if(st->p==Max)
{
printf("栈满\n");
st->p--;
return;
}
st->aa[st->p]=a;
};

//pop操作
T pop(stack* st)
{
if(isEmpty(st))
{
printf("栈空");
return NULL;
}
char t=st->aa[st->p];
st->p=st->p-1;
printf("隐拍%c ",t);
return t;
};

//栈销毁
void destroy(stack* st)
{
free(st);
};

int main()
{

stack* st = createEmptyStack();
if(isEmpty(st)) printf("MyStack is empty\n");
else printf("MyStack is not empty\n");
push(st,'a');
push(st,'b');
push(st,'c'灶缓羡);
push(st,'d');
push(st,'e');
printf("%d\n",size(st));
while(!isEmpty(st)) pop(st);
destroy(st);
system("pause");
return 0;
}

⑥ 货物出栈进栈算法

进栈出栈满足先进后漏森出顺序，所世搜渣以进栈要先进搜悄生产日期后进，分别用两个函数程序编写，主程序满足进栈出栈就可以了

⑦ 栈的进出算法..

栈数据操作是先进后出，后进先出，但是这是说已经存储在栈的数据，对于尚未进栈的数据流，这种说法是不正确的。拿上面的例子说，分别说明：A：1进栈，1出栈，2进栈，3进栈，3出栈，2
出栈，4进栈，4
出栈B：1进栈，2进栈，3进栈，3出栈，4进栈，4出栈，2
出栈，1
出栈D：1进栈，2进栈，2出栈，3进栈，3出栈，4进栈，4
出栈，1
出栈
C答案明显是1，2，3，4顺序进栈，出栈顺序只能是4，3，2，1，圆敬1是
不能比2
先出栈，因为1，2已经在栈，而且1比2现进栈。所以，渣庆在判断出栈顺序的时候，需要考虑在进栈的如腔握过程中是否有栈元素出栈，而不能只考虑所有元素进栈后的出栈顺序。

⑧ 栈的顺序结构和入栈、出栈算法

typedef struct {
SElemType *base;/*设栈顶栈底两指针的目的是便于判断栈是否为空*/
SElemType *top;/*栈的当前可使用的肆友型最大容量*/
int StackSize;
}SqStack;

int Push(SqStack &S,SElemType e){
if(S.top-s.base>=S.stacksize){
S.base=(ElmenType *)realloc(S.base,
(S.stacksize+STACKINCREMENT)*sizeof(ElemType));
if(!S.base)exit(OVERFLOW);
S.top=S.stacksize;
S.stacksize+=STACKINCREMENT;
}/*Push*/
*S.top++=e;
return OK;
}

int Pop(SqStack &S,SElenType &e){
if(空缺裂猜部分)return ERROR;
e=*--S.top;
return OK;
}/告春*Pop*/

⑨ 入栈出栈题目怎么做

栈的原则是先进后出，进栈序列为el，e2，e3，e4，芹信不是说一次性进入的，而是先进了el，e2，这时候出栈的话一定出e2，e3，e4又进栈，这时候出栈顺序就是e4，e3，el 了，总的出栈顺序就是e2，e4，e3，渣州el 了。

栈的特点是先进后出，即：进去的早，出来的晚。

54321进栈，5在栈底，1在栈顶！

出一次栈，则栈顶的1先出来，2成为新的栈顶。

ABCD入栈，D成为新的栈顶。

全部出栈：D C B A 2 3 4 5

综上，所有元素退栈顺序为：1 D C B A 2 3 4 5

进栈（PUSH）算法

①若TOP≥n时，则给出溢出信息，作出错处理（进栈前首先检查栈是否已满，满则溢出；不满则作②）；

②置TOP=TOP+1（栈指针加1，指向进栈地址）；

③S(TOP)=X，结束（X为新进栈的元素）；

退栈（POP）算法

①若TOP≤0，则给出下溢信息，作出错处理(退栈前先检查是否已为空栈， 空则下溢；不空则作嫌梁轮②)；

②X=S(TOP)，（退栈后的元素赋给X）：

③TOP=TOP-1，结束（栈指针减1，指向栈顶）。

以上内容参考：网络-栈

⑩ 栈的入栈和出栈的顺序规律是什么

入栈的顺序规律是排在前面的先进，排在后面的后进。

栈中的数据只有一种方式出栈，即先进后出，所以出栈的可能数目跟入栈的可能排列数目是一致的。a的出入有2中可能，b的出入有2种可能，c的出入有2种可能，d只需要关系入，只有一种可能。所以可能的出栈方式数为2*2*2*1=8种。

入栈顺序：a、b、c、d。出栈顺序可以是：d、c、b、a；a、b、c、d;b、a、c、d很多，但要把栈想象成一个没盖子的纸箱，取出东西时只能从最上层取，放进东西也只能放在最上层，所以栈是一个“后进先出”或“先进后出”的顺序存储结构。

相关介绍：

栈又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。

向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。