算法第四版1.4算法分析：习题1.4.30

组成：steque和stack

将steque作为存储主体，底部为队列开始，顶部为队列结尾；stack用来释放元素操作

pushLeft():放在队列的最开始，那么应该在steque的最底下，对steque作enqueue()操作

pushRight():放在队列的最后面，那么应该在steque的最上面，先把stack的所有元素依次弹出再压入steque,最后将新元素压入steque

popLeft():释放队列最开始的元素，也就是steque最下面的元素，将steque依次pop()再压入stack中,弹出stack最上面的元素

popRight():释放队列最后一个元素，将stack中的元素，依次弹出压入steque中，弹出steque最上面的元素

import edu.princeton.cs.algs4.StdOut;

public class E1_4_30 {
    public static void main(String[]args){
        Deque<Integer> deque=new Deque<>();
        for (int i=5;i<10;i++)
            deque.pushRight(i);
        for (int i=0;i<4;i++)//右边出四个，结果应该为9，8，7，6
            StdOut.print(deque.popRight()+"  ");
        StdOut.println();
        for (int i=4;i>=0;i--)
            deque.pushLeft(i);
        while (!deque.isEmpty())//左边出完，0，1，2，3，4，5
            StdOut.print(deque.popLeft()+"  ");
    }

    public static class Deque<Item>{
        Steque<Item> steque=new Steque<>();
        Stack<Item> stack=new Stack<>();
        public boolean isEmpty(){return size()==0;}
        public int size(){
            return steque.size()+stack.size();
        }

        public void pushLeft(Item item){
            steque.enqueue(item);//放在steque最下面
        }
        public void pushRight(Item item){
            if (stack.isEmpty());
            else
                while (!stack.isEmpty())
                    steque.push(stack.pop());
            steque.push(item);
        }
        public Item popLeft(){
            while (!steque.isEmpty())
                stack.push(steque.pop());
            return stack.pop();
        }
        public Item popRight(){
            while (!stack.isEmpty())
                steque.push(stack.pop());
            return steque.pop();
        }
    }
}

 Steque的实现：

import edu.princeton.cs.algs4.StdOut;

public class Steque<Item> {
    private Node first;
    private Node last;
    private int N=0;
    private class Node{
        Item item;
        Node next;
    }
    public Steque(){
        first=null;
        last=null;
    }
    public boolean isEmpty(){return first==null;}
    public int size(){return N;}
    public void push(Item item){
        if (isEmpty()){
            first=new Node();
            first.item=item;
            first.next=null;
            last=first;
        }
        else {
            Node newfirst=new Node();
            newfirst.item=item;
            newfirst.next=first;
            first=newfirst;
        }
        N++;
    }
    public Item pop(){
        if (first==null)return null;
        Item item=first.item;
        if (first==last){
            first=null;
            last=null;
        }
        else {
            first=first.next;
        }
        N--;
        return item;
    }
    public void enqueue(Item item){
        if (isEmpty())
            push(item);
        else {
            Node newlast=new Node();
            newlast.item=item;
            last.next=newlast;
            last=newlast;
        }
        N++;
    }
    public void printList(){
        Node current=first;
        while (current!=null) {
            StdOut.print(current.item + " ");
            current = current.next;
        }
        StdOut.println();
    }
}

Stack的实现： 

import edu.princeton.cs.algs4.StdIn;
import edu.princeton.cs.algs4.StdOut;

import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.NoSuchElementException;

public class Stack <Item> implements Iterable<Item>{
    public static void main(String[]args){
        //Create a stack and push/pop strings as directed on StdIn.
        Stack<String>s=new Stack<>();
        while (!StdIn.isEmpty()){
            String item=StdIn.readString();
            if (!item.equals("-"))
                s.push(item);
            else if (!s.isEmpty()) StdOut.print(s.pop()+" ");
        }
        StdOut.println("("+s.size()+" left on stack)");
        for (String s1:s)StdOut.println(s1);
    }

    private Node first; //top of stack (most recently added node)
    private int N;      //number of items

    private class Node{
        //nested class to define nodes
        Item item;
        Node next;
    }
    public Stack(){
        first=null;
        N=0;
    }
    public Stack(Stack<Item> s){//1.3.42
        Stack<Item> temp=new Stack<>();
        int N=s.size();
        for (int i=0;i<N;i++)
            temp.push(s.pop());
        for (int i=0;i<N;i++) {
            Item item = temp.pop();
            push(item);
            s.push(item);
        }
    }
    public boolean isEmpty()    {return first==null;}   //Or:N==0
    public int size()           {return N;          }
    public void push(Item item){
        Node oldfirst=first;
        first=new Node();
        first.item=item;
        first.next=oldfirst;
        N++;
    }
    public Item pop(){
        //Remove item from top of stack.
        Item item=first.item;
        first=first.next;
        N--;
        return item;
    }
    public Item peek(){
        if (isEmpty()){
            throw new NoSuchElementException("Stack underflow!");
        }
        return first.item;
    }
    public static <Item1> Stack<Item1> copy(Stack<Item1> s){
        Stack<Item1> result=new Stack<>();
        Stack<Item1> temp=new Stack<>();
        Iterator<Item1> iterator=s.iterator();
        while (iterator.hasNext())
            temp.push(iterator.next());
        iterator=temp.iterator();
        while (iterator.hasNext())
            result.push(iterator.next());
        return result;
    }
    public Iterator<Item> iterator(){
        return new StackIterator();
    }
    private class StackIterator implements Iterator<Item>{
        private Node current=first;
        private int count=size();
        public boolean hasNext(){
            if (count!=size())
                throw new ConcurrentModificationException("Stack was being modified!");
            return current!=null;
        }
        public void remove(){}
        public Item next(){
            if (count!=size())
                throw new ConcurrentModificationException("Stack was being modified!");
            Item item=current.item;
            current=current.next;
            return item;
        }
    }
}