剑指offer 37、38：数字在排序数组中出现的次数 、二叉树的深度

36：题目描述
统计一个数字在排序数组中出现的次数。
思路：二分法查找

class Solution {
public:
    int process(vector<int>&data,float k)
    {
        int left=0,right=data.size()-1;
        int mid=0;
        while(left<=right)
        {
            mid=(left+right)>>1;
            if(data[mid]>k)
                right=mid-1;
            else if(data[mid]<k)
                left=mid+1;
        }
        return left;
    }
    int GetNumberOfK(vector<int> data ,int k) {
        if(data.empty())
            return 0;
        int left=process(data,k-0.5);
        int right=process(data,k+0.5);
        return right-left;
    }
};
# -*- coding:utf-8 -*-
class Solution:
    def GetNumberOfK(self, data, k):
        return data.count(k)
        # write code here

37.题目描述
输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。
思路：递归法，深度优先搜索dfs，从底部开始搜索，每次返回节点的左右子树最大值加一，加一是因为当前节点的深度。
层序法也可以

/*
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;
        int l_left=TreeDepth(pRoot->left);
        int l_right=TreeDepth(pRoot->right);
        return max(l_left+1,l_right+1);
    }
};

class Solution {
public:
    int TreeDepth(TreeNode* pRoot)
    {
        if(pRoot==NULL)
            return 0;
        queue<TreeNode*>node;
        node.push(pRoot);
        int deep=0;
        while(!node.empty())
        {
            int len=node.size();
            while(len)
            {
                TreeNode* temp = node.front();
                if(temp->left != NULL)
                    node.push(temp->left);
                if(temp->right != NULL)
                    node.push(temp->right);
                node.pop();
                --len;
            }
            ++deep;
        }
        return deep;
    }
};

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def TreeDepth(self, pRoot):
        if pRoot==None:
            return 0
        left=self.TreeDepth(pRoot.left)
        right=self.TreeDepth(pRoot.right)
        return max(left+1,right+1)
        # write code here