栈、队列面试题总结

俩个栈实现一个队列

原理图

注意一定要谨防pop时，容器内没有元素而引发的错误。

class Solution
{
public:
    void push(int node) {
        stack1.push(node);
    }

    int pop() {
        if (stack1.empty()) {
            cout << "队列中无元素pop失败" << endl;
            exit(1);
        }
        while (!stack1.empty())
        {
            stack2.push(stack1.top());
            stack1.pop();
        }
        int ret = stack2.top();
        stack2.pop();//这个pop挺重要的 ，必须pop这才符合 要不根本该元素一直是队列的头元素
        while (!stack2.empty())
        {
            stack1.push(stack2.top());
            stack2.pop();
        }
        return ret;
    }

private:
    stack<int> stack1;
    stack<int> stack2;
};

俩个队列实现一个栈

class Solution2
{
public:
    void push(int node) {
        queue1.push(node);
    }

    int pop() {
        if (queue1.empty())
        {
            cout << "栈为空不能pop" << endl;
            exit(2);
        }
        while (queue1.size()>1)
        {
            queue2.push(queue1.front());
            queue1.pop();
        }
        int ret = queue1.front();
        queue1.pop();
        while (!queue2.empty())
        {
            queue1.push(queue2.front());
            queue2.pop();
        }
    }

private:
    queue<int> queue1;
    queue<int> queue2;
};

实现一个栈Stack，要求实现Push、Pop、Min的时间复杂度为O(1)

思路

第一种方法定义俩个栈，一个保存元素一个保存min值。每次入栈时要比较如果该元素小于等于min栈的栈顶元素时就把该元素也向min栈中入栈，否则只入保存元素的栈。出栈时如果该元素等于min栈的栈顶元素则俩个栈都要执行pop操作，否则只出保存元素栈的元素。
第二种方法只是用一个栈。每次入栈时，入俩个元素。先入要入的元素，再入min值。每次入的时候要判断，如果栈不为空，取栈顶元素。如果该元素小于栈顶元素就该元素入俩次，即从该元素后，该栈的最小元素得到了更新，否则先入该元素，再入原先栈顶的元素。出站栈时俩个俩个出。

方法2：
class Mystack{
public:
    Mystack()
    {}
    void push(T data)
    {
        if (_s.empty())
        {
            _s.push(data);
            _s.push(data);
        }
        else{
            int min = _s.top();
            if (data < min)
            {
                _s.push(data);
                _s.push(data);
            }
            else{
                _s.push(data);
                _s.push(min);
            }
        }
    }
    void pop()
    {
        if (_s.empty()){
            cout << "栈为空不能pop" << endl;
            return;
        }
        _s.pop();
        _s.pop();
    }
    T min()
    {
        return _s.top();
    }
private:
    stack<T> _s;
};

元素出栈、入栈顺序的合法性。

举个栗子:入栈的序列（1,2,3,4,5），出栈序列为（4,5,3,2,1），则合法。入栈的序列（1,2,3,4,5），出栈序列为（4,5,2,3,1），则不合法。也就是给你入栈序列，和出栈序列，看它符不符合一个栈的规律。

思路

因为栈是先进后出。所以出栈序列和入栈序列应该是反向的一组序列。但是有个例外，就是有一个元素先进然后立即出再入下一个元素，这种情况入栈序列和出栈序列就不再是反序的了。这样的情况影响出栈的序列。所以可以用出栈序列中的第一个元素在入栈序列中找到相应的下标。因为该元素是第一个出栈的元素，在此之前没有元素出栈。故在此之前进栈的元素严格遵循先进后出。而在该元素后入栈的元素可以遵循，也可以不遵循以例外的方式出栈所以是任意顺序的。
所以我们只判断在此之前是严格反序的话就是合法，不是严格反序就是非法。但是我们得在这样判断前，确保俩个数组元素都是相同的，所以我使用了俩段空间保存这俩个数组的值，然后快排看了下这俩个数组的值是否都完全相同。

int partion(int*arr,int left,int right)
{
    int begin = left;
    int end = right;
    int &key = arr[right];
    while (begin < end)
    {
        while (begin < end&&arr[begin] <= key) ++begin;
        while (begin < end&&arr[end] >= key) --end;
        if (begin < end)
        {
            arr[begin] ^= arr[end];
            arr[end] ^= arr[begin];
            arr[begin] ^= arr[end];
        }
    }
    if (begin != right) {
        arr[begin] ^= key;
        key ^= arr[begin];
        arr[begin] ^= key;
    }
    return begin;
}
void  quicksort(int*arr, int left ,int right)
{
    if (left<right)
    {
        int Base = partion(arr, left, right);
        quicksort(arr, left, Base - 1);
        quicksort(arr, Base+1, right);
    }

}
bool My_sort(int*test1, size_t len, int*test2, size_t len2)
{
    std::sort(test1, test1+len);//sort的end为尾随位置,可以用sort或者自己写个快排什么的基本上sort的时
    std::sort(test2, test2 + len);//间复杂度是nlog2n
    //quicksort(test1,0,len-1);
    //quicksort(test2,0,len2-1);
    for (size_t idx = 0; idx < len; ++idx)
    {
        if (test1[idx] != test2[idx]) return false;
    }
    return true;
}
bool stack_legal(int arr[],int arr_2[],size_t len ,size_t len_2)//这个方法时间复杂度O(nlog2)
{                                                           // 空间复杂度O(n)
    assert(arr != NULL&&arr_2 != NULL);
    if (len != len_2) return false;
    if (len == 0 ||len_2==0) return true;
    if (len == 1&&len_2==1)
    {
        if (arr[0] == arr_2[0]) return true;
        else return false;
    }
    int *test_arr = new int[len];
    int *test_arr2 = new int[len_2];
    memmove(test_arr, arr, len*sizeof(int));
    memmove(test_arr2, arr_2, len_2*sizeof(int));
    if (!My_sort(test_arr, len, test_arr2, len_2)) return false;
    size_t pos = 0;
    while (arr[pos] != arr_2[0])++pos;
    size_t idx = 0;
    while (pos > 0)
    {
        if (arr[idx] != arr_2[len_2 - 1 - idx]) return false;
        idx++;
        --pos;
    }
    return true;;
}

判断一棵树是否是完全二叉树

思路

我主要使用了层序遍历的思想，检测每一层的节点的合法性。
①当出现了只有左子树节点没有右子树的节点，那么我给一个标记置为True,以后遍历的每个节点再有子节点的话就不是完全二叉树。
②如果当该层节点只有右子树没有左子树那么该树不是完全二叉树。
所以根据上面俩条规则来解决这个问题

该图就是我所描述的几种情况

代码

bool complete_tree(Node*Root)
{
    if (Root == NULL) return true;
    bool Last = false; //该标记表示是否发现只有一个左子节点的子树
    queue<Node*> qcon;
    qcon.push(Root);
    Node*pCur = NULL;
    while (!qcon.empty())
    {
        pCur = qcon.front();
        if (Last&&(pCur->_PLeft!=NULL||pCur->_PRight!=NULL))
        {
            return false;
        }
        if (pCur->_PLeft !=NULL&&pCur->_PRight!=NULL)
        {
            qcon.push(pCur->_PLeft);
            qcon.push(pCur->_PRight);
        }
        if (pCur->_PLeft != NULL&&pCur->_PRight == NULL)
        {
                qcon.push(pCur->_PLeft);
                Last =true;
        }
        if (pCur->_PRight != NULL&&pCur->_PLeft == NULL)
        {
            return false;
        }
        qcon.pop();
    }
    return true;
}