二位数组中的查找
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;
}
}