Princeton Algorithms, Part I week2 stack&queue

stack:先进后出

queue:先进先出

首先是stack 有两种实现方式，第一种是用链表，第二种是用数组。

Stack: linked-list representation

stack: array implementation

 上面这个实现是固定长度的array implementation

非常不方便，所以引入可变长度的实现

resizing-array implementation

那么以什么方式去可变呢？不能每次都capacity满了就加1，或者少了就减1，这种方式代价太大

 正确的方式是当array满了以后，直接将数组的长度翻倍。

 原因是

 那么在缩减的时候该怎么缩减呢？

应该在当前array的1/4长度的时候再缩减而不是在1/2的时候，因为有一种极端情况就是，比如一共有8的长度，现在里面只有5个元素，pop出去一个，那么就需要缩减，然后又push进去，又要扩回8个，每次操作都是要访问N个元素 并且 赋值N个。下面是 java implementation

 1 public class ResizingCapacityStackofString{
 2 
 3            private String [] s;
 4            private int N = 0;
 5            public ResizingCapacityStackofString(){
 6 
 7                    s = new String[1];
 8 
 9   }
10            public ResizingCapacityStackofString(int capacity){
11 
12                    s = new String[capacity];
13 
14   }
15          public boolean isEmpty(){
16                return N == 0;
17 
18 }
19          public void push(String item){
20               if(N == s.length){resize(s.length * 2);}
21               s[N++] = item;
22 
23 }
24          private void resize(int capacity){
25                  String[] newArr = new string[capacity];
26                  for(int i =0;i <N;i++){
27                      newArr[i] = s[i];
28 }
29                  s = newArr;
30 }
31          public String pop(){
32                 Strting item = s[N--];
33                 if(N <= 1/4 * s.length){resize(s.length/2);}
34                 return item;
35                 
36 
37 
38 }
39 
40 
41 }