C++ 不确定时间复杂性

所以我问了一个关于LeetCode的问题。。。 问题:

Write an efficient algorithm that searches for a target value in an m x n integer matrix. The matrix has the following properties:

Integers in each row are sorted in ascending from left to right.
Integers in each column are sorted in ascending from top to bottom.
 
Example 1:
Input: matrix = [[1,4,7,11,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,24],[18,21,23,26,30]], target = 5
Output: true

Example 2:
Input: matrix = [[1,4,7,11,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,24],[18,21,23,26,30]], target = 20
Output: false

首先，我尝试用常规的暴力方法来回答这个问题： 答复1：

class Solution {
public:
    bool searchMatrix(vector<vector<int>>& matrix, int t) {
        int i=0,j,I=matrix.size(),J,mj;
        for(;i<I;i++)
        {
            j=0;J=matrix[i].size()-1;
            mj=(j+J)/2;
            while(j<=J)
            {
                if(matrix[i][mj]==t)
                    return true;
                else if(matrix[i][mj]<t)
                    j=mj+1;
                else
                    J=mj-1;
                mj=(j+J)/2;
            }
        }
        return false;
    }
};

类解决方案{
公众：
布尔搜索矩阵（向量和矩阵，整数t）{
inti=0，j，i=matrix.size（），j，mj；
为了（；我卖）
返回false；
int mid=hstart；
int start=hstart；
int-end=hend；
while（开始）注意此问题有一个简单的线性解决方案。从右上角开始。如果元素大于目标，则向左移动一个；如果元素小于目标，则向下移动一个。重复此操作，直到找到目标或离开左边缘或底边。最多进行
2*n
比较。（等效地，从左下角开始向上或向右移动）。我认为你的第二个解决方案实际上并没有你想象的那么快地减少搜索空间。我建议你一步一步地通过它并记录调用。你想分而治之吗？将矩阵分成四个四分之一，你应该只需要递归地搜索其中一个。@dratenik检查中心的元素只允许你消除一个quarter（左上角或右下角），而不是三个。给你留下四分之三的搜索空间。@dratenik我不相信这会让你消除超过四分之一的搜索空间；只检查中心就可以消除相同的搜索空间。
class Solution {
public:
    
    bool VFinder(vector<vector<int>>& matrix, int hstart, int hend, int vstart, int vend, int ele)
    {
        if(vstart > vend || hstart > hend)
            return false;
        
        int mid = vstart;
        int start = vstart;
        int end = vend;
        while(start<=end)
        {
            mid = (int)((start + end) / 2);
            if (start == end)
         {
            if (matrix[mid][hstart] == ele)
            {
               return true;
            }
            else
            {
               return HFinder(matrix, hstart + 1, hend, vstart, mid, ele);
            }
         }
            else
            {if(matrix[mid][hstart] <ele && matrix[mid+1][hstart] > ele)
                return HFinder(matrix, hstart+1, hend, vstart, mid,ele);
            else if(matrix[mid][hstart] <ele)
                start = mid+1;
            else if(matrix[mid][hstart] >ele)
                end = mid-1;
            else if(matrix[mid][hstart] == ele)
                return true;}
        }
        return false;
    }
    
    bool HFinder(vector<vector<int>>& matrix, int hstart, int hend, int vstart, int vend, int ele)
    {
        if(hstart > hend || vstart > vend)
            return false;
        
        int mid = hstart;
        int start = hstart;
        int end = hend;
        while(start<=end)
        {
            mid = (int)((start + end) / 2);
            if (start == end)
         {
            if (matrix[vstart][mid] == ele)
            {
               return true;
            }
            else
            {
               return VFinder(matrix, hstart, mid, vstart + 1, vend, ele);
            }
         }
            else
            {if(matrix[vstart][mid] <ele && matrix[vstart][mid+1] > ele)
                return VFinder(matrix, hstart, mid, vstart+1, vend, ele);
            else if(matrix[vstart][mid] <ele)
                start = mid+1;
            else if(matrix[vstart][mid] >ele)
                end = mid-1;
            else if(matrix[vstart][mid] == ele)
                return true;}
        }
        return false;
    }
    
    bool searchMatrix(vector<vector<int>>& matrix, int target) {
        int horizontal = matrix[0].size();
        int vertical = matrix.size();
        return HFinder(matrix, 0, horizontal-1, 0, vertical-1, target);
    }
};