java 栈和队列的模拟--java

栈的定义：栈是一种特殊的表这种表只在表头进行插入和删除操作。因此，表头对于栈来说具有特殊的意义，称为栈顶。相应地，表尾称为栈底。不含任何元素的栈称为空栈。 
栈的逻辑结构：假设一个栈S中的元素为an,an-1,..,a1，则称a1为栈底元素，an为栈顶元 素。栈中的元素按a1 ,a2,..,an-1,an的次序进栈。在任何时候，出栈的元素都是栈顶元素。换句话说，栈的修改是按后进先出的原则进行的.因此，栈又称为后进先出(Last In First Out)表，简称为LIFO表。所以，只要问题满足LIFO原则，就可以使用栈。 
notice:换句话说,栈就是可以一个元素进后,可以接着进行输出的表.
java 模拟栈操作：

 package com.zsy.stack;
 /**
  * 栈 java 实现  先进后出
  * @author 偶my耶
  *
  */
 public class stack {
     private Object[] stack;

     //元素个数;
     private int size;

     //默认长度为10;
     public stack(){
         this(10);
     }

     //也可以自己设置长度,即容量;
     public stack(int len){
         stack = new Object[len];
     }

     //返回元素个数;
     public int size(){
         return size;
     }

     //返回数组长度,即容量;
     public int capacity(){
         return stack.length;
     }

     //实现动态的数组;
     public void ensureCapacity(){
         if(size() == capacity()){
             Object[] newStack = new Object[size() * 3 / 2 + 1];
             System.arraycopy(stack, 0, newStack, 0, size());
             stack = newStack;
         }
     }

     //入栈;
     public void push(Object o){
         size++;
         ensureCapacity();
         stack[size - 1] = o;
     }

     //判空;
     public boolean isEmpty(){
         return size == 0;
     }

     //出栈;
     public Object pop(){
         //首先要判空;
         if(isEmpty()){
             throw new ArrayIndexOutOfBoundsException("不能为空");
         }

         Object o = stack[--size];
         stack[size] = null;
         return o;
     }

     public static void main(String[] args) {
         stack stack = new stack(3);
         String[] data = new String[] { "a", "b", "c1" ,"f2","s3", "a4", "b5", "c6" , "a7", "b", "c" };
         for(String i:data)
         {    stack.push(i);
             System.out.print(i + "\t");
         }

         System.out.println("\n***********************************");
         while (!stack.isEmpty()) {
             System.out.print(stack.pop() + "\t");
         }
         //}
     }
 } 

运行效果：

队列
  在java5中新增加了java.util.Queue接口，用以支持队列的常见操作。该接口扩展了java.util.Collection接口。
Queue使用时要尽量避免Collection的add()和remove()方法，而是要使用offer()来加入元素，使用poll()来获取并移出元素。它们的优
点是通过返回值可以判断成功与否，add()和remove()方法在失败的时候会抛出异常。 如果要使用前端而不移出该元素，使用
element()或者peek()方法。
值得注意的是LinkedList类实现了Queue接口，因此我们可以把LinkedList当成Queue来用。

java代码模拟：

 package com.zsy.stack;
 /**
  *     java 队列实现 先进先出
  * @author 偶my耶
  *
  */
 public class Queue {

             private int maxSize; //队列长度，由构造函数初始化
             private long[] queArray; // 队列
             private int front; //队头
             private int rear; //队尾
             private int nItems;  //元素的个数

             public Queue(int s)           // 构造函数
                {
                maxSize = s;
                queArray = new long[maxSize];
                front = 0;
                rear = -1;
                nItems = 0;
                }

             public void insert(long j)    // 进队列
                {
                if(rear == maxSize-1)          // 处理循环
                   rear = -1;
                queArray[++rear] = j;          // 队尾指针加1,把值j加入队尾
                nItems++;
                }

             public long remove()          // 取得队列的队头元素。
                {
                long temp = queArray[front++]; // 取值和修改队头指针
                if(front == maxSize)            // 处理循环
                   front = 0;
                nItems--;
                return temp;
                }

             public long peekFront()       // 取得队列的队头元素。该运算与 remove()不同，后者要修改队头元素指针。
                {
                return queArray[front];
                }

             public boolean isEmpty()     // 判队列是否为空。若为空返回一个真值，否则返回一个假值。
                {
                return (nItems==0);
                }

             public boolean isFull()      // 判队列是否已满。若已满返回一个真值，否则返回一个假值。
                {
                return (nItems==maxSize);
                }

             public int size()            // 返回队列的长度
                {
                return nItems;
                }
         public static void main(String[] args)
            {
             Queue theQueue = new Queue(5);   // 队列有5个元素

            theQueue.insert(10);             // 添加4个元素
            theQueue.insert(20);
            theQueue.insert(30);
            theQueue.insert(40);

            theQueue.remove();               // 移除3个元素
            theQueue.remove();               // (10, 20, 30)
            theQueue.remove();

            theQueue.insert(50);             // 添加4个元素
            theQueue.insert(60);
            theQueue.insert(70);
            theQueue.insert(90);
            while( !theQueue.isEmpty() )     // 遍历队列并移除所有元素
               {
               long n = theQueue.remove();   // (40, 50, 60, 70, 80)
               System.out.print(n);
               System.out.print(" ");
               }
            System.out.println("");
            }
 }

运行效果：