剑桥offer(31~40)

31.题目描述

统计一个数字在排序数组中出现的次数。

思路：找到最低和最高，相减

class Solution {
public:
    int GetNumberOfK(vector<int> data ,int k) {

        int low=;
        int high = data.size()-;
        int mid=;
        int index=-;
        while(low<=high){
            mid = (low+high)/;

            if(k == data[mid] )
                index=mid;
               break;
            if(k>data[mid]){
                low = mid+;
            }else if(k<data[mid]){
                high = mid -;
            }
        }
        if(index==-)return ;
        low = mid -;
        high = mid +;

        while(low>=&&data[low]==k)
            low--;
        while(high<data.size() &&data[high]==k)
            high++;
        return high-low-;

    }
};

32.题目描述

输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。

思路：无论是有左还是有右，深度加1，相当与按层次打印树的节点，使用队列数据结构。

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};*/
class Solution {
public:
    int TreeDepth(TreeNode* pRoot)
    {

    //    if(pRoot == NULL) return 0;
    //     return max(TreeDepth( pRoot->left),TreeDepth( pRoot->right))+1;

     queue<TreeNode*> q;
        if(!pRoot) return ;
        q.push(pRoot);
        int level=;
        while(!q.empty()){
            int len=q.size();
            level++;
            while(len--){
                TreeNode* tem=q.front();
                q.pop();
                if(tem->left) q.push(tem->left);
                if(tem->right) q.push(tem->right);
            }
        }
        return level;
    }
};

33.题目描述

输入一棵二叉树，判断该二叉树是否是平衡二叉树。

思路：递归求深度，左右深度差小于1。

class Solution {
public:
    bool IsBalanced_Solution(TreeNode* pRoot) {

        if(pRoot==NULL)
            return true;

        int left=depth(pRoot->left);
        int right=depth(pRoot->right);
        if(abs(left-right)>)
            return false;

        bool booleft=IsBalanced_Solution(pRoot->left);
        bool booright=IsBalanced_Solution(pRoot->right);
        return booleft&&booright;
    }

    int depth(TreeNode *root){
        if(root==NULL)
            return ;
        int left=depth(root->left);
        int right=depth(root->right);
        return (left>right)?(left+):(right+);
    }

};

34.题目描述

一个整型数组里除了两个数字之外，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字。

思路：此题考察的是异或运算的特点：即两个相同的数异或结果为0。

此题用了两次异或运算特点：

（1）第一次使用异或运算，得到了两个只出现一次的数相异或的结果。

（2）因为两个只出现一次的数肯定不同，即他们的异或结果一定不为0，一定有一个位上有1。另外一个此位上没有1，我们可以根据此位上是否有1，将整个数组重新划分成两部分，一部分此位上一定有1，另一部分此位上一定没有1，然后分别对每部分求异或，因为划分后的两部分有这样的特点：其他数都出现两次，只有一个数只出现一次。因此，我们又可以运用异或运算，分别得到两部分只出现一次的数。

class Solution {
public:
    void FindNumsAppearOnce(vector<int> data,int* num1,int *num2) {

        int tmp =;

        for (auto it=data.begin();it<data.end();it++){
            tmp ^=(*it);
        }

        int index = ;
        while((tmp&)==){
            index++;
            tmp=tmp>>;
        }

        for (auto it=data.begin();it<data.end();it++){
            if((*it>>index)&==){
                *num1 ^=(*it);
            }else{
                *num2 ^=(*it);
            }

        }

    }
};

35.题目描述

小明很喜欢数学,有一天他在做数学作业时,要求计算出9~16的和,他马上就写出了正确答案是100。但是他并不满足于此,他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。没多久,他就得到另一组连续正数和为100的序列:18,19,20,21,22。现在把问题交给你,你能不能也很快的找出所有和为S的连续正数序列? Good Luck! 

思路：sum=(a1+an)n/2 = (2a1+n-1)n/2; 2sum=2a1n+n(n-1);

　　2sum-n(n-1)=2a1n>0;这个条件作为循环的条件，建立起n和sum的关系。

　　a1=(2sum-n(n-1))/2n;

class Solution {
public:
    vector<vector<int> > FindContinuousSequence(int sum) {

        int n = ;
        int a1 = ;
        vector<vector<int> >a;
        vector<int>v;
     while ( * sum - n*(n - )>){

        if (( * sum - n*(n - )) % ( * n) == ){
                a1 = ( * sum - n*(n - )) / ( * n);
                cout << n << "----" << a1 << endl;

            v.clear();
            for(int i=;i<n;i++){
                v.push_back(a1+i);
            }

            a.push_back(v);

        }
        n++;
    }
        reverse(a.begin(),a.end());
        return a;

    }
};

36.题目描述

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

思路：两个数差越大，乘积越小。

class Solution {
public:
    vector<int> FindNumbersWithSum(vector<int> array,int sum) {

         vector<int> result;
        int length = array.size();
        int start = ;
        int end = length - ;
        while (start < end)
        {
            if (array[start] + array[end] == sum)
            {
                result.push_back(array[start]);
                result.push_back(array[end]);
                break;
            }
            else if (array[start] + array[end] < sum)
                start++;
            else
                end--;
        }
        return result;

    }
};

37.题目描述

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

class Solution {
public:
    string LeftRotateString(string str, int n) {

        int len = str.length();

        while(n--){
             char ch = str[];
            for(int i=;i<len;i++){
                str[i-]=str[i];
            }
            str[len-]=ch;
        }

        return str;
    }
};

38.题目描述

牛客最近来了一个新员工Fish，每天早晨总是会拿着一本英文杂志，写些句子在本子上。同事Cat对Fish写的内容颇感兴趣，有一天他向Fish借来翻看，但却读不懂它的意思。例如，“student. a am I”。后来才意识到，这家伙原来把句子单词的顺序翻转了，正确的句子应该是“I am a student.”。Cat对一一的翻转这些单词顺序可不在行，你能帮助他么？

思路：获取分割后的字符串数组，逆序输出。

#include <iostream>
#include <vector>
#include <string>
using namespace std;
//字符串分割函数
vector< string> split(string str, string pattern)
{
    vector<string> ret;
    if (pattern.empty()) return ret;
    size_t start = , index = str.find_first_of(pattern, );//查找，并返回index
    while (index != string::npos)
    {
        if (start != index)
            ret.push_back(str.substr(start, index - start));
        start = index + ;
        index = str.find_first_of(pattern, start);
    }
    if (!str.substr(start).empty())
        ret.push_back(str.substr(start));
    return ret;
}

int main()
{
    string str = "the     sky #is blue";
    string pattern = "# ";
    vector< string> result = split(str, pattern);
    //cout << "The result:" << result.size() << endl;
    for (int i = result.size()-; i>=; i--)
    {
        cout << result[i]<<" ";
    }
    cout << endl;
    return ;
}

39.题目描述

LL今天心情特别好,因为他去买了一副扑克牌,发现里面居然有2个大王,2个小王(一副牌原本是54张^_^)...他随机从中抽出了5张牌,想测测自己的手气,看看能不能抽到顺子,如果抽到的话,他决定去买体育彩票,嘿嘿！！“红心A,黑桃3,小王,大王,方片5”,“Oh My God!”不是顺子.....LL不高兴了,他想了想,决定大\小 王可以看成任何数字,并且A看作1,J为11,Q为12,K为13。上面的5张牌就可以变成“1,2,3,4,5”(大小王分别看作2和4),“So Lucky!”。LL决定去买体育彩票啦。 现在,要求你使用这幅牌模拟上面的过程,然后告诉我们LL的运气如何。为了方便起见,你可以认为大小王是0。

class Solution {
public:
    bool IsContinuous( vector<int> numbers ) {

        int max=-;
        int min=;
        int a[] = {};

        int len = numbers.size();
        if (len!=){
            return false;
        }

        for(int i=; i<len; i++){

            a[numbers[i]]++;

            if(numbers[i] == ){
                continue;
            }
            if(a[numbers[i]]>){
                return false;
            }
            if(max < numbers[i]){
                max = numbers[i];
            }
            if(min > numbers[i]){
                min = numbers[i];
            }

        }
        if(max-min <){
            return true;
        }else{
            return false;
        }

    }
};

40.题目描述

每年六一儿童节,牛客都会准备一些小礼物去看望孤儿院的小朋友,今年亦是如此。HF作为牛客的资深元老,自然也准备了一些小游戏。其中,有个游戏是这样的:首先,让小朋友们围成一个大圈。然后,他随机指定一个数m,让编号为0的小朋友开始报数。每次喊到m-1的那个小朋友要出列唱首歌,然后可以在礼品箱中任意的挑选礼物,并且不再回到圈中,从他的下一个小朋友开始,继续0...m-1报数....这样下去....直到剩下最后一个小朋友,可以不用表演,并且拿到牛客名贵的“名侦探柯南”典藏版(名额有限哦!!^_^)。请你试着想下,哪个小朋友会得到这份礼品呢？(注：小朋友的编号是从0到n-1)

class Solution {
public:
    int LastRemaining_Solution(unsigned int n, unsigned int m)
    {
        if (n ==  || n == )
            return -;
        vector <int>a(n);
        for (int i = ; i<n; i++){
            a[i] = i;
        }
        int index = -;
        while (a.size()>){
            index = (m+index)%a.size() ;
            a.erase(a.begin() + index);
            index--;
        }
        return a[];

    }
};