算法 学习笔记 构造一个栈

定容String栈

public class FixedCapacityStackOfString {
    private String[] a;
    private int N;
    public FixedCapacityStackOfString(int cap){
        a = new String[cap];
        N = 0;
    }
    public boolean isEmpty(){
        return N ==0;
    }
    public int size(){
        return N;
    }
    public void push(String item){
        a[N++] = item;
    }
    public String pop(){
        return a[--N];
    }
}

测试：

public class FixedCapacityStackOfString_test {
    public static void main(String[] args) {
        FixedCapacityStackOfString a = new FixedCapacityStackOfString(10);
        System.out.println(a.isEmpty());
        a.push("first");
        System.out.println(a.isEmpty());
        System.out.println(a.size());
        a.push("second");
        System.out.println(a.pop());
    }
}

测试结果

true
false
1
second

定容泛型栈

public class FixedCapacityStackOfString<item> {
    private item[] a;
    private int N;
    public FixedCapacityStackOfString(int cap){
        a = (item[]) new Object[cap];
        N = 0;
    }
    public boolean isEmpty(){
        return N ==0;
    }
    public int size(){
        return N;
    }
    public void push(item item){
        a[N++] = item;
    }
    public item pop(){
        return a[--N];
    }
}

测试

public class FixedCapacityStackOfString_test {
    public static void main(String[] args) {
        FixedCapacityStackOfString<Integer> a = new FixedCapacityStackOfString<Integer>(10);
        System.out.println(a.isEmpty());
        a.push(1);
        System.out.println(a.isEmpty());
        System.out.println(a.size());
        a.push(2);
        System.out.println(a.pop());
    }
}

测试结果

true
false
1
2

非定容泛型栈

public class FixedCapacityStackOfString<item> {
    private item[] a;
    private int N;
    public FixedCapacityStackOfString(int cap){
        a = (item[]) new Object[cap];
        N = 0;
    }
    public boolean isEmpty(){
        return N ==0;
    }
    public int size(){
        return N;
    }
    public void resize(int max){
        item[] temp = (item[]) new Object[max];
        for (int i = 0;i<N;i++){
            temp[i] = a[i];
        }
        a = temp;
    }
    public void push(item item){
        if (N == a.length){
            resize(2*a.length);
        }
        a[N++] = item;
    }
    public item pop(){
        item item = a[--N];
        a[N] = null;
        if (N>0 && N == a.length/4){
            resize(a.length/2);
        }
        return item;
    }
}

测试

public class FixedCapacityStackOfString_test {
    public static void main(String[] args) {
        FixedCapacityStackOfString<Integer> a = new FixedCapacityStackOfString<Integer>(2);
        a.push(1);
        a.push(2);
        a.push(3);
        a.push(4);
        System.out.println(a.pop());
    }
}

测试结果

4

可以遍历的非定容泛型栈

import java.util.Iterator;

/*引入Iterable接口来保证一定有可以遍历的函数*/
public class FixedCapacityStackOfString<item> implements Iterable{
    private item[] a;
    private int N;
    public FixedCapacityStackOfString(int cap){
        a = (item[]) new Object[cap];
        N = 0;
    }
    public boolean isEmpty(){
        return N ==0;
    }
    public int size(){
        return N;
    }
    public void resize(int max){
        item[] temp = (item[]) new Object[max];
        for (int i = 0;i<N;i++){
            temp[i] = a[i];
        }
        a = temp;
    }
    public void push(item item){
        if (N == a.length){
            resize(2*a.length);
        }
        a[N++] = item;
    }
    public item pop(){
        item item = a[--N];
        a[N] = null;
        if (N>0 && N == a.length/4){
            resize(a.length/2);
        }
        return item;
    }
    /*返回一个Iterator,实际为函数ReverseArrayIterator*/
    @Override
    public Iterator<item> iterator() {
        return new ReverseArrayIterator();
    }
    /*该函数为内容函数,内部函数可以使用外部函数的变量*/
    private class ReverseArrayIterator implements Iterator<item>{

        private int i = N;

        @Override
        public boolean hasNext() {
            return i>0;
        }

        @Override
        public item next() {
            return a[--i];
        }

        @Override
        public void remove() {

        }
    }
}

测试

import java.util.Iterator;

public class FixedCapacityStackOfString_test {
    public static void main(String[] args) {
        FixedCapacityStackOfString<Integer> a = new FixedCapacityStackOfString<Integer>(2);
        a.push(1);
        a.push(2);
        a.push(3);
        a.push(4);
        Iterator<Integer> iterator = a.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

测试结果

4
3
2
1