二维数组中的查找

一、二维数组中的查找

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

1.暴力解法
题解：挨个遍历数组，如果能找到，返回true，找不到返回false。
暴力大法好0.0

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

时间复杂度：O(n^2）
空间复杂度：O(1)

2.从左下找
题解：
利用该二维数组的性质：
每一行都按照从左到右递增的顺序排序，
每一列都按照从上到下递增的顺序排序
改变个说法，即对于左下角的值 m，m 是该行最小的数，是该列最大的数
每次将 m 和目标值 target 比较：
当 m < target，由于 m 已经是该行最大的元素，想要更大只有从列考虑，取值右移一位
当 m > target，由于 m 已经是该列最小的元素，想要更小只有从行考虑，取值上移一位
当 m = target，找到该值，返回 true
用某行最小或某列最大与 target 比较，每次可剔除一整行或一整列

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

时间复杂度：O(行高 + 列宽)
空间复杂度：O(1)

二、回文数组（牛客上的，用到了动态规划，暂时不会，记录后补）

三、数组操作

题目描述
输入一个无序整数数组，调整数组中数字的顺序， 所有偶数位于数组的前半部分，使得所有奇数位于数组的后半部分。
要求时间复杂度为O(n)。

输入描述:
给定无序数组。
长度不超过1000000。

输出描述:
所有偶数位于数组的前半部分，所有奇数位于数组的后半部分。
如果有多个答案可以输出任意一个正确答案。

示例1

输入
2 4 5 7 8 1
输出
2 4 8 7 5 1

解题思路：

设置双指针，一个从前往后走，一个从后往前走，遇到不符合条件的就进行交换

1.

import java.util.*;
public class Main{
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        String str="";
        while(sc.hasNext()){
            str=sc.nextLine();
            String[] s=str.split(" ");
            int[] arr=new int[s.length];
            for(int i=0;i<s.length;i++){
                arr[i]=Integer.parseInt(s[i]);
            }
            int i=0;
            int j=arr.length-1;
            while (i<j){
                while(i<j&&arr[i]%2==0){
                    i++;
                }
                while(i<j&&arr[j]%2==1){
                    j--;
                }
                 
                    int temp=arr[i];
                    arr[i]=arr[j];
                    arr[j]=temp;
                    i++;
                    j--;
              
            }
            for(int k=0;k<arr.length;k++){
                System.out.print(arr[k]+" ");
            }
        }
    }
}

2、

import java.util.*;
public class Main {
    private static void swap(int [] array){
        if (array == null || array.length == 0)
            return;
        int low = 0, high = array.length - 1;
        while(low < high){
            if (array[low] % 2 == 0){
                low ++;
            }
            if (array[high] % 2 == 1){
                high --;
                continue;
            }
            int temp = array[low];
            array[low] = array[high];
            array[high] = temp;
        }
    }
    //输入输出
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        //切割
        String [] Astr = str.split(" ");
        //数组
        int n = Astr.length;
        int[] array = new int[n];
        for(int i = 0; i < n; i ++){
            array[i] = Integer.parseInt(Astr[i]);
        }
        //调用主函数Solution
        swap(array);
        for (int i = 0; i < array.length; i++){
            System.out.print(array[i] + " ");
        }
    }
}

四、中位数（后补）