《剑指offer》刷题第四篇

最新推荐文章于 2021-06-25 14:23:22 发布

ChiaHsinChen

最新推荐文章于 2021-06-25 14:23:22 发布

阅读量347

点赞数

分类专栏：剑指offer

本文链接：https://blog.csdn.net/ChiaHsinChen/article/details/82020566

版权

剑指offer 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

重建二叉树
https://www.nowcoder.com/practice/8a19cbe657394eeaac2f6ea9b0f6fcf6?tpId=13&tqId=11157&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking

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

解题思路
知道前序和中序遍历的结果是可以唯一确定一颗二叉树的，但是知道前序和后序遍历是不可以唯一确定一颗二叉树的。

在二叉树的前序遍历中第一个数字为根节点的值，在中序遍历中，根节点的值位于序列中间，根节点左边为左子树，右边为右子树。

第一层：如上，根节点值为1，其中4，7，2为左子树，5，3，8，6为右子树。
第二层：前序遍历为2，4，7，因此左子树中2为根节点值，中序遍历为4，7，2，所以4，7为根节点2的左子树；同理右边，3为根节点，5为左子树，8，6为右子树，以此类推，最终得出整个二叉树。

/**
 * 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) {
        if (pre.size() == 0)
            return NULL;
        TreeNode *root = dfs(pre, vin, 0, pre.size(), 0, vin.size());
        return root;
    }

    TreeNode *dfs(vector<int> &pre,vector<int> &vin, int p_l, int p_r, int v_l, int v_r) {
        if (p_l == p_r)
            return NULL;
        TreeNode *root = new TreeNode(pre[p_l]);
        int pos = -1;
        for (int i = v_l; i < v_r; i++)
            if (vin[i] == pre[p_l]) {
                pos = i;
                break;
            }

        root->left = dfs(pre, vin, p_l + 1, p_l + 1 + pos - v_l, v_l, pos);
        root->right = dfs(pre, vin, p_l + 1 + pos - v_l, p_r, pos + 1, v_r);
        return root;
    }
};

用两个栈实现队列
https://www.nowcoder.com/practice/54275ddae22f475981afa2244dd448c6?tpId=13&tqId=11158&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking

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

解题思路
用两个栈，一个用来压入Push，一个用来弹出Pop。

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

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

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

同理可用两个队列实现一个栈。

旋转数组的最小数字
https://www.nowcoder.com/practice/9f3231a991af4f55b95579b44b7a01ba?tpId=13&tqId=11159&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking

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

解题思路
输入数组是“非递减”的，有两种情况：
1.严格递增时，当原数组是严格递增的，它的一个旋转就可以认为是两个递增子数组组成，并且我们可以观察到旋转后数组第一个元素大于等于最后一个元素，我们要找的最小元素刚好在这个两个数组的分界线。

因此，我们用两个指针P1,P2分别指向数组第一个和最后一个元素，然后我们找到中间元素。

如果中间元素比第一个元素大，说明中间元素位于第一个递增数组，最小的元素位于该中间元素后面，此时移动P1指向该中间元素，缩小查找范围。

如果中间元素比最后一个元素小，说明中间元素位于第二个递增数组，最小的元素在中间元素前面，此时移动P2指向中间元素，同样缩小一半的查找范围。

最后的形式P1,P2将会指向两个相邻的元素，而第二个指针刚好指向最小元素。

2.再来考虑非递减这个条件，当第一个，最后一个，以及中间元素均相等的时候，是一个非递减数组，此时我们无法判断最小元素位置，采取顺序查找法。

时间复杂度最大为O(n)，最小为O(log n)。

class Solution {
public:
    int minNumberInRotateArray(vector<int> rotateArray) {
        if (rotateArray.size() == 0)
            return 0;
        int l = 0, r = rotateArray.size() - 1;
        while (l < r && rotateArray[l] >= rotateArray[r]) {
            int mid = (l + r) / 2;
            if (rotateArray[l] == rotateArray[r] && rotateArray[l] == rotateArray[mid]) {
                int ret = rotateArray[l];
                for (int i = l + 1; i <= r; ret = min(ret, rotateArray[i++]));
                return ret;
            }
            if (rotateArray[mid] >= rotateArray[l])
                l = mid + 1;
            else
                r = mid;
        }
        return rotateArray[l];
    }
};