用数组实现栈、队列、动态数组

 一、栈

package com.kfm.it.Strictice;

public abstract class Stack {
    /**
     * 将元素压入栈顶
     * 入栈
     * @param element 要压入的元素
     */
    abstract void push(Object element);

    /**
     * 弹出栈顶元素并返回
     * 把栈顶元素删除，并返回
     * 出栈
     * @return 弹出的栈顶元素, 如果栈为空返回 null
     */
    abstract Object pop();

    /**
     * 返回栈顶元素，但不弹出
     * @return 栈顶元素
     */
    abstract Object peek();

    /**
     * 检查栈是否为空
     * @return 如果栈为空则返回true，否则返回false
     */
    abstract boolean isEmpty();

    /**
     * 返回栈中的元素个数
     * @return 栈中元素的个数
     */
    abstract int size();
}

package com.kfm.it.Strictice;

import java.util.Arrays;

public class MyStack extends Stack {
    /*
    存元素的数组
     */
    private Object[] value;
    /*
    存元素的下标
     */
    private int length;
    /*容量
     */
    private static final int DEFAULT_CAPACITY = 10;

    public MyStack() {
        this(DEFAULT_CAPACITY);
    }

    public MyStack(int capacity) {
        if (capacity < 0) {
            capacity = DEFAULT_CAPACITY;
        }
        value = new Object[capacity];
    }

    @Override
    public void push(Object element) {
        if (length + 1 > value.length){
            add();
        }
        value[length++]=element;
    }

    private void add() {
        int oldCapacity = value.length;
        int newCapacity = oldCapacity+oldCapacity >>1;  //1.5
        if (oldCapacity>newCapacity){
            newCapacity = Integer.MAX_VALUE;
        }
        value = Arrays.copyOf(value,newCapacity);
    }

    @Override
    Object pop() {
        Object element = value[length - 1];
        value[length - 1] = null;
        length--;
        return null;
    }

    @Override
    Object peek() {
        return value[length - 1];
    }

    @Override
    boolean isEmpty() {
        return length == 0;
    }

    @Override
    int size() {
        return length;
    }
}

package com.kfm.it.Strictice;

public class MyStackTest {
    public static void main(String[] args) {
        MyStack myStack = new MyStack();
        myStack.push("1");
        myStack.push("a");
        System.out.println(myStack.size());//长度
        System.out.println(myStack.pop());//
        System.out.println(myStack);
    }
}

二、动态数组 

package com.kfm.it.Array1;

import java.util.Arrays;
import java.util.function.Consumer;

public class DynamicArray {
    private int size = 0;
    private int capacity = 8;//容量
    private int[] array = {};

    public void addLast(int element) {
        //array[size++] = element;
        add(size, element);
    }

    public void add(int index, int element) {
        //1 2 3 4 5 6 7   index =3  element 9   1 2 9 3 4 5 6 7
//检查容量
        CheckAndGrow();

        if (index >= 0 && index < size) {
            System.arraycopy(array, index, array, index + 1, size - index);
        }
        array[index] = element;
        size++;
    }

    private void CheckAndGrow() {
        if (size == 0){
            array =new int[capacity];
        }else  if (size == capacity) {
            //扩容1.5
            capacity += capacity >> 1;
            int[] newArray = new int[capacity];
           System.arraycopy(array,0,newArray,0,size);
           array = newArray;
        }
    }

    public int get(int index) {
        return array[index];
    }

    public void foreach(Consumer<Integer> consumer) {
        for (int i = 0; i < size; i++) {
            consumer.accept(array[i]);
            //System.out.println(array[i]);
        }

    }

    public int remove(int index) {
        int removeed = array[index];

        System.arraycopy(array, index + 1, array, index, size - index - 1);
        size--;
        return removeed;
    }
}

package com.kfm.it.Array1;

import java.util.Arrays;

public class TestDynamicArray {

    public static void main(String[] args) {
        DynamicArray dynamicArray = new DynamicArray();
        dynamicArray.addLast(1);
        dynamicArray.addLast(2);
        dynamicArray.addLast(3);
        dynamicArray.addLast(4);
        dynamicArray.remove(2);


        dynamicArray.add(3,9);

        dynamicArray.foreach((element)->{
            System.out.println(element);
        });
    }
}

三、队列

package com.kfm.it.Strictice;

import java.util.Arrays;

public class MyQueue extends Queue {
    Object[] value;
    private int size;
    private static final int DEFAULT_CAPACITY = 10;

    public MyQueue() {
        this(DEFAULT_CAPACITY);
    }

    public MyQueue(int capacity) {
        if (capacity < 0) {
            capacity = DEFAULT_CAPACITY;
        }
        value = new Object[capacity];
    }

    @Override
    void push(Object element) {
        if (size + 1 > value.length) {
            add();
        }
        value[size++] = element;
    }

    private void add() {
        int old = value.length;
        int newCapacity = old + old >> 1;
        if (old>= newCapacity){
            newCapacity = Integer.MAX_VALUE;
        }
        value = Arrays.copyOf(value,newCapacity);
    }

    @Override
    Object pop() {
        Object element = value[0];
        System.arraycopy(value,1,value,0,size -1);
        value[size - 1] = null;
        size --;
        return element;
    }

    @Override
    Object peek() {
        return value[0];
    }

    @Override
    boolean isEmpty() {
        return size ==0;
    }

    @Override
    int size() {
        return size;
    }
}

package com.kfm.it.Strictice;

public class MyQueueTest {
    public static void main(String[] args) {
        MyQueue myQueue = new MyQueue();
        myQueue.push("a");
        myQueue.push(1);
        myQueue.push(2);
        myQueue.push(3);
        System.out.println(myQueue);
        System.out.println(myQueue.size());
    }
}