面試題四：元素出棧、入棧順序的合法性。如入棧的序列（1,2,3,4,5），出棧序列為（4,5,3,2,1）。

思路：

①首先判斷出棧入棧序列長度是否一致，不一致直接返回false;

②借用一個臨時的棧，依次遍歷入棧序列的每一個元素，每次都先將入棧序列的第i個元素先入臨時棧，這時就需要進行檢查，判斷臨時棧的棧頂元素是否等於出棧序列的第index個元素，相等的話臨時棧進行一次pop，OutputIndex指向下一個出棧序列的下標。當入棧序列遍歷完成後，若臨時棧還存有元素，則返回false；反之為true。

實現程式碼：

bool JudgeLegal(vector
 
<int> Input,vector<int> Output)
{
    if (Input.size() != Output.size())
        return false;
    else
    {
        stack<int> tmp;
        int OutputIndex = 0;
        for (int i = 0; i < Input.size(); i++)
        {
            tmp.push(Input[i]);
            while (tmp.size()>0
 
 && tmp.top() == Output[OutputIndex])
            {
                tmp.pop();
                OutputIndex++;
            }
        }
        return (tmp.size() > 0) ? false : true;
    }
}

測試：

面試題五：一個數組實現兩個棧

思路：

方法一：採用交叉索引的方式，陣列奇數位為一個棧，偶數位為一個棧；每次push，pop操作找到對應的下標進行操作；

方法二：可計算出陣列中間位置，左半部分為棧1，右半部分為棧2；

方法三：相對於前兩種比較優的解決方法，棧1從陣列下標為0開始不斷增大，棧2從陣列元素個數-1的下標開始不斷減小。

相比三種方法，效率不相上下，第一二種考慮增容時會比較麻煩，第三種較簡單；第一種和第二種方法在其中一個棧壓入比較多的資料而另外一個棧資料很少時，就存在非常大的空間浪費，但方法三就可以很好的避免這一情況，空間利用率比較高，而且這種方案在一個棧pop的空間另一個棧可以使用，可以在一些情況下減少開闢空間的次數。簡單的圖示下三種區別：

方法三的實現程式碼：

class ArrayTwoStack
{
public:
    ArrayTwoStack()
        :_a(new int[2])
        , _capacity(2)
        ,stack1_size(0)
        ,stack2_size(1)
    {}

    void Stack1Push(const int& x)
    {
        CheckCapacity();
        _a[stack1_size++] = x;
    }

    void Stack2Push(const int& x)
    {
        CheckCapacity();
        _a[stack2_size--] = x;
    }

    void Stack1Pop()
    {
        if (stack1_size > 0)
            stack1_size--;
    }

    void Stack2Pop()
    {
        //stack2_size == capacity -1時說明stack2為空
        if (stack2_size < _capacity - 1)
            stack2_size++;  
    }

    const int& Stack1Top()
    {
        if (stack1_size != 0)
            return _a[stack1_size-1];
    }

    const int& Stack2Top()
    {
        if(stack2_size != _capacity-1)
            return _a[stack2_size+1];
    }

    size_t SizeofStack1()
    {
        return stack1_size;
    }

    size_t SizeofStack2()
    {
        return _capacity - 1 - stack2_size;
    }

    void Stack1Print()
    {
        for (int i = 0; i < stack1_size; i++)
        {
            cout << _a[i] << " ";
        }
        cout << endl;
    }

    void Stack2Print()
    {
        for (int i =stack2_size+1; i < _capacity; i++)
        {
            cout << _a[i] << " " ;
        }
        cout << endl;
    }

protected:
    void CheckCapacity()
    {
        if (stack2_size - stack1_size > 0)
            return;
        else
        {
            int newCapacity = _capacity * 2;
            int* tmp = new int[newCapacity];

            //從前向後拷貝stack1
            for (int i = 0; i < stack1_size; i++)
                tmp[i] = _a[i];

            //從後向前拷貝stack2
            int stack2_index = newCapacity - 1;
            for (int i = _capacity - 1; i > stack2_size; i--)
                tmp[stack2_index--] = _a[i];

            _a = tmp;
            _capacity = newCapacity;
            stack2_size = stack2_index;
        }
    }

private:
    int* _a;
    int _capacity;  //容量
    int stack1_size; //stack1的棧頂下標
    int stack2_size;  //stack2的棧頂下標
};

測試：

注意：Print操作是按照下標輸出的，stack2的棧底是最後一個元素，下標依次減小，更詳細的測試可拷貝下來詳細測試。