剑指offer5,6

5. 请实现一个函数，将一个字符串s中的每个空格替换成“%20”。

例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。

string replaceSpace(string s) {
        // write code here
        string res="";
        for(int i=0;i<s.size();i++)
        {
            if(s[i]!=' ')
            {
                res +=s[i];
            }
            else {
                res +="%20";
            }
        }
        return res;
    }

解决思路为，先创建一个字符串数组，接着对源字符串进行遍历，把遍历的结果存储到新建字符串中，如果遇到空格则替换成“%20”，最后返回新建字符串也就可以啦。

6. 输入一个链表的头节点，按链表从尾到头的顺序返回每个节点的值（用数组返回）。

如输入{1,2,3}的链表如下图:

返回一个数组为[3,2,1]，0 <= 链表长度 <= 10000。

vector<int> printListFromTailToHead(ListNode* head) {
        /*
        vector<int>res;
        while(head)
        {
            res.push_back(head->val);
            head=head->next;
        }
        reverse(res.begin(),res.end());
        return res;
        */
        vector<int> a;
        stack<int> s;
        if(head==nullptr)
        {
            return a;
        }
        while(head!=nullptr)
        {
            s.push(head->val);
            head=head->next;
        }
        while(!s.empty())
        {
            int temp=s.top();
            s.pop();
            a.push_back(temp);
        }
        return a;
    }

 这题提供两种思路：第一种是创建一个数字，然后遍历以下链表，把遍历结果存储到数组中，最后对数组进行反转得到需要的结果。

第二种是利用栈的先进后出的特点，也是先对链表进行遍历，遍历的结果存储到栈中，之后对栈进行弹出操作，弹出的结果存储到一个新建的数组中，得到最后的结果。

7. 给定节点数为 n 的二叉树的前序遍历和中序遍历结果，请重建出该二叉树并返回它的头结点。

例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建出如下图所示。

 TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) {
        int n=pre.size();
        int m=vin.size();
        //每个遍历都不能为零
        if(n==0||m==0)
        {
            return nullptr;
        }
        //构建一个根节点
        TreeNode* root=new TreeNode(pre[0]);
        
        for(int i=0;i<n;i++)
        {
            //找到中序遍历中的前序遍历第一个元素
            if(pre[0]==vin[i])
            {
                //左子树前序遍历
                vector<int>leftpre(pre.begin()+1,pre.begin()+i+1);
                //左子树中序遍历
                vector<int>leftvin(vin.begin(),vin.begin()+i);
                //构建左子树
                root->left=reConstructBinaryTree(leftpre,leftvin);
                //右子树前序遍历
                vector<int>rightpre(pre.begin()+i+1,pre.end());
                //右子树中序遍历
                vector<int>rightvin(vin.begin()+i+1,vin.end());
                //构建右子树
                root->right=reConstructBinaryTree(rightpre,rightvin);
                break;
            }
        }
        return root;
    }

由二叉树前序遍历（根左右），可知第一个元素为根元素，在中序遍历（左根右）中一定能找根元素，而中序遍历又把二叉树分成左右两棵子树。从而又可以对左右两颗子树进行上述操作。直到子树结束。