剑指offer【6-10】

面试题06. 从尾到头打印链表

输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。

示例 1：
输入：head = [1,3,2]
输出：[2,3,1]
限制：
0 <= 链表长度 <= 10000

最终返回的是vector数组，那么首先想到vector的reverse操作:

class Solution {
public:
    vector<int> reversePrint(ListNode* head) {
        ListNode *cur=head;
         vector<int> v;
        while(cur!=NULL)
        {
            v.push_back(cur->val);
            cur=cur->next;
        }
        reverse(v.begin(),v.end());
        return v;
    }
};

解法二：可以利用栈的先进后出的性质，得到反转的数组

class Solution {
public:
    vector<int> reversePrint(ListNode* head) {
        ListNode *cur=head;
        stack<int> s;
        while(cur!=NULL)
        {
            s.push(cur->val);
            cur=cur->next;
        }
        vector<int> v;
        while(!s.empty())
        {
            v.push_back(s.top());
            s.pop();
        }
        return v;
    }
};

面试题07. 重建二叉树

输入某二叉树的前序遍历和中序遍历的结果，请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。

限制：
0 <= 节点个数 <= 5000

递归得到左右子树的前序、中序遍历结果，直到为空

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if (preorder.size() == 0 || inorder.size() == 0) {
            return NULL;
        }
        TreeNode* treeNode = new TreeNode(preorder[0]);
        int mid = distance(begin(inorder), find(inorder.begin(), inorder.end(), preorder[0]));
        vector<int> left_pre(preorder.begin() + 1, preorder.begin() + mid + 1);
        vector<int> right_pre(preorder.begin() + mid + 1, preorder.end());
        vector<int> left_in(inorder.begin(), inorder.begin() + mid);
        vector<int> right_in(inorder.begin() + mid + 1, inorder.end());

        treeNode->left = buildTree(left_pre, left_in);
        treeNode->right = buildTree(right_pre, right_in);
        return treeNode;
    }
};

面试题09. 用两个栈实现队列

用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 )

示例 1：
输入：
[“CQueue”,“appendTail”,“deleteHead”,“deleteHead”]
[[],[3],[],[]]
输出：[null,null,3,-1]
示例 2：
输入：
[“CQueue”,“deleteHead”,“appendTail”,“appendTail”,“deleteHead”,“deleteHead”]
[[],[],[5],[2],[],[]]
输出：[null,-1,null,null,5,2]

class CQueue {
public:
    CQueue() {
    }
    void appendTail(int value) {
        s1.push(value);
    }
    int deleteHead() {
        if(s1.empty())
            return -1;
        while(!s1.empty())
        {
            s2.push(s1.top());
            s1.pop();
        }
        int n=s2.top();
        s2.pop();
        while(!s2.empty())
        {
            s1.push(s2.top());
            s2.pop();
        }
        return n;
    }
private:
    stack<int> s1;
    stack<int> s2;
};

/**
 * Your CQueue object will be instantiated and called as such:
 * CQueue* obj = new CQueue();
 * obj->appendTail(value);
 * int param_2 = obj->deleteHead();
 */

面试题10- I. 斐波那契数列

写一个函数，输入 n ，求斐波那契（Fibonacci）数列的第 n 项。斐波那契数列的定义如下：
F(0) = 0, F(1) = 1
F(N) = F(N - 1) + F(N - 2), 其中 N > 1.
斐波那契数列由 0 和 1 开始，之后的斐波那契数就是由之前的两数相加而得出。
答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。

示例 1：
输入：n = 2
输出：1
示例 2：
输入：n = 5
输出：5

class Solution {
public:
    int fib(int n) {
        if(n<=1)
            return n;
        int f[n+1];
        f[0]=0;
        f[1]=1;
        for(int i=2;i<=n;i++)
        {
            f[i]=(f[i-1]+f[i-2])%1000000007;
        }
        return f[n];
    }
};

面试题10- II. 青蛙跳台阶问题

一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。
答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。

示例 1：
输入：n = 2
输出：2
示例 2：
输入：n = 7
输出：21

class Solution {
public:
    int numWays(int n) {
        if(n<=1)
            return 1;
        int f[n+1];
        f[0]=1;
        f[1]=1;
        for(int i=2;i<=n;i++)
        {
            f[i]=(f[i-1]+f[i-2])%1000000007;
        }
        return f[n];
    }
};