Java 数组遍历和for循环的几种写法，引出一道二维数组中的查找算法题

for循环传统方法数组遍历

一维数组：

	int[] array = {1,2,3};
	for(int i=0;i<array.length;i++){
		System.out.print(array[i]);
	}

二维数组：

	int[][] array = {{1,2,3},{4,5,6},{7,8,9}};
	for(int i=0;i<array.length;i++){
		for(int j=0;j<array[i].length;j++){
			System.out.print(array[i][j]);
		}
	}

forech循环方法(增强for循环)数组遍历

foreach不能对数组或集合进行修改（添加删除操作），如果想要修改就要用for循环

编写格式：

for（元素类型  元素名称 ： 遍历数组（集合）（或者能进行迭代的）对象）{

　　　　　　循环语句

　　　　　}

一维数组：

	int[] array = {1,2,3};
	for(int i : array){
		System.out.print(i);
	}

二维数组：

	int[][] array = {{1,2,3},{4,5,6},{7,8,9}};
	for(int[] i : array){
		for(int j : i)
			System.out.print(j);
	}

二维数组中的查找算法题

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

for循环传统方法解：

 public class Solution {
    public boolean Find(int target, int [][] array) {
        int row = array.length;
        int cols = array[0].length;
        for(int i=0;i<row;i++){
            for(int j=0;j<cols;j++){
                if(array[i][j]==target){
                    return true;
                } else{
                    continue;
                }
            }
        }
        return false;
    }
}

forech循环方法求解：

public class Solution {
    public boolean Find(int [][] array,int target) {
        for(int[] i : array){
            for(int j : i){
                if(j==target)
	                return true;
            }
        }
        return false;
    }
}

算法的优化

上面的解决方法都是暴利枚举，时间复杂度O（n^2）。

public class Solution {
    public boolean Find(int target, int [][] array) {
        for(int i=0;i<array.length;i++){
            int low=0;
            int hight=array[i].length-1;
            while(low<=hight){
                int mid=(low+hight)/2;
                if(target<array[i][mid]){
                    hight = mid-1;
                }else if(target>array[i][mid]){
                    low = mid+1;
                }else return true;
            }
        }
        return false;
    }
}

已知数组是有序的，可以利用二分查找（折半查找），时间复杂度为O（nlogn）。

还有一种更优的解决方案：

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

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

牛逼的绝招：

function Find(target, array)
{
    return array.some(arr=>arr.some(e=>e===target))
}

参考：
https://www.nowcoder.com/profile/8638055/codeBookDetail?submissionId=4180187