如题：堆栈、队列有什么特点和区别？
谁可以形象化说明下，或者用程序模拟下这几种数据结构吗？

堆栈（先进后出）
队列（先进先出）

1. import java.util.ArrayList;
   
2. import java.util.List;
   
3. 
   
4. public class Demo {
   
5. 
   
6.         public static void main(String[] args)
   
7.         {
   
8.                 ArrayList aList = new ArrayList();
   
9.                 aList.add(32132);
   
10.                 aList.add("fws4");
    
11.                 aList.add("vsw");
    
12.                
    
13.                 stack(aList);
    
14.                 System.out.println("————————————————");
    
15.                 queue(aList);
    
16. 
    
17.         }
    
18.         
    
19.         public static void stack(List aList)// 队列
    
20.         {
    
21.                 for(int i=0; i<aList.size(); i++)
    
22.                 {
    
23.                         System.out.println(aList.get(i));
    
24.                 }
    
25.         }
    
26.         
    
27.         public static void queue(List aList)//堆栈
    
28.         {
    
29.                 for(int i=aList.size()-1; i>=0; i--)
    
30.                 {
    
31.                         System.out.println(aList.get(i));
    
32.                 }
    
33.         }
    
34. 
    
35. }

复制代码

List 简单模拟

堆栈的特点是：压栈，类似于水缸（先进后出）；
队列的特点是：类似于水管，（先进先出）。
用程序模拟的话， 就是用LinkedList集合的添加分别用addFirst方法和addLast方法，
                                                         获取分别用:getFirst方法和getLast方法操作。
示例代码如下

1. /**
   
2. * 模拟堆栈
   
3. * @author wuyong
   
4. *
   
5. */
   
6. class Stack{
   
7.         public Stack(){
   
8.                 add();
   
9.         }
   
10.         LinkedList<String> stack = new LinkedList<String>();
    
11.         int no;//元素的顺序从1开始
    
12.         public String get(){
    
13.                 return stack.getFirst();
    
14.         }
    
15.         public void add() {
    
16.                 while (no < 4) {
    
17.                         stack.addFirst("stack" + ++no);
    
18.                 }
    
19.         }
    
20. }
    
21. /**
    
22. * 模拟队列
    
23. * @author wuyong
    
24. *
    
25. */
    
26. class Queue{
    
27.         public Queue(){
    
28.                 add();
    
29.         }
    
30.         LinkedList<String> queue = new LinkedList<String>();
    
31.         int no;//元素的顺序从1开始
    
32.         public String get(){
    
33.                 return queue.getFirst();
    
34.         }
    
35.         public void add() {
    
36.                 while (no < 4) {
    
37.                         queue.addLast("stack" + ++no);
    
38.                 }
    
39.         }
    
40. }

复制代码

masai158 发表于 2014-8-20 23:23
堆栈（先进后出）
队列（先进先出）

强大，谢谢。

之前有人总结：栈是吃多了吐出来，队列是吃多了拉出来，这样记就好记了