编程实现一个堆栈类Stack,要有push()压栈方法,pop()出栈方法,clear()方法

 

1*编程实现一个堆栈类Stack,要求需要含有push()压栈方法,pop()出栈方法,clear()方法。

我们采用的是典型的封装，这里的堆栈采用先进后出的顺序存储数据，通过两个传统的堆栈操作来控制，这两种方法分别是压栈（pose）和出栈(pop).

如果在堆栈的上面加入一项，用压栈

如果从堆栈中取出一项，用出栈

Stack类实现整数的堆栈，参考代码如下：

//这个类定义一个变量

 

// This class defines an integer stack that can hold 10 values.

 

class Stack

{

       int stck[] = new int[10];

       int tos;

       // Initialize top-of-stack

       Stack()

      { 
          tos = -1; 
      }

      // Push an item onto the stack 

       void push(int item)

      {

          if(tos==9)

              System.out.println("Stack is full.");

          else

              stck[++tos] = item;

       }

        // Pop an item from the stack

         int pop()

        {

            if(tos < 0) {

                System.out.println("Stack underflow.");

                return 0;

             }
            else 
                return stck[tos--];
    }
}

Stack类定义了两个数据项，三个方法

整数堆栈由数组stck存储，该数组的下标是由变量t控制，该变量总是包含堆栈顶层的下标。

Stack（）构造函数将t初始化为-1，他指向一个空的堆栈。

push()方法将一个项目压入堆栈，为了重新的取回压入堆栈的项目，需要调用 pop()方法

既然存取数据通过Push()和pop()，数组中存储堆栈的事实实际上和使用的堆栈并不相关

例如，堆栈可以被存储在一个更复杂的数据结构中，比如说一个链表，但是Push()和Pop()定义的 接口还是一样的

代码类TestStack,验证Stack类，TestStack类产生两个整数堆栈，将一些值存入，然后将他们取出。

 

class TestStack {

 

public static void main(String args[]) {
Stack mystack1 = new Stack();
Stack mystack2 = new Stack();

// push some numbers onto the stack
for(int i=0; i<10; i++) mystack1.push(i);
for(int i=10; i<20; i++) mystack2.push(i);

// pop those numbers off the stack
System.out.println("Stack in mystack1:");
for(int i=0; i<10; i++)

System.out.println(mystack1.pop());

System.out.println("Stack in mystack2:");
for(int i=0; i<10; i++)
System.out.println(mystack2.pop());
}
}

产生的输出如下：

Stack in mystack1:
9
8
7
6
5
4
3
2
1
0
Stack in mystack2:
19
18
17
16

15
14
13
12
11
10

那么到这里我们已经看到了，每个堆栈中的内容是分离的。

关于Stack 类的最后值得注意的一点。正如它现在执行的一样，通过Stack 类外面的代码可以改变保存堆栈的数组stck 。这样的Stack 是开放的，容易误用或损坏。

如何补救这种情况呢？继续学习，，，待续