矩阵（二维数组）局部极大/小值-python实现

题目来源：
某为面试/算法第四版：Algs4-1.4.19矩阵的局部最小元素

参考思路：传送

CODE：

import numpy as np

'''
def findMin():
    arr=np.random.rand(10,10)
    index_arr=np.zeros((10,10))

    for i in range(arr.shape[0]):
        for j in range(arr.shape[1]):
            if i>0 and i<arr.shape[0]-1 and j>0 and j<arr.shape[1]-1:
                if(
                    arr[i][j]<arr[i][j-1]
                    and
                    arr[i][j]<arr[i][j+1]
                    and
                    arr[i][j]<arr[i-1][j]
                    and
                    arr[i][j]<arr[i+1][j]
                ):
                    return arr[i][j],i,j
    return 'None'
'''



def findMin2(arr):
    print(arr)
    if arr.shape[0]==arr.shape[1]==1 or arr.shape[0]==arr.shape[1]==2 :
        assert False,'No Result.'
    middle_row=int(arr.shape[0]/2)
    middle_col=int(arr.shape[1]/2)
    next_cell=[]

    if np.min(arr[middle_row,:]) < np.min(arr[:,middle_col]):
        # min num at row way
        min_cell=[
            np.min(arr[middle_row,:]),    #num
            middle_row,                   #row_index
            np.argmin(arr[middle_row,:])  #col_index
            ]

        next_cell_top = [
            arr[middle_row+1][min_cell[2]],
            middle_row+1, 
            min_cell[2]
            ]
        next_cell_bottom = [
            arr[middle_row-1][min_cell[2]],
            middle_row-1, 
            min_cell[2]
            ]
        
        if next_cell_top[0]<min_cell[0]:
            next_cell=next_cell_top
        elif next_cell_bottom[0]<min_cell[0]:
            next_cell=next_cell_bottom
        else:
            next_cell=min_cell

    else:
        # min num at col way
        min_cell=[
            np.min(arr[:,middle_col]),
            np.argmin(arr[:,middle_row]),
            middle_col
            ]
        next_cell_left = [
            arr[min_cell[2]][middle_col-1],
            min_cell[2],
            middle_col-1
            ]
        
        next_cell_right = [
            arr[min_cell[2]][middle_col+1],
            min_cell[2],
            middle_col+1
            ]

        if next_cell_left[0]<min_cell[0]:
            next_cell=next_cell_left
        elif next_cell_right[0]<min_cell[0]:
            next_cell=next_cell_right
        else:
            next_cell=min_cell

    if min_cell[0]==next_cell[0]:
        return min_cell
    elif next_cell[1]<middle_row:
        if next_cell[2]<middle_col:
            return findMin2(arr[:middle_row,:middle_col])
        else:
            return findMin2(arr[:middle_row,middle_col:])
    else:
        if next_cell[2]<middle_col:
            return findMin2(arr[middle_row:,:middle_col])
        else:
            return findMin2(arr[middle_row:,middle_col:])

    
arr=np.random.randint(9, size=(19,19)) 

local_min,row_index ,col_index =findMin2(arr)

print("result-localmin:",local_min,'\t at ({}.{})'.format(row_index,col_index))

思路讲解：
思路是分治
极端的情况没咋处理
大体思想是矩阵中间横竖分成四份
先找出横竖两条线上最小的那一个值 min_cell
以cell为结尾的变量都是一个list数据格式【数据，行，列】
然后最小值在行/列上就把相邻行/列两个值比较，将更小的 next_cell赋给 min_cell

之后是判断逻辑
当 next_cell==min_cell，我们找到了一个结果，返回即可
否则根据next_cell的所在位置，我们在
↖️↗️
↙️↘️
四个象限分割小矩阵，把小矩阵当作新的目标矩阵再找一遍

极端情况无非是四个边角和小矩阵是1，2个边长时如何操作，看情况自己琢磨吧。