数组、链表实现队列、栈

package com.jmdf;

import java.util.ArrayList;
import java.util.Deque;
import java.util.LinkedList;
import java.util.Queue;

/**
 * array实现队列、栈，likedlist实现队列、栈
 */
public class MyQueue {

    /**
     * 利用数组实现有界队列
     * @param <T>
     */
public static class ArrayListQueue<T>{

    private ArrayList<T> arrayList;

    /**
     * 入队
     */
    public void add(T t) {
        if (arrayList == null) {
            arrayList = new ArrayList();
        }
        arrayList.add(t);
    }

    /**
     * 出队
     */
    public T remove() {
        if (arrayList != null && arrayList.size() > 0) {
            return arrayList.remove(0);
        }
        return null;
    }

    public int size() {
        return arrayList == null ? 0 : arrayList.size();
    }


    public static void main(String[] args) {
        ArrayListQueue queue = new ArrayListQueue();
        queue.add(1);
        queue.add(2);
        queue.add(3);
        queue.add(4);
        while (queue.size()!=0) {
            System.out.println(queue.remove());
        }

    }
}

    /**
     * 利用数组实现栈
     * @param <T>
     */
public static class MyStack<T> {
        private ArrayList<T> arrayList;

        /**
         * 入栈
         */
        public void push(T t) {
            if (arrayList == null) {
                arrayList = new ArrayList<>();
            }
            arrayList.add(t);
        }

        /**
         * 出栈
         */
        public T pop() {
            if (arrayList != null && arrayList.size() > 0) {
                return arrayList.remove(arrayList.size() - 1);
            }
            return null;
        }

        /**
         * 查看栈顶元素
         */
        public T peek() {
            if (arrayList != null && arrayList.size() > 0) {
                return arrayList.get(arrayList.size() - 1);
            }
            return null;
        }

        public int size() {
            return arrayList == null ? 0 : arrayList.size();
        }

        public static void main(String[] args) {
            MyStack<String> stack = new MyStack<>();
            stack.push("a");
            stack.push("b");
            stack.push("c");
            while (stack.peek()!=null){
                System.out.println("查看栈顶元素，不删除"+stack.peek());
                System.out.println(stack.pop());
            }
        }
    }

    /**
     * 利用LinkedList队列的queue接口的实现
     */
public static class LimkedListQueue{

public static void main(String[] args) {
        
        Queue queue = new LinkedList();

        queue.offer("1");
        queue.offer("2");
        queue.offer("3");
        queue.offer("4");
        while (queue.peek()!=null){
            System.out.println(queue.poll());
        }

    }
}

    /**
     * 用Deque双端队列接口（LinkedList也实现了这个接口）定义的方法来实现队列
     */
public static class LimkedListQueue2{
    private LinkedList ll = new LinkedList();

        //入队操作
        public void put (Object o){
            ll.addLast(o);
        }
        //使用removeFirst方法，返回队列第一个数据，然后将它从队列删除
        public Object get(){
            return ll.removeFirst();
        }

        public boolean empty(){
            return ll.isEmpty();
        }




    public static void main(String[] args) {
            
            LimkedListQueue2 queue2 = new LimkedListQueue2();
            queue2.put("a");
            queue2.put("b");
            queue2.put("c");
            queue2.put("d");
            while (!queue2.empty()){
                System.out.println(queue2.get());
            }
        }
    }

    /**
     * 用Deque双端队列接口（LinkedList也实现了这个接口）定义的方法来实现栈
     */
   
public static class LimkedListStack{
    /**
     * 栈的实现
     */

        public static void main(String[] args) {
            //利用双端队列接口实现栈
            Deque<String> stack = new LinkedList();
            stack.push("a");
            stack.push("b");
            stack.push("c");
            while (stack.peek()!=null){
                System.out.println("查看元素，但不删除元素"+stack.peek());
                System.out.println(stack.pop());
            }

        }


    }
    

}