牛客 剑 二维数组中的查找、重建二叉树（前中建树）、【链表】合并两个排序的链表（递归）、【数组】和为S的两个数字、【字符串】左旋转字符串（递归）、【树】把二叉树打印成多行（层数的处理）

题目描述

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

思路：在如下矩阵中找7，从右上角的9开始找，因为9>7,剔除9这一列，分析剩下3列；因为8>7,剔除8这一列；因为2<7,剔除2这一行向下寻找；因为4<7,剔除4这一行向下寻找.

1 2 8 9

2 4 9 12

4 7 10 13

6 8 11 15

class Solution{
public:
   bool Find(int target, vector<vector<int> > array) {
    int t1=array[0].size(),t2=array.size();
    // printf("%d %d",t1,t2);
    int flag=0;
    while(t1>=1&&flag<t2)
    {
        if(array[flag][t1-1]>target)
        {
            t1--;
        }
        else if(array[flag][t1-1]<target)
        {
            flag++;
        }
        else
            return true;
    }
    return false;
}
};

 

题目描述

输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,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* Create(vector<int> pre,vector<int> vin,int preL,int preR,int inL,int inR)
{
    if(preL>preR)    //递归必不可少的跳出条件
        return NULL;
    TreeNode *root=new TreeNode(pre[preL]);
    int k;
    for(int i=inL;i<=inR;i++)
    {
        if(vin[i]==root->val)
        {
            k=i;
            break;  //不要漏掉！！！
        }
    }
    int leftNum=k-inL;  //别写错！！
    root->left=Create(pre,vin,preL+1,preL+leftNum,inL,k-1);
    root->right=Create(pre,vin,preL+leftNum+1,preR,k+1,inR);
    return root;
}
TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) {
    if(pre.size()==0||vin.size()==0)
        return NULL;
    TreeNode *root=Create(pre,vin,0,pre.size()-1,0,vin.size()-1);
    return root;
}

};

代码的鲁棒性：程序能够判断输入是否符合规范要求，并对不合要求的输入予以合理的处理。

【链表】：求链表的中间节点：定义两个指针，同时从链表的头节点出发，一个指针一次走一步，另一个指针一次走两步，当走的快的指针走到链表的末尾时，走得慢的指针正好在链表的中间。

判断一个单向链表是否形成了环形结构：定义两个指针，同时从链表的头节点出发，一个指针一次走一步，另一个指针一次走两步，当走得快的指针追上了走得慢的指针，那么链表就是环形链表。

 

题目描述

输入一个链表，反转链表后，输出新链表的表头。

 

题目描述

输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
            val(x), next(NULL) {
    }
};*/
class Solution {
public:
 ListNode* Merge(ListNode* pHead1, ListNode* pHead2)
{
    if(pHead1==NULL)
        return pHead2;
    if(pHead2==NULL)
        return pHead1;
    ListNode *pHead=NULL;
    if(pHead1->val<=pHead2->val)
    {
        pHead=pHead1;
        pHead->next=Merge(pHead1->next,pHead2);
    }
    else if(pHead2->val<pHead1->val)
    {
        pHead=pHead2;
        pHead->next=Merge(pHead1,pHead2->next);
    }
    return pHead;
}
};

 

题目描述

输入一个递增排序的数组和一个数字S，在数组中查找两个数，使得他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的。

输出描述:

对应每个测试案例，输出两个数，小的先输出。

因为数组是递增的，定义两个指针，第一个指向数组的第一个位置，第二个指向数组的最后一个位置。

class Solution {
public:
   vector<int> FindNumbersWithSum(vector<int> array,int sum) {
    int len=array.size();
    int s1=0,s2=len-1;
    vector<int>v;
    while(s1<s2)
    {
        if(array[s1]+array[s2]==sum)
        {
            v.push_back(array[s1]);
            v.push_back(array[s2]);
            break;
        }
        else if(array[s1]+array[s2]>sum)
        {
            s2--;
        }
        else if(array[s1]+array[s2]<sum)
        {
            s1++;
        }
    }
    return v;
}
};

 

题目描述

汇编语言中有一种移位指令叫做循环左移（ROL），现在有个简单的任务，就是用字符串模拟这个指令的运算结果。对于一个给定的字符序列S，请你把其循环左移K位后的序列输出。例如，字符序列S=”abcXYZdef”,要求输出循环左移3位后的结果，即“XYZdefabc”。是不是很简单？OK，搞定它！

class Solution {
public:
string LeftRotateString(string str, int n) {
    string s="";
    if(n==0)
        return str;
    if(str.length()==0)
        return s;
    reverse(str.begin(),str.begin()+n); //先翻转前一部分
    reverse(str.begin()+n,str.begin()+str.length());  //翻转后一部分
    reverse(str.begin(),str.begin()+str.length());  //翻转整个字符串
    return str;
}
};

 

题目描述

从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
vector<vector<int> > Print(TreeNode* pRoot) {
    vector<vector<int>>v;
    if(pRoot==NULL)    //特殊情况的处理
        return v;
    queue<TreeNode*>q;
    q.push(pRoot);
    while (!q.empty()) {
        vector<int>c;
        int x=q.size();
        int i=0;
        while(i++<x)       //层数的处理
        {
            TreeNode *tmp=q.front();
            c.push_back(tmp->val);
            q.pop();
            if(tmp->left)
            {
                q.push(tmp->left);
            }
            if(tmp->right)
            {
                q.push(tmp->right);
            }
        }
        v.push_back(c);
    }
    return v;
}
};