棧類

 1 public class MyStack<T> {
 2     //棧的大小
 3     private int size;
 4     //存放棧的數組
 5     private Object[] data;
 6     
 7     /**
 8      * 無參構造方法，初始化數組大小
 9      */
10     public MyStack() {
11         size = -1;
12         data = new Object[10];
13     }
14     
15     /**
16      * 有參構造方法，自定義數組大小
 
17      */
18     public MyStack(int len) {
19         size = 0;
20         if(len < 0) {
21             len = 5;
22         }
23         data = new Object[len];
24     }
25     
26     /**
27      * 出棧
28      * @param t
29      * @return
30      */
31     public boolean push(T t) {
32         if
 
(size == data.length) {
33             return false;
34         }else {
35             data[++size] = t;
36             return true;
37         }
38     }
39     
40     /**
41      * 入棧
42      * @return
43      */
44     public T pop() {
45         if(size == data.length) {
46             return
 
 null;
47         }else {
48             return (T) data[size--];
49         }
50     }
51     
52     /**
53      * 查看棧頂元素
54      * @return
55      */
56     public T peek() {
57         if(size == data.length) {
58             return null;
59         }else {
60             return (T) data[size];
61         }
62     }
63     
64     /**
65      * 查看數組大小
66      * @return
67      */
68     public int size() {
69         return size;
70     }

隊列類

 1 public class MyQueue<T> {
 2     //存放隊列的數組
 3     private Object[] data;
 4     
 5     /**
 6      * 無參構造方法，初始化數組大小
 7      */
 8     public MyQueue() {
 9         data = new Object[0];
10     }
11     
12     //入隊
13     public void add(T t) {
14         // 創建一個新的數組
15         Object[] newArr = new Object[data.length + 1];
16         // 把原數組中的元素復制到新數組中
17         for (int i = 0; i < data.length; i++) {
18             newArr[i] = data[i];
19         }
20         // 把添加的元素放入新數組中
21         newArr[data.length] = t;
22         // 使用新數組替換舊數組
23         data = newArr;
24     }
25     
26     //出隊
27     public T poll() {
28         //把數組中的第0個元素取出來
29         T element = (T) data[0];
30         //創建一個新的數組
31         Object[] newArr = new Object[data.length - 1];
32         //復制原數組中的元素到新數組中
33         for(int i = 0; i < newArr.length;i++) {
34             newArr[i] = data[i + 1];
35         }
36         //替換數組
37         data=newArr;
38         return element;
39     }
40     
41     //判斷隊列是否為空
42     public boolean isEmpty() {
43         return data.length == 0;
44     }
45     
46     /**
47      * 查看數組大小
48      * @return
49      */
50     public int size() {
51         return data.length;
52     }

線性結構——棧和隊列