剑指offer之数组

二位数组中的查找

1.在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
1.暴力法：
时间复杂度 n^2

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(target == array[i][j]){
                    return true;
                }
            }
        }
        return false;
    }
}

因为矩阵有序
思路1：把每一行看成有序递增的数组，
利用二分查找，
通过遍历每一行得到答案，
时间复杂度是nlogn

public class Solution {
    public boolean Find(int target, int[][] array) {
        for (int i=0;i<array.length;i++) {
            int low = 0;//获取每行中最小值下标
            int high = array[i].length-1;//获取每行中最大值下标
            while(low <= high){
                int mid = (low+high) / 2;
                if (target>array[i][mid]){
                    low = mid + 1 ;
                }else if (target<array[i][mid]){
                    high = mid - 1 ;
                }else{
                    return true;
                }
            }
        }
        return false;
    }
}

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

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

数组中重复的数字

2.在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是第一个重复的数字2。

思路1：将输入数组排序，再判断相邻位置是否存在相同数字，如果存在，对 duplication 赋值返回，否则继续比较。时间复杂度：O(nlogn)O(nlogn)
空间复杂度：O(1)O(1)

import java.util.Arrays;
public class Solution {
    
    // Parameters:
    //    numbers:     an array of integers
    //    length:      the length of array numbers
    //    duplication: (Output) the duplicated number in the array number,length of duplication array is 1,so using duplication[0] = ? in implementation;
    //                  Here duplication like pointor in C/C++, duplication[0] equal *duplication in C/C++
    //    这里要特别注意~返回任意重复的一个，赋值duplication[0]
    // Return value:       true if the input is valid, and there are some duplications in the array number
    //                     otherwise false
    public boolean duplicate(int numbers[],int length,int [] duplication) {
        if (numbers==null || length==0){
            return false;
        }
        Arrays.sort(numbers);
        for(int i=0;i<length-1;i++){
            if(numbers[i]==numbers[i+1]){
                duplication[0] = numbers[i];
                return true;
            }
        }

        return false;
    }
}

思路2：利用 HashSet 解决，从头到尾扫描数组，每次扫描到一个数，判断当前数是否存在 HashSet 中，如果存在，则重复，对 duplication 赋值返回，否则将该数加入到 HashSet 中
时间复杂度：O(n)O(n)
空间复杂度：O(n)O(n)

import java.util.HashSet;
import java.util.Set;
public class Solution {
    // Parameters:
    //    numbers:     an array of integers
    //    length:      the length of array numbers
    //    duplication: (Output) the duplicated number in the array number,length of duplication array is 1,so using duplication[0] = ? in implementation;
    //                  Here duplication like pointor in C/C++, duplication[0] equal *duplication in C/C++
    //    这里要特别注意~返回任意重复的一个，赋值duplication[0]
    // Return value:       true if the input is valid, and there are some duplications in the array number
    //                     otherwise false
    public boolean duplicate(int numbers[],int length,int [] duplication) {
        if (numbers==null || length==0){
            return false;
        }
        Set<Integer> set = new HashSet<>();
        for (int i=0;i<length;i++){
            if (set.contains(numbers[i])){
                duplication[0] = numbers[i];
                return true;
            }
            set.add(numbers[i]);
        }
        return false;
    }
}

思路3：
数组的长度为 n 且所有数字都在 0 到 n-1 的范围内，我们可以将每次遇到的数进行"归位"，当某个数发现自己的"位置"被相同的数占了，则出现重复。
扫描整个数组，当扫描到下标为 i 的数字时，首先比较该数字（m）是否等于 i，如果是，则接着扫描下一个数字；如果不是，则拿 m 与第 m 个数比较。如果 m 与第 m 个数相等，则说明出现重复了；如果 m 与第 m 个数不相等，则将 m 与第 m 个数交换，将 m “归位”，再重复比较交换的过程，直到发现重复的数

举个栗子：
以数组 {2,3,1,0,2,5,3} 为例
当 i = 0 时，nums[i] = 2 != i，判断 nums[i] 不等于 nums[nums[i]]，交换 nums[i] 和 nums[nums[i]]，交换后数组为：{1,3,2,0,2,5,3}
此时 i = 0，nums[i] = 1 != i，判断 nums[i] 不等于 nums[nums[i]]，交换 nums[i] 和 nums[nums[i]]，交换后数组为：{3,1,2,0,2,5,3}
此时 i = 0，nums[i] = 3 != i，判断 nums[i] 不等于 nums[nums[i]]，交换 nums[i] 和 nums[nums[i]]，交换后数组为：{0,1,2,3,2,5,3}
此时 i = 0，nums[i] = 0 = i，继续下一组
当 i = 1，nums[i] = 1 = i，继续下一组
当 i = 2，nums[i] = 2 = i，继续下一组
当 i = 3，nums[i] = 3 = i，继续下一组
当 i = 4，nums[i] = 2 != i，判断 nums[i] 等于 nums[nums[i]]，出现重复，赋值返回
时间复杂度：O(n)O(n)
空间复杂度：O(1)O(1)

构建乘积数组

题目描述
给定一个数组A[0,1,…,n-1],请构建一个数组B[0,1,…,n-1],其中B中的元素B[i]=A[0]A[1]…*A[i-1]A[i+1]…*A[n-1]。不能使用除法。（注意：规定B[0] = A[1] * A[2] * … * A[n-1]，B[n-1] = A[0] * A[1] * … * A[n-2];）
思路1：暴力破解时间复杂度On^2

import java.util.ArrayList;
public class Solution {
    public int[] multiply(int[] A) {
        int[] B = new int[A.length];
        for (int i=0;i<B.length;i++){
            B[i]=1;
            for(int j =0;j<A.length;j++){
                if (j!=i){
                    B[i]=A[j]*B[i];
                }
            }
            
        }
        return B;
    }
}

思路2：
可以把B[i]=A[0]A[1]…A[i-1]A[i+1]…A[n-1]。看成A[0]A[1]…A[i-1]和A[i+1]…A[n-2]A[n-1]两部分的乘积。
即通过A[i]项将B[i]分为两部分的乘积。效果相当于是个对角矩阵。

第一个for循环用来计算上图1范围的数，第二个for循环用来计算上图2范围的数。
时间复杂度On

import java.util.ArrayList;
public class Solution {
    public int[] multiply(int[] A) {

        int[] B = new int[A.length];
        B[0] = 1 ;
        for (int i=1;i<B.length;i++){
            B[i] = A[i-1] * B[i-1];
        }
        int temp = 1;
        for (int j=B.length-1;j>=0;j--){
            B[j] = temp *  B[j];
            temp = A[j] * temp;
        }
        return B;
    }
}