1.3 背包、队列和栈

public class FixedCapacityStackOfStrings
{
    private String[] a;
    private int N;
    public FixedCapacityStackOfStrings(int cap)
    {
        a=new String[cap];
    }
    public boolean isEmpty()
    {
        return N==0;
    }
    public boolean isFull()    //检查是否已满
    {
        return N==a.length;
    }
    public int size()
    {
        return N;
    }
    public void push(String item)
    {
        a[N++]=item;
    }
    public String pop()
    {
        return a[--N];
    }
    
    public static void main(String[] args) throws IOException
    {
        FixedCapacityStackOfStrings s=new FixedCapacityStackOfStrings(3);
        while(!s.isFull())
            s.push("first");
        while(!s.isEmpty())
            StdOut.println(s.pop());
    }
}

public class Parentheses
{
    private static final char LEFT_PAREN     = ‘(‘;  //paren---括弧
    private static final char RIGHT_PAREN    = ‘)‘;
    private static final char LEFT_BRACE     = ‘{‘;  //brace---大括号
    private static final char RIGHT_BRACE    = ‘}‘;
    private static final char LEFT_BRACKET   = ‘[‘;  //bracket---括号
    private static final char RIGHT_BRACKET  = ‘]‘;

    public static boolean isBalanced(String s) 
    {
        Stack<Character> stack = new Stack<Character>();
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == LEFT_PAREN)   stack.push(LEFT_PAREN);
            if (s.charAt(i) == LEFT_BRACE)   stack.push(LEFT_BRACE);
            if (s.charAt(i) == LEFT_BRACKET) stack.push(LEFT_BRACKET);

            if (s.charAt(i) == RIGHT_PAREN) {
                if (stack.isEmpty())           return false;
                if (stack.pop() != LEFT_PAREN) return false;
            }

            else if (s.charAt(i) == RIGHT_BRACE) {
                if (stack.isEmpty())           return false;
                if (stack.pop() != LEFT_BRACE) return false;
            }

            else if (s.charAt(i) == RIGHT_BRACKET) {
                if (stack.isEmpty())             return false;
                if (stack.pop() != LEFT_BRACKET) return false;
            }
        }
        return stack.isEmpty();
    }


    public static void main(String[] args) 
    {
        In in = new In();
        String s = in.readAll().trim();
        StdOut.println(isBalanced(s));
    }
}

Stack<String> stack=new Stack<String>();
while(!q.isEmpty())
       stack.push(q.dequeue());
while(!stack.isEmpty())
        q.enqueue(stack.pop());

public Item peek() {
        if (isEmpty()) throw new NoSuchElementException("Stack underflow");
        return first.item;
    }

public class H1_3_09
{
    public static void main(String[] args)
    {
        In in=new In();
        @SuppressWarnings("deprecation")
        String[] arr=In.readStrings("h1_3_09.txt");
        for(int i=0;i<arr.length;i++)
            StdOut.printf("%s",arr[i]);
        StdOut.println();
        StdOut.println(fillParen(arr));
        in.close();
    }
    
    public static String fillParen(String[] arr)   //补上左括号操作
    {
        Stack<String> operator=new Stack<String>(); 
        Stack<String> value=new Stack<String>();
        
        for(int i=0;i<arr.length;i++)
        {
            if(arr[i].equals("("));    //可以删去该句
            else if(arr[i].equals("*")||arr[i].equals("/")
                    ||arr[i].equals("+")||arr[i].equals("-")||arr[i].equals("sqrt"))  //操作符情况
                operator.push(arr[i]);
            else if(arr[i].equals(")"))    //右括号情况---关键
            {
                String op = operator.pop();
                String v = value.pop();
                
                if (op.equals("+") ||op.equals("-") ||op.equals("*") ||op.equals("/"))
                    v = String.format("( %s %s %s )", value.pop(), op, v);
                else if (op.equals("sqrt"))
                    v = String.format("( %s %s )", op, v);
                
                value.push(v);   //记得将操作结果存回数值栈中
            }
            else
                value.push(arr[i]);
        }
        return value.pop();
    }
}

public class H1_3_10
{
    public static void main(String[] args)
    {
        String str="(1+2)*3/4";
        String pfstr=infixToPostfix(str);
        StdOut.println(pfstr);
        StdOut.println(evaluatePostfix(pfstr));
    }
    
    //计算后序表达式的值
    public static double evaluatePostfix(String str)
    {
        Stack<String> stack=new Stack<String>();
        
        for(int i=0;i<str.length();i++)
        {
            char c=str.charAt(i);
            if(!isOperator(c))
                stack.push(Character.toString(c));
            else
            {
                double a1=Double.parseDouble(stack.pop().toString());
                double a2=Double.parseDouble(stack.pop().toString());
                stack.push(Double.toString(doOperator(a1,a2,c)));
            }            
        }
        return Double.parseDouble(stack.pop());
    }
    //根据操作符进行操作
    public static double doOperator(double a1,double a2,char c)
    {
        switch(c)
        {
        case ‘+‘:
            return a2+a1;
        case ‘-‘:
            return a2-a1;
        case ‘/‘:
            return a2*1.0/a1;
        case ‘*‘:
            return a2*1.0*a1;
        default:
            throw new NoSuchElementException("operator is illegal!");
        }
    }
    
    //将前序表达式转换为后序表达式
    public static String infixToPostfix(String str)
    {
        Stack<Character> stack=new Stack<Character>();
        String express="";
        
        for(int i=0;i<str.length();i++)
        {
            char c=str.charAt(i);
            if(!isOperator(c))      //情形1:操作数情况
                express+=c;
            else                      
            {
                if(c==‘(‘)          //情形2:左括号情况
                    stack.push(c);
                else if(c==‘)‘)     //情形3:右括号情况
                {
                    if(stack.isEmpty())
                        throw new NoSuchElementException("Stack underflow");
                    else
                    {
                        char temp=stack.pop();
                        while(temp!=‘(‘)
                        {
                            express+=temp;
                            temp=stack.pop();
                        }
                    }
                }
                else               //情形4:+-*/情况
                {
                    if(stack.isEmpty()||priority(stack.peek())<priority(c))
                        stack.push(c);
                    else    
                    {
                        while(!stack.isEmpty()&&stack.peek()!=‘(‘&&priority(stack.peek())>=priority(c))
                            express+=stack.pop();
                        stack.push(c);
                    }
                }
            }
        }
        if(!stack.isEmpty())     //栈中还有操作符情况
        {
            while(!stack.isEmpty())
            {
                if(stack.peek()==‘(‘)
                    throw new NoSuchElementException("Illegal input");
                else
                    express+=stack.pop();
            }
        }         
        return express;
    }
    //判断字符是否为符号
    public static boolean isOperator(char c)
    {
        if(c==‘+‘||c==‘-‘||c==‘*‘||c==‘/‘||c==‘(‘||c==‘)‘)
            return true;
        else
            return false;
    }
    //设定优先级
    public static int priority(char c)
    {
        if(c==‘(‘)
            return 0;
        else if(c==‘*‘||c==‘/‘)
            return 2;
        else if(c==‘+‘||c==‘-‘)
            return 1;
        else
            return 3;
    }
}

public class ResizingArrayQueue<Item> implements Iterable<Item> {
    private Item[] q;            // queue elements
    private int N = 0;           // number of elements on queue
    private int first = 0;       // index of first element of queue
    private int last  = 0;       // index of next available slot
    /**
     * Initializes an empty queue.
     */
    public ResizingArrayQueue() {
        // cast needed since no generic array creation in Java
        q = (Item[]) new Object[2];
    }
    /**
     * Is this queue empty?
     * @return true if this queue is empty; false otherwise
     */
    public boolean isEmpty() {
        return N == 0;
    }
    /**
     * Returns the number of items in this queue.
     * @return the number of items in this queue
     */
    public int size() {
        return N;
    }
    // resize the underlying array
    private void resize(int max) {
        assert max >= N;
        Item[] temp = (Item[]) new Object[max];
        for (int i = 0; i < N; i++) {
            temp[i] = q[(first + i) % q.length];
        }
        q = temp;
        first = 0;
        last  = N;
    }
    /**
     * Adds the item to this queue.
     * @param item the item to add
     */
    public void enqueue(Item item) {
        // double size of array if necessary and recopy to front of array
        if (N == q.length) resize(2*q.length);   // double size of array if necessary
        q[last++] = item;                        // add item
        if (last == q.length) last = 0;          // wrap-around
        N++;
    }
    /**
     * Removes and returns the item on this queue that was least recently added.
     * @return the item on this queue that was least recently added
     * @throws java.util.NoSuchElementException if this queue is empty
     */
    public Item dequeue() {
        if (isEmpty()) throw new NoSuchElementException("Queue underflow");
        Item item = q[first];
        q[first] = null;                            // to avoid loitering
        N--;
        first++;
        if (first == q.length) first = 0;           // wrap-around
        // shrink size of array if necessary
        if (N > 0 && N == q.length/4) resize(q.length/2); 
        return item;
    }
    /**
     * Returns the item least recently added to this queue.
     * @return the item least recently added to this queue
     * @throws java.util.NoSuchElementException if this queue is empty
     */
    public Item peek() {
        if (isEmpty()) throw new NoSuchElementException("Queue underflow");
        return q[first];
    }
    /**
     * Returns an iterator that iterates over the items in this queue in FIFO order.
     * @return an iterator that iterates over the items in this queue in FIFO order
     */
    public Iterator<Item> iterator() {
        return new ArrayIterator();
    }
    // an iterator, doesn‘t implement remove() since it‘s optional
    private class ArrayIterator implements Iterator<Item> {
        private int i = 0;
        public boolean hasNext()  { return i < N;                               }
        public void remove()      { throw new UnsupportedOperationException();  }

        public Item next() {
            if (!hasNext()) throw new NoSuchElementException();
            Item item = q[(i + first) % q.length];
            i++;
            return item;
        }
    }
   /**
     * Unit tests the <tt>ResizingArrayQueue</tt> data type.
     */
    public static void main(String[] args) {
        ResizingArrayQueue<String> q = new ResizingArrayQueue<String>();
        while (!StdIn.isEmpty()) {
            String item = StdIn.readString();
            if (!item.equals("-")) q.enqueue(item);
            else if (!q.isEmpty()) StdOut.print(q.dequeue() + " ");
        }
        StdOut.println("(" + q.size() + " left on queue)");
    }
}

public class H1_3_15
{
    public static void main(String[] args)
    {
        Queue<String> queue=new Queue<String>();
        for(int i=0;i<10;i++)
            queue.enqueue(Integer.toString(i));
        StdOut.println(Reversek(1, queue));
    }
    
    public static String Reversek(int k,Queue<String> queue)
    {
        if(k>queue.size())
            throw new NoSuchElementException("k is over the size");
        int cnt=queue.size()-k;
        for(int i=0;i<cnt;i++)
            queue.dequeue();
        return queue.dequeue();
    }
}

public class H1_3_16
{    
    public static Date[] readDates(String name)    //仿照readInts()
    {
        In in=new In(name);
        Queue<Date> q=new Queue<Date>();
        while(!in.isEmpty())
            q.enqueue(new Date(in.readString()));  //由于日期形式为 5/22/1939 所以用readString
        
        int N=q.size();
        Date[] a=new Date[N];
        for(int i=0;i<N;i++)
            a[i]=q.dequeue();
        return a;
    }
    
    public static void main(String[] args)
    {
        Date[] date=readDates("h1_3_16.txt");  
        for(int i=0;i<date.length;i++)
            StdOut.println(date[i].toString());
    }
}

public class H1_3_17
{
    public static Transaction[] readTransactions(String name)    //仿照readInts()
    {
        In in=new In(name);
        Queue<Transaction> q=new Queue<Transaction>();
        while(!in.isEmpty())
        {
            //由于Transaction的格式为 Turning 5/22/1939 11.99 的格式,因此采用readLine()
            String[] str=in.readLine().split("\\s+");
            Transaction tran=new Transaction(str[0],new Date(str[1]),Double.parseDouble(str[2]));
            q.enqueue(tran);
        }
        
        int N=q.size();
        Transaction[] a=new Transaction[N];
        for(int i=0;i<N;i++)
            a[i]=q.dequeue();
        return a;
    }
    
    public static void main(String[] args)
    {
        Transaction[] Transaction=readTransactions("h1_3_17.txt");  
        for(int i=0;i<Transaction.length;i++)
            StdOut.println(Transaction[i].toString());
    }
}

public class CircleQueue<Item> implements Iterable<Item>
{
    private Node first;
    private Node last;
    private int N;
    private class Node
    {
        Item item;
        Node next;
    }
    public boolean isEmpty()
    {
        return N==0;
    }
    public int size()
    {
        return N;
    }
    //进队列
    public void enqueue(Item item)
    {
        Node oldlast=last;
        last=new Node();
        last.item=item;
        last.next=first;
        if(isEmpty())
            first=last;
        else
            oldlast.next=last;
        N++;
    }
    //出队列
    public Item dequeue()
    {
        if(isEmpty())
            throw new NoSuchElementException("the queue is null");
        Item item=first.item;
        first=first.next;
        last.next=first;
        N--;
        return item;
    }
    @Override
    public Iterator<Item> iterator() {
        return new ListIterator();
    }
    //迭代器
    private class ListIterator implements Iterator<Item>
    {
        private int i;
        private Node current=first;
        public boolean hasNext()
        {
            return i<N;
        }
        public void remove(){}
        public Item next()
        {
            Item item=current.item;
            current=current.next;
            i++;
            return item;
        }
    }
    
    public static void main(String[] args)
    {
        CircleQueue<Integer> queue=new CircleQueue<Integer>();
        for(int i=0;i<10;i++)
            queue.enqueue(i);
        Iterator<Integer> itr=queue.iterator();
        while(itr.hasNext())
            StdOut.printf("%d ",itr.next());
        StdOut.println();
        queue.dequeue();
        Iterator<Integer> itr2=queue.iterator();
        while(itr2.hasNext())
            StdOut.printf("%d ",itr2.next());
    }
}