【牛客网—剑指Offer】刷题记录

1.二维数组的查找

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

思路：由于从左到右，从上到下是递增的，所以从右上角开始搜索，根据如下规则搜索：

           如果目标数字比当前位置的数字小，那么肯定不在当前位置的这一列，只可能在当前位置的前一列，往前一列搜索；

           如果目标数字比当前位置的数字大，那么肯定不在当前位置的这一行，只可能在当前位置的下一行，往下一行搜索；

           搜索完所有可能的行与列还没搜到数字则表明不存在，返回false，若搜索到返回true。

          时间复杂度O(n+m)

class Solution {
public:
    bool Find(int target, vector<vector<int> > array) {
        int n=array.size()-1;
        int m=array[0].size()-1;
        int tmp;
        int x=0;
        int y=m;
        while (x<=n && y>=0) {
            tmp=array[x][y];
            if (target==tmp) return(true);
            if (target>tmp)  x++;
            if (target<tmp)  y--;
       
         }
        return(false);
   }
};

2.替换空格

题目描述：请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。在该字符串数组内进行操作。

思路：从后往前可以比从前往后降低时间复杂度。首先遍历一遍字符串确定空格的个数：Num_of_blank，

           那么替换空格后的新字符串长度为： Length_of_new=Length_of_old+2*Num_of_blank。

           设置两个指针p1和p2分别指向原字符串长度末尾和新字符串长度末尾，判断p1所指位置是否为空格，

           若是，则p2所指位置分别赋值为0，2，%，若不是，则将p1所指位置的值赋值给p2所指位置。

           时间复杂度O(2n)

class Solution {
public:
    void replaceSpace(char *str,int length) {
        if (str==NULL or length<=0) return ;
        int num_of_blank=0;
        int length_of_old=0;
        int length_of_new=0;
        for (int i=0;str[i]!='\0';i++){
            length_of_old++;
            if (str[i]==' ') num_of_blank++;
        }
        length_of_new=length_of_old+2*num_of_blank;
        char *p1=str+length_of_old;;
        char *p2=str+length_of_new;
        while(p1!=p2){
            if(*p1!=' '){
                *p2=*p1;
                p2--;
            }
            else{
                *p2='0';p2--;
                *p2='2';p2--;
                *p2='%';p2--;
            }
            p1--;
        }
        return;
    }
};

3.从尾到头打印链表

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

思路：可以开一个栈，利用栈先进后出的特点，把链表的值存入栈后再输出。

          也可以直接将链表反转然后输出，这里选择后者，因为省空间。

          反转的做法是把当前点的next改成指向它的前面的点，但需要先存下原来的next指向的点，否则会导致断链。

          接着更新前面的点和当前点。而当前点的next为空时，说明已经到末尾，将末尾作为新的head，就反转完毕。

         这里若不清楚，可以结合程序自行画图理解。

         时间复杂度O(n)

/**
*  struct ListNode {
*        int val;
*        struct ListNode *next;
*        ListNode(int x) :
*              val(x), next(NULL) {
*        }
*  };
*/
class Solution {
public:
    vector<int> printListFromTailToHead(ListNode* head) {
        vector<int> res;
        if (head==NULL) return(res);
        ListNode* newhead=NULL;
        ListNode* pPrev=NULL;
        ListNode* pNode=head;
        ListNode* pNext=NULL;
        while(pNode!=NULL){
            pNext=pNode->next;   //存下原先next指向的点
            if (pNext==NULL) newhead=pNode;
            pNode->next=pPrev;  //将next改成指向前面的点
            pPrev=pNode;  //下一步当前点变成前面的点，更新
            pNode=pNext;  //下一步原先next指向的点变成当前点，更新
        }
        while (newhead){
            res.push_back(newhead->val);
            newhead=newhead->next;
        }
        return(res);
    }
};

4.重建二叉树

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

思路：前序遍历为“根左右”，中序遍历为“左根右”，因此可以先通过前序遍历序列找到根的值，

           然后在中序遍历序列中，对应的根的左边序列的为左子树，右边序列为右子树。在该例子中，

          ｛4，7，2｝是1的左子树，｛5，3，8，6｝是1的右子树，也可以对应到前序遍历序列中。

           而在左子树｛4，7，2｝中，由前序遍历序列可知，2是子树的根，在中序遍历序列中，｛4，7｝在2的左边，为左子树。

          可以发现这是一个重复的递归过程。只需每次存下根节点后，依次递归左右子树即可。

/**
 * 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 pre_len=pre.size();
        int vin_len=vin.size();
        if (pre_len==0 || vin_len==0 || pre_len!=vin_len)
            return NULL;
        int root=0;
        for(;root<pre_len;root++)
            if (vin[root]==pre[0]) break;  //在中序遍历序列中确定根节点的位置
        TreeNode *List=new TreeNode(pre[0]); //储存根节点
        vector<int>pre_left,pre_right;   //在前序遍历序列中划分左右子树
        vector<int>vin_left,vin_right;   //在中序遍历序列中根据根节点划分左右子树
        for(int i=0;i<root;i++){
            pre_left.push_back(pre[i+1]);
            vin_left.push_back(vin[i]);
        }
        for (int i=root+1;i<vin_len;i++){
            pre_right.push_back(pre[i]);
            vin_right.push_back(vin[i]);
        }
        List->left=reConstructBinaryTree(pre_left,vin_left); //递归左子树
        List->right=reConstructBinaryTree(pre_right,vin_right); //递归右子树
        return(List); //递归结束返回该子树
    }
};

待更新 ...  0.0