堆栈操作！！

[YZZ2086]

情况是这样的：
我用一个指针变量pstack来存储栈顶的地址，先将堆栈列表在内部存储为数组，
经过pop（）操作之后，pstack-1，
经过push（）操作之后，pstack+1；

问题是:1、我怎样将栈内的 操作数提出？
2、提出后原来位置的内容会有怎样的变化？？？？？？
3、怎样将操作之后的栈内数全部cout出来？？

[lann64]

1，指针解引用
2，你想让它有怎样的变化就怎样实现
3，用指针遍历数组到头

[Vegertar]

stack不能随机提取, 要抽取其中一个数据, 要将上面的全部pop

[lsldd]

void pop（）
{
cout << *(pstack--);
}

[YZZ2086]

关键是我把栈定的数pop出去之后，pstack-1之后，原来的位置即pstack指向的内容那去了，
pop的实质操作是什么？？？？

[fvflove]

//以下是我在VS2005 C#下做的一个栈类.你可以参考一下.
 class mStack
   {
      private  ArrayList m_List = new ArrayList();
      private int m_Index = 0;

      public void Clear()  //置空栈
      { m_List.Clear(); m_Index = 0;}

      public bool isEmpty
      {
         get{ return m_List.Count == 0;}
      }

      public void Push(string Data)
      {
          m_Index = m_Index + 1;
          m_List.Add(Data);
      }

     public string Pop()
     {
         string x;
         x = m_List[m_List.Count - 1].ToString();

         m_List.Remove(x);

         m_Index = m_Index - 1;

         return x;
     }

     public string GetTop
     {
         get { return m_List[m_List.Count - 1].ToString();}
     }

     public int Count
     {
         get { return m_Index; }
     }

   }

[lann64]

你是在用数组做模拟栈操作，那何必关心原来的内容，原来的内容还在数组里呗，你也可以在pop函数里把那个内容清0什么的。

[Gump_BlueSky]

#include <iostream>
#include <vector>

using namespace std;

class iStack
{
public:
	iStack( int capacity ) : _stack( capacity ), _top( 0 ){}

	bool pop( int &value );
	bool push( int value );

	bool full(){ return _top < _stack.size() - 1 ? false : true; }
	bool empty(){ return _top ? false : true; }
	void display();

	int size(){ return _top; }

private:
	int _top;
	vector< int > _stack;
};

bool iStack::pop( int &value )
{
	if( empty() )
		return false;

	value = _stack[ --_top ];
	return true;
}

bool iStack::push( int value )
{
	if( full() ) 
		return false;

	_stack[ _top++ ] = value;
	return true;
}

void iStack::display()
{
	if( !size() )
		cout << "stack is empty!" << endl;

	for( int i = 0; i < _top; ++i ){
		cout << _stack[ i ] << " ";
	}

	cout << endl;
}

[zhuwanglove]

1楼讲得很明白了. 还有棧和数组都是顺序存储的.栈只在一端操作，数组可以随机访问．

[kkndciapp]

队列：先进先出
堆栈：先进后出

[liubuweiright]

#include <stdio.h>
#include <malloc.h>

typedef int DataType;
struct Node;
typedef struct Node * PNode; //指向结点的指针类型
struct Node
{
DataType info;
PNode link;
};
struct LinkStack
{
PNode top;
};
typedef struct LinkStack * PLinkStack; //链接栈类型的指针类型

PLinkStack createEmptyStack_link(void ) //创建一个空链栈
{
PLinkStack plstack;
plstack = (PLinkStack)malloc(sizeof(struct LinkStack));
if(plstack != NULL)
plstack -> top = NULL;
else
printf("Out of space ! \n");
return (plstack);
}

int isEmptyStack_link(PLinkStack plstack) //判断单链开式栈是否为空栈
{
return (plstack ->top == NULL);
}
void push_link(PLinkStack plstack,DataType x)//在栈中压入一个元素
{
PNode p;
p = (PNode)malloc(sizeof(struct Node));
if(p == NULL)
printf("Out of space!\n");
else
{
p -> info = x;
p ->link = plstack -> top;
plstack -> top = p;
}
}

void pop_link(PLinkStack plstack) //出栈
{
PNode p;
if(isEmptyStack_link(plstack))
printf("Empty stack pop.\n");
else
{
p = plstack -> top;
plstack -> top = plstack -> top -> link;
printf("pop:%d\n",p -> info);
free(p);

}
}

DataType top_link(PLinkStack plstack) //取栈顶元素
{
if(plstack -> top == NULL)
{
printf("Stack is empty1 \n");
return -99999;
}
else
return (plstack -> top -> info);
}
void printAll_link(PLinkStack plstack) //输出所有
{
PLinkStack p;
p = plstack;
while(p -> top)
{
printf("%d ",p -> top ->info);
p -> top = p -> top -> link;
}
}


void main()
{
PLinkStack One;
One = createEmptyStack_link();
if(isEmptyStack_link(One))
{
printf("One 栈为空! \n");
}
for(int i = 0 ;i < 100;i++)
push_link(One, i);
printf("push: %d\n",top_link(One));
pop_link(One);
printAll_link(One);

}

结果:
One 栈为空!
push: 99
pop:99
98 97 96 95 94 93 92 91 90 89 88 87 86 85 84 83 82 81 80 79
78 77 76 75 74 73 72 71 70 69 68 67 66 65 64 63 62 61 60 59
58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39
38 37 36 35 34 33 32 31 30 29 28 27 26 25 24 23 22 21 20 19
18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 Press any key
to continue