剑指offer（4~6）--重建二叉树--用两个栈实现一个队列--旋转数组的最小数字

4、重建二叉树

输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

思路分析

在二叉树的前序遍历序列中，第一个数字总是树的根结点的值。但在中序遍历序列中，根结点的值在序列的中间，左子树的结点的值位于根结点的值的左边，而右子树的结点的值位于根结点的值的右边。因此我们需要扫描中序遍历序列，才能找到根结点的值。
如下图所示，前序遍历序列的第一个数字1就是根结点的值。扫描中序遍历序列，就能确定根结点的值的位置Inroot。根据中序遍历特点，在根结点Root之前的节点都是左子树结点，也就是说4 7 2就是左子树的中序遍历，而5 3 8 6就是右子树的中序遍历。同理左子树的前序遍历是2 4 7，右子树的前序遍历是3 5 6 8，然后递归就可够冲建二叉树。

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) {
        int len=pre.size();
        if(len==0)return nullptr;
        
        int root=pre[0];
        TreeNode*ret=new TreeNode(root);//返回的根节点
        vector<int> left_pre,left_in,right_pre,right_in;
        
        int Inroot;
        for(Inroot=0;Inroot<len;Inroot++)
        {
            if(vin[Inroot]==root)
                break;
        }
        //此时找到了根节点在中序数组中的位置Inroot
        for(int i=0;i<len;i++)
        {
            if(i<Inroot)
            {
                left_pre.push_back(pre[i+1]);//对于前序遍历来说，左子树下标1开始
                //这里虽然使用i+1,但是不会存在越界，因为在数组pre中下标为Inroot的节点仍然属于左子树
                left_in.push_back(vin[i]);
            }
            else if(i>Inroot)
            {
                right_pre.push_back(pre[i]);
                right_in.push_back(vin[i]);
            }
        }
        ret->left=reConstructBinaryTree(left_pre,left_in);
        ret->right=reConstructBinaryTree(right_pre,right_in);
        return ret;
    }
};

牛客网链接

5、用两个栈实现一个队列

用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。

思路分析

定义两个队列s1和s2。入队列：直接Push到s2。
出队列：如果s1为空，s2不为空，把栈s2中的元素依次入栈到s1。否则直接Pop栈s1。

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

    int pop() {
        if(stack1.empty())
        {
            while(!stack2.empty())
            {
                stack1.push(stack2.top());
                stack2.pop();
            }
        }
        int val=stack1.top();
        stack1.pop();
        return val;
    }

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

牛客网链接

6、旋转数组的最小数字

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

思路分析

笨方法：从头到尾遍历数组找到最小值，$O(N)$的时间复杂度。

class Solution {
public:
    int minNumberInRotateArray(vector<int> rotateArray) {
        if(rotateArray.size()==0)
            return 0;
        int min=rotateArray[0],i=0;
        for(i;i<rotateArray.size();i++)
        {
            if(rotateArray[i]<min)
                min=rotateArray[i];
        }
        return min;
    }
};

初级优化

由于非减排序数组，在进行旋转之后，数组形如是7，8，9，1，2，3，4，5，6这样，那么当arr[i+1] < arr[i]的时候，arr[i+1]就是整个数组的最小值。时间复杂度$O(1)$~$O(n)$。

class Solution {
public:
    int minNumberInRotateArray(vector<int> rotateArray) {
        int ret=0;
        if(!rotateArray.size())
            return ret;
        for(size_t i=0;i<rotateArray.size()-1;i++){
            if(rotateArray[i+1]<rotateArray[i])
            {
                ret=rotateArray[i+1];
                break;
            }
        }
        return ret;
    }
};

终极优化：根据数组的规则：

左区数值均大于arr[arr.size()-1]，右区数值均小于arr[0]。那么从取中间位置看它是左区还是右区，然后再向最小值位置靠近，就可以找到最小值。这种方法时间效率最高，时间复杂度是$O(1)$~$O(n/2)$。

class Solution {
public:
    int minNumberInRotateArray(vector<int> rotateArray) {
        int ret = 0;// 变量记录待返回的最小数
        if (!rotateArray.size())// 如果数组为空返回0
            return ret;
        int i = rotateArray.size() / 2;
        while (i > 0 && i < rotateArray.size()) {// 在左区内
            if (rotateArray[i] > rotateArray[rotateArray.size() - 1] &&
                rotateArray[i] <= rotateArray[i + 1]) {
                i++;
            } else if (rotateArray[i] < rotateArray[0] && 
                       rotateArray[i] >= rotateArray[i - 1]) {// 在右区内
                i--;
            } else { 
                // 此时拿到的rotateArray[i]是边界值，可能是左区的最大值或右区的最小值，判断一下即可
                ret = rotateArray[i] > rotateArray[i + 1] ? rotateArray[i + 1] : rotateArray[i];
                break;
            }
        }
        return ret;
    }
};

牛客网链接