编程之美 队列中取最大值操作

main.cpp

/***********************************************

* Problem: 队列中取最大值操作

* 1.EnQueue(V): 将V加入队列中

* 2.DeQueue(): 使队列中首元素删除并返回此元素

* 3.MaxElement(): 返回对列中的最大元素

*

* Solution:

* 利用两个栈实现队列，在栈中实现取最大元素的操作

*************************************************/

#include <iostream>

#include "Stack.h"

#include "Queue.h"



using namespace std;



int main()

{

    Stack<int> s;

    int a[10];

    for(int i=0;i<10;i++)

        a[i]=rand();



    for(int i=0;i<10;i++)

    {

        s.Push(a[i]);

        cout<<a[i]<<" ";

    }

    cout<<endl;



    cout<<s.Max()<<endl;



    Queue<int> queue;

    for(int i=0;i<10;i++)

        queue.EnQueue(a[i]);

    cout<<"Queue front: "<<queue.DeQueue()<<endl;

    cout<<"Queue max: "<<queue.Max()<<endl;



    system("PAUSE");

    return 0;

}

 

Stack.h

#ifndef GUARD_stack_h

#define GUARD_stack_h



#include <iostream>

const int MAX_STACK_SIZE=50;



template<typename T>

class Stack

{

    public:

        Stack();

        void Push(const T& item);

        T Pop();

        T Max() const;

        bool Empty() const;

        bool Full() const;



    private:

        T stack[MAX_STACK_SIZE];

        int top;

        //最大元素的索引

        int maxItemIndex;
　　　　 //储存着第二大的元素的一组索
        int nextMaxItem[MAX_STACK_SIZE];

        void Error(char errorMsg[]);

};



template<typename T>

Stack<T>::Stack()

    :top(-1),maxItemIndex(-1)

{



}



template<typename T>

void Stack<T>::Push(const T& item)

{

    if(top+1==MAX_STACK_SIZE)

        Error("Stack overflow");

    top++;

    stack[top]=item;
    if(item > Max())
    {
        //储存到栈顶为止，第二大元素的Index
        nextMaxItem[top]=maxItemIndex;
	maxItemIndex=top;
    }

else

        nextMaxItem[top]=-1;

}



template<typename T>

T Stack<T>::Pop()

{

    if(top<0)

        Error("Stack empty.");



    T ret=stack[top];

    if(top==maxItemIndex)

    {

        maxItemIndex=nextMaxItem[top];

    }

    top--;

    return ret;

}



template<typename T>

T Stack<T>::Max() const

{

    if(maxItemIndex >=0)

        return stack[maxItemIndex];

    else

        return INT_MIN;

}



template<typename T>

bool Stack<T>::Empty() const

{

    return top==-1;

}



template<typename T>

bool Stack<T>::Full() const

{

    return top+1==MAX_STACK_SIZE;

}



template<typename T>

void Stack<T>::Error(char errorMsg[])

{

    std::cerr<<errorMsg<<std::endl;

    exit(1);

}



#endif

 

Queue.h

#ifndef GUARD_Queue_h

#define GUARD_Queue_h



#include "Stack.h"



template<typename T>

class Queue

{

    public:

        Queue();

        ~Queue();

        void EnQueue(const T& item);

        T DeQueue();

        T Max() const;



    private:

        Stack<T> *stack1,*stack2;

        T MaxValue(const T& x,const T& y) const;

        void Error(char errorMsg[]);

};



template<typename T>

Queue<T>::Queue()

{

    stack1=new Stack<T>();

    stack2=new Stack<T>();



    if(stack1==NULL || stack2==NULL)

        Error("Memory allocation failure.");



}



template<typename T>

Queue<T>::~Queue()

{

    delete stack1;

    delete stack2;

}



template<typename T>

void Queue<T>::EnQueue(const T &item)

{

    stack2->Push(item);

}



template<typename T>

T Queue<T>::DeQueue()

{

    if(stack1->Empty())

    {

        while(!stack2->Empty())

            stack1->Push(stack2->Pop());

    }

    return stack1->Pop();

}



template<typename T>

T Queue<T>::MaxValue(const T& x,const T& y) const

{

    return x>y ? x:y;

}



template<typename T>

T Queue<T>::Max() const

{

    return MaxValue(stack1->Max(),stack2->Max());

}



template<typename T>

void Queue<T>::Error(char errorMsg[])

{

    std::cerr<<errorMsg<<std::endl;

    exit(1);

}



#endif