Java实现堆栈（Stack)

编程题目： 请用Java实现堆栈（Stack)

堆栈实现的三种方式：
（1）通过数组实现一个堆栈；
（2）通过集合实现一个堆栈；
（3）通过两个队列实现一个堆栈。
示例代码：
（1）通过数组实现一个堆栈：

package program.stack.arrayImpl;

/**
* 1.使用数组实现堆栈功能，使用int数组保存数据特点：先进后出，后进先出
*/

public class StackTest1 {  
    public static void main(String[] args){  

        //测试堆栈
        System.out.println("1.数组实现一个堆栈：");
        Stack stack = new Stack();  
        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.push(4);
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        stack.push(5);
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack.pop());

    }  
}  

//使用数组定义一个堆栈
class Stack {  

    int[] a = new int[5];  
    int i = 0; //数组下标

    //入栈 
    public void push(int n){  
      a[++i] = n; 
    }  

    //出栈
    public int pop(){  
      if(i>0){  
         return a[i--];  
      }
      return -1;  
    }  

}  

（2）通过集合实现一个堆栈：

package program.stack.listImpl;

import java.util.*;

/**
* 2.使用集合实现堆栈功能，使用int数组保存数据特点：先进后出，后进先出
*/

public class StackTest2 {  
    public static void main(String[] args){  

        //测试堆栈
        System.out.println("2.集合实现一个堆栈：");
        Stack stack = new Stack();  
        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.push(4);
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        stack.push(5);
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack.pop());

    }  
}  

//使用集合定义一个堆栈
class Stack { 

    List<Integer> list = new ArrayList<Integer>();  
    int index = 0; //下标 

    //入栈
    public void push(int n){  
        list.add(n);  
        index++;  
    } 

    //出栈
    public int pop(){  
       if(!list.isEmpty()){  
           index--;  
           return list.remove(index);  
       }  
       return -1;  
    }  
}  

（3）通过两个队列实现一个堆栈：

package program.stack.twoQueueImpl;

import java.util.ArrayDeque;
import java.util.Queue;

/**
 * 3.两个队列实现一个堆栈
 *  1.原理分析：
 *  栈的主要操作有两个：入栈操作和出栈操作，出栈时从栈顶出，入栈是从栈顶插入。
 *  入栈和入队类似，都是从“所有元素后面插入”；而最关键的问题是出栈操作，要出栈的是的栈顶元素，
 *  而队列每次出队的是队列的第一个元素。因此我们可以这样，出队的时候，若队列不止一个元素，则进行出队 操作，
 *  只保留最后一个元素，这样出队的时候，就符合出栈的要求了，但其他的元素必须 保留，而且顺序不能乱，
 *  这时候另一个队列就起作用了，这个队列可以在“出栈”操作之前按顺序保留所有的元素，等到“出栈”之后，
 *  把所有元素按顺序进入到“出栈”后的队列。因此两个队列总有一个为空。
 *
 *  2.总结操作就是：
 *  入栈：将元素进队列A
 *  出栈：判断队列A中元素的个数是否为1，如果等于1，则出队列，否则将队列A中的元素  以此出队列并放入队列B，
 *  直到队列A中的元素留下一个，然后队列A出队列，再把  队列B中的元素出队列以此放入队列A中。
 *
 */
public class StackTest3 {
     public static void main(String[] args) {

         System.out.println("3.两个队列实现一个堆栈：");
         Stack stack = new Stack();
         stack.push(1);
         stack.push(2);
         stack.push(3);
         stack.push(4);
         System.out.println(stack.pop());
         System.out.println(stack.pop());
         stack.push(5);
         System.out.println(stack.pop());
         System.out.println(stack.pop());
         System.out.println(stack.pop());   

    }

}
//两个队列实现一个堆栈
class Stack {

    Queue<Integer> queueA = new ArrayDeque<Integer>();
    Queue<Integer> queueB = new ArrayDeque<Integer>();

    //入栈
    public void push(int n){
        queueA.add(n);
    }

    //出栈
    public int pop(){
        //如果queueA为空，queueB有元素， 将queueB的元素依次放入queueA中，直到最后一个元素，我们弹出。
        if(queueA.isEmpty()){
            while (queueB.size() > 1) {
                queueA.add(queueB.poll());//poll()移出并返回队列的头元素,如果队列为空，则返回null
            }
            return queueB.poll();
        }
        if(queueB.isEmpty()){
            while (queueA.size() > 1) {
                queueB.add(queueA.poll());
            }
            return queueA.poll();
        }
        return -1;
    }
}

结果显示：

版权声明：本文为CSDN博主「云魄」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/jsc123581/article/details/81986830