数据结构——栈和队列

已知的数据结构：数组、链表、哈希表(数组+链表)、二叉树[详情见集合[容器]篇]

<-------栈-------->

  

模拟栈
　　使用数组，模拟一个栈结构和对栈的操作
 　  如果栈已经满了，提示压栈失败，栈已经满了
  　 出栈操作，如果栈已经空了，提示 出栈失败，栈已经空了

public class MyStack<T> {
    //栈的最大容量
    private final int CAPACITY;
    //用来存放对象的模拟栈的数组
    private T[] values;
    //指向栈顶的指针
    private int index;
    @SuppressWarnings("unchecked")
    public MyStack(int capacity) {
        this.CAPACITY = capacity;
        this.values = (T[])new Object[capacity];
        index = 0;
    }
    /**
     * 压栈操作
     * @param item
     * @return 压栈的对象
     */
    public void push(T item){
        if(index >= CAPACITY){
            System.out.println("提示压栈失败，栈已经满了。");
            return;
        }
        values[index] = item;
        index ++;
    }
    /**
     * 出栈操作
     * @return 出栈的对象
     */
    public T pop(){
        if(index <= 0){
            System.out.println("提示 出栈失败，栈已经空了。");
            return null;
        }
        index --;
        return values[index];
    }
    /**
     * 得到栈的容量
     * @return 
     */
    public int capacity(){
        return this.CAPACITY;
    }
    /**
     * 得到栈中元素的数量
     * @return
     */
    public int size(){
        return this.index;
    }
    
    /**
     * 清栈操作
     */
    public void clear(){
        this.index = 0;
    }
    /**
     * 栈是否为空
     * @return
     */
    public boolean isEmpty(){
        return index == 0;
    }
    
    /**
     * 打印栈中的内容
     */
    public String toString(){
        return Arrays.toString(Arrays.copyOf(values, this.index));
    }
}

测试栈模拟器

//测试自定义栈
import java.util.*;

class Test {

    public static void main(String[] args) {
        MyStack<String> myStack = new MyStack<String>(6);

        myStack.pop(); // 提示压栈失败，栈已经满了。
        myStack.push("1");
        myStack.push("2");
        myStack.push("3");

        myStack.push("4");
        myStack.push("5");
        myStack.push("6");

        myStack.push("7"); // 提示压栈失败，栈已经满了。
        System.out.println(myStack); // [1, 2, 3, 4, 5, 6]

        System.out.println(myStack.pop()); // 6

        System.out.println(myStack); // [1, 2, 3, 4, 5]
        System.out.println(myStack.isEmpty()); // false

        System.out.println("栈的容量：" + myStack.capacity()); // 栈的容量：6
        System.out.println("栈内元素的数量：" + myStack.size()); // 栈内元素的数量：5
        myStack.clear(); // 栈内元素的数量：5
        System.out.println("栈的容量：" + myStack.capacity()); // 栈的容量：6
        System.out.println("栈内元素的数量：" + myStack.size()); // 栈内元素的数量：0

        System.out.println(myStack); // []

        System.out.println(myStack.isEmpty()); // true

    }
}

<-------队列------->