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

O（n）的算法
利用二维数组由上到下，由左到右递增的规律，
那么选取右上角或者左下角的元素a[row][col]与target进行比较，
当target小于元素a[row][col]时，那么target必定在元素a所在行的左边,
即col–；
当target大于元素a[row][col]时，那么target必定在元素a所在列的下边,
即row++；

假设是一个nn的矩阵，因为每个一维数组的长度相同。故最坏情况是查找的元素在左下角，运行时间T(n)=
2n=O（n）

public static bool Find(int target, int[][] array)
        {
            int row = 0;
            int col = array[0].Length - 1;
            while (row <= array.Length - 1 && col >= 0)
            {
                if (target == array[row][col])
                    return true;
                else if (target > array[row][col])
                    row++;
                else
                    col--;
            }
            return false;

        }

我们考虑每个一维数组不是等长的情况。这种情况会有限制
例如：

int[][] array = new int[3][];
            array[0] =new int[]{ 1,2,3,5};
            array[1]=new int[]{3,4,5,6,11};
            array[2] = new int[] {7,8,9,10 };
            Console.Write(Find(11,array));//false

此时我们考虑使用循环遍历每一行，加对行进行二分查找。

二分查找

class Program
    {
        static void Main(string[] args)
        {
            int[][] array = new int[3][];
            array[0]=new int[]{1,3,5,7,9};
            array[1] = new[] {2, 4, 6, 8};
            array[2] = new[] {3, 12, 36, 108,109,136};
            array[3] = new[] 10, 16, 64, 256,257};
            Console.Write(Find(10,array));//true
        }
        
        public static bool Find(int target, int[][] array)
        {
            foreach (var row in array)
            {
                int i = BinarySearch(row, 0, row.Length - 1, target);
                if (i != -1) return true;
            }

            return false;
        }

        public static int BinarySearch(int[] arrary,int low,int high,int key)
        {
            if (low <= high)
            {
                int q = (low+high)/2;
                if (arrary[q] == key) return q;
                else if (arrary[q] < key) return BinarySearch(arrary, q + 1, high, key);
                else return BinarySearch(arrary, low, q - 1,key);
            }

            return -1;
        }
    }

显而易见，T(n)=nlgn,此时对于每个一维数组长度不一致的情况也能满足。

来源：CSDN

作者：pw8992134

链接：https://blog.csdn.net/pw8992134/article/details/104135964

标签

target

矩阵