线性表的逻辑结构：栈、队列

线性表的逻辑结构：栈、队列

利用链表结构和数组结构实现栈的先进后出

public class Test02 {

    public static void main(String[] args) {
        int [] a={1,2,3,4,5,6,7,8};

       /* LinkedStack<Integer> linkedStack=new LinkedStack<Integer>();
        for (int i = 0; i < a.length; i++) {
            linkedStack.push(a[i]);
        }
        System.out.println("======================");
        for (;;){
            Integer temp=linkedStack.pop();
            if(temp==null){
                break;
            }
            System.out.println(temp);
        }*/

        ArrayStack<Integer> arrayStack=new ArrayStack<Integer>(10);
        for (int i = 0; i < a.length; i++) {
            arrayStack.push(a[i]);
        }
        System.out.println("------------");
        for (;;) {
            Integer temp=arrayStack.pop();
            if(temp==null){
                break;
            }
            System.out.println(temp);
        }
    }

    //静态内部类数组实现接口及方法
    static class ArrayStack<T> implements MyStack<T>{

        Object [] objects;

        public ArrayStack(int size){
            objects=new Object[size];
        }
        @Override
        public boolean push(T object) {
            for (int i = 0; i < objects.length; i++) {
                if(objects[i]==null){
                    objects[i]=object;
                    return true;
                }
            }
            return false;
        }

        @Override
        public T pop() {
            for (int i = 0; i < objects.length; i++) {//注意下：此段意义为遍历数组，弹出最后一个数据
                if(objects[i]==null){
                    if(i>0){
                        Object temp=objects[i-1];
                        objects[i-1]=null;
                        return (T)temp;
                    }
                }else{
                    if(i==objects.length-1){
                        Object temp=objects[objects.length-1];
                        objects[objects.length-1]=null;
                        return (T)temp;
                    }
                }
            }
            return null;
        }
    }

    //静态内部类链表实现接口及方法（尾插法）
    static class LinkedStack<T> implements MyStack<T>{

        Node<T> top =null;
        Node<T> p=null;
        int size=0;

        @Override
        public boolean push(T object) {
            if(size==0){
                top=new Node<T>();
                p=top;
                top.value=object;
            }else{
                p.next=new Node<T>();
                p.next.value=object;
                p=p.next;
            }
            size++;
            return true;
        }

        @Override
        public T pop() {
            Node<T> temp=top;
            if(size==0){
                return null;
            }

            if(size==1){
                temp=top;
                top=null;
                size=0;
                p=null;
                return temp.value;
            }

            while (true){
                if (temp.next!=null){
                    if(temp.next.next==null){
                        break;
                    }
                }
                temp=temp.next;
            }

            Node<T> result=p;
            p=temp;
            p.next=null;
            size--;
            return result.value;
        }

        static class Node<T>{
            T value;
            Node<T> next;
        }
    }

    //静态内部类链表实现接口及方法（头插法）
    static class LinkedStack2<T> implements MyStack<T>{
        Node<T> top=null;
        int size=0;
        @Override
        public boolean push(T object) {
            if(size==0){
                top=new Node<T>();
                top.value=object;
            }else{
                Node<T> temp=new Node<T>();
                temp.value=object;
                temp.next=top;
                top=temp;
            }
            size++;
            return true;
        }

        @Override
        public T pop() {
            Node<T> result=top;
            if(size==1){
                top=null;
                size=0;
                return result.value;
            }
            if(size==0){
                return null;
            }

            top=top.next;
            size--;
            return result.value;
        }
        static class Node<T>{
            T value;
            Node<T> next;
        }
    }

    //构建栈模型接口
    interface MyStack<T>{
        boolean push(T object);//入栈方法
        T pop();//弹栈方法
    }

}

利用数组和链表结构实现队列先进先出效果

public class Test03 {
    public static void main(String[] args) {
        int [] a={1,2,3,4,5,6,7,8,9};
//        ArrayQueue<Integer> arrayQueue=new ArrayQueue(9);
//        for (int i = 0; i < a.length; i++) {
//            arrayQueue.add(a[i]);
//        }
//        while (true) {
//            Integer result=arrayQueue.remove();
//            if(result==null){
//                break;
//            }
//            System.out.println(result);
//        }


        LinkedQueue<Integer> linkedQueue=new LinkedQueue();
        for (int i = 0; i < a.length; i++) {
            linkedQueue.add(a[i]);
        }
        while (true) {
            Integer result=linkedQueue.remove();
            if(result==null){
                break;
            }
            System.out.println(result);
        }
    }

    //数组实现为有界队列
    static class ArrayQueue<T> implements MyQueue<T>{
        Object [] objects;
        int size=0;
        public ArrayQueue(int size){
            objects=new Object[size];
        }
        @Override
        public boolean add(T object) {//从头插入数据
            if(size==objects.length){
                return false;
            }
            if(size!=0){
                System.arraycopy(objects, 0, objects, 1,
                        size);
            }
            objects[0]=object;
            size++;
            return true;
        }

        @Override
        public T remove() {//尾部移除数据
            if(size==0){
                return null;
            }
            //size=0
            //此时无元素
            //size=1
            //唯一的一个元素就是objects[0]
            T result= (T) objects[size-1];
            objects[size-1]=null;
            size--;
            return result;
        }
    }
    static class LinkedQueue<T> implements MyQueue<T>{//尾部插入
        Node<T> top;
        Node<T> p;
        int size=0;
        @Override
        public boolean add(T object) {//p指向最后一个
            if(size==0){
                top=new Node<T>();
                top.value=object;
                p=top;
            }else{
                p.next=new Node<T>();
                p.next.value=object;
                p=p.next;
            }
            size++;
            return true;
        }

        @Override
        public T remove() {//头部取出
            if(size==0){
                return null;
            }
            T result=top.value;
            if(size==1){
                top=null;
                size=0;
                return result;
            }

            top=top.next;
            size--;
            return result;
        }
        static class Node<T>{
            T value;
            Node<T> next;
        }
    }
    interface MyQueue<T>{
        boolean add(T object);
        T remove();
    }
}