编程之美3.7队列中取最大值操作问题Java版

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package chart_3;

/**
 *
 * 3.7 队列中取最大值操作问题
 */
public class QueueMaxOperate_3_7 {

    public static void main(String[] args) {
        //定义一个Stack类
        Stack s = new Stack(5);
        s.push(12);
        s.push(3);
        s.push(5);
        s.push(9);
        s.push(6);
        s.push(36);
        System.out.println(s.Max());
        s.Pop();
        System.out.println(s.Max());
        //定义一个Queue_T类，用Stack实现
        Queue_T q = new Queue_T();
        q.EnQueue(3);
        q.EnQueue(4);
        q.EnQueue(2);
        System.out.println(q.Max());
        q.DeQueue();
        q.EnQueue(5);
        System.out.println(q.Max());
    }

    private static class Stack {

        private static int maxStackItemIndex;
        private static int stackTop;
        private static int[] link2NextMaxItenm;
        private static int[] stackItem;
        private static int maxn;

        public Stack(int maxn) {
            stackTop = -1;
            maxStackItemIndex = -1;
            link2NextMaxItenm = new int[maxn];
            stackItem = new int[maxn];
            this.maxn = maxn;
        }

        void push(int x) {
            
            if (stackTop >= maxn-1) {

            } else {
                stackTop++;
                stackItem[stackTop] = x;
                if (x > Max()) {
                    link2NextMaxItenm[stackTop] = maxStackItemIndex;
                    maxStackItemIndex = stackTop;
                } else {
                    link2NextMaxItenm[stackTop] = -1;
                }
            }
        }
        int Pop(){
            int ret;
            if(stackTop <0){
                return -1;
            }else{
                ret = stackItem[stackTop];
                if(stackTop == maxStackItemIndex){
                    maxStackItemIndex = link2NextMaxItenm[stackTop];
                }
                stackTop--;
                return ret;
            }
        }

        int Max() {
            if (maxStackItemIndex >= 0) {
                return stackItem[maxStackItemIndex];
            } else {
                return -1;
            }
        }
    }

    
}

Queue_T类

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package chart_3;

import java.util.Enumeration;
import java.util.Stack;

/**
 *
 * @author Administrator
 */
class Queue_T {

    private Stack<Integer> stackA;
    private Stack<Integer> stackB;
    private int max_index;

    public Queue_T() {
        stackA = new Stack<Integer>();
        stackB = new Stack<Integer>();
        max_index = -1;
    }

    void EnQueue(int v) {
        stackB.push(v);
        if (v > max_index) {
            max_index = v;
        }
    }

    Integer DeQueue() {
        if (stackA.isEmpty()) {
            while (!stackB.isEmpty()) {
                stackA.push(stackB.pop());
            }
        }
        int peek = stackA.pop();
        if (peek == max_index) {
           max_index = LookMax();
        }
        return peek;
    }
    int Max(){
        return max_index;
    }
            
    int LookMax() {
        int maxA = -1;
        int maxB = -1;
        Enumeration<Integer> itemsA = stackA.elements();
        while (itemsA.hasMoreElements()) {
            if (itemsA.nextElement() > maxA) {
                maxA = itemsA.nextElement();
            }
        }
        if (!stackB.isEmpty()) {
            Enumeration<Integer> itemsB = stackB.elements();
            while (itemsB.hasMoreElements()) {
                if (itemsB.nextElement() > maxB) {
                    maxB = itemsB.nextElement();
                }
            }
        }
        if(maxA > maxB)
            return maxA;
        else 
            return maxB;
    }
}