【剑指offer]1-4

题目一

二维数组查找

在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

class Solution //二维数组查找
{
public:
    bool Find(int target, vector<vector<int> > array)
    {
        int rows = array.size();//行
        int cols= array[0].size();//列
        int i = rows - 1;
        int j = 0;
        while (i >= 0 && j < cols)
        {
            if (array[i][j] > target)
            {
                i--;
            }
            else if (array[i][j] < target)
            {
                j++;
            }
            else
                return true;
        }
        return false;

    }
};

题目二

空格替换

请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。

void replaceSpace(char *str, int length) {//空格替换
    int count = 0;
    for (int i = 0; i<length; i++){
        if (str[i] == ' ')
            count++;
    }
    for (int i = length - 1; i >= 0; i--){
        if (str[i] != ' '){
            str[i + 2 * count] = str[i];
        }
        else{
            count--;
            str[i + 2 * count] = '%';
            str[i + 2 * count + 1] = '2';
            str[i + 2 * count + 2] = '0';
        }
    }
}

题目三

从头到尾打印链表

输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。

struct ListNode { //链表数据结构
    int val;
    struct ListNode *next;
    ListNode(int x) :
        val(x), next(NULL) {

        }   
};

vector<int> printListFromTailToHead(ListNode* head)//反向输出链表数据
    {
        stack<int> s;
        while (head!=NULL)
        {
            s.push(head->val);
            head = head->next;
        }
        vector<int> array;
        while(!s.empty())
        {
            array.push_back(s.top());
            s.pop();
        }
        return array;
    }

题目四

二叉树的恢复

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

struct TreeNode {//二叉树数据结构
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
TreeNode* reConstructBinaryTree(vector<int> pre, vector<int> vin)// 复原二叉树
    {
        int inlen = vin.size();
        if (inlen == 0)
        {
            return NULL;
        }
            vector<int> left_pre, right_pre, left_vin, right_vin;     
            //创建根节点，根节点肯定是前序遍历的第一个数
            TreeNode* head = new TreeNode(pre[0]);
            int gen = 0;//找到中序遍历根节点所在位置,存放于变量gen中
            for (int i = 0; i < inlen; i++)
            {
                if (vin[i] == pre[0])
                {
                    gen = i;
                    break;
                }
            }       
            //对于中序遍历，根节点左边的节点位于二叉树的左边，根节点右边的节点位于二叉树的右边
            for (int i = 0; i < gen; i++)//利用上述这点，对二叉树节点进行归并
            {
                left_vin.push_back(vin[i]);
                left_pre.push_back(pre[i + 1]);//前序第一个为根节点
            }
            for (int i = gen + 1; i < inlen; i++)
            {
                right_vin.push_back(vin[i]);
                right_pre.push_back(pre[i]);
            }
            head->left = reConstructBinaryTree(left_pre, left_vin);//递归，再对其进行上述所有步骤，即再区分子树的左、右子树，直到叶节点
            head->right = reConstructBinaryTree(right_pre, right_vin);
            return head;    
    }