中等难度(java实现)
数组中相加为0的三元组
题目描述
给出一个有n个元素的数组S,S中是否有元素a,b,c满足a+b+c=0?找出数组S中所有满足条件的三元组。
注意:
三元组(a、b、c)中的元素必须按非降序排列。(即a≤b≤c)
解集中不能包含重复的三元组。
例如,给定的数组 S = {-10 0 10 20 -10 -40},解集为(-10, 0, 10) (-10, -10, 20)
示例1:
输入:[-2,0,1,1,2]
返回值:[[-2,0,2],[-2,1,1]]
思路:三数相加和为0,则有三数均为0或数组中负数与正数共存,重点:解集中不能包含重复的三元组。
import java.util.*;
public class Solution {
public ArrayList<ArrayList<Integer>> threeSum(int[] num) {
//三数相加和为0,则必有正数和负数,或三数均为0
ArrayList<ArrayList<Integer>> arr = new ArrayList<>();
Arrays.sort(num); //此sort方法只适用于基本数据类型,引用数据类型暂不适用
int len = num.length;
for(int i = 0; i < len; i++){
//排序后的数组若第一个最小的元素就大于0,则直接退出
if(num[i] > 0)
break;
//去重(i > 0时)
if(i > 0 && num[i] == num[i - 1])
continue;
//双指针,求和
int left = i + 1;
int right = len - 1;
while(left < right){ //去重
while(left < right && num[i] + num[left] + num[right] > 0)
right --;
if(left < right && num[i] + num[left] + num[right] == 0){
ArrayList<Integer> list = new ArrayList<>();
list.add(num[i]);
list.add(num[left]);
list.add(num[right]);
arr.add(list);
while(left < right && list.get(1) == num[left]) //去重
left ++;
}
else
left ++;
}
}
return arr;
}
}
重建二叉树
题目描述
输入某二叉树的前序遍历和中序遍历的结果,请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6},则重建二叉树并返回。
示例1:
输入:[1,2,3,4,5,6,7],[3,2,4,1,6,5,7]
返回值:{1,2,5,3,4,6,7}
思路:已知前序—根左右,中序—左根右;递归
/**
* Definition for binary tree
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
import java.util.*;
public class Solution {
public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
//前序遍历——根左右; 中序遍历——左根右
if(pre.length == 0 || in.length == 0)
return null;
TreeNode root = new TreeNode(pre[0]);
//在中序中找到前序的根,通过跟节点将其分为左右子树
for(int i = 0; i < in.length; i++){
if(in[i] == pre[0]){
//递归
//copyOfRange()函数,左闭右开
root.left = reConstructBinaryTree(Arrays.copyOfRange(pre, 1, i+1), Arrays.copyOfRange(in, 0, i));
root.right = reConstructBinaryTree(Arrays.copyOfRange(pre, i+1, pre.length), Arrays.copyOfRange(in, i+1, in.length));
break; //找到与根节点相同的元素,在完成递归操作后直接退出
}
}
return root;
}
}
矩阵的最小路径和
题目描述
给定一个 n * m 的矩阵 a,从左上角开始每次只能向右或者向下走,最后到达右下角的位置,路径上所有的数字累加起来就是路径和,输出所有的路径中最小的路径和。
示例1:
输入:[[1,3,5,9],[8,1,3,4],[5,0,6,1],[8,8,4,0]]
返回值:12
思路:从后向前看,设dp[i][j]表示从左上角元素到(i, j)的最小路径和,dp[i][j] = min(dp[i-1][j], dp[i][j-1]) + a[i][j]。
import java.util.*;
public class Solution {
/**
*
* @param matrix int整型二维数组 the matrix
* @return int整型
*/
public int minPathSum (int[][] matrix) {
// write code here
//动态规划
//用dp[i][j]表示从左上角到(i, j)的最小路径之和
//dp[i][j] = min(dp[i-1][j], dp[i][j-1]) + a[i][j];
int m = matrix.length;
int n = matrix[0].length;
int[][] dp = new int[m][n];
dp[0][0] = matrix[0][0];
for(int i = 1; i < m; i++) //如果目标在第一列,则只能往下走进行累加,因为规定只能向右或向下走
dp[i][0] = dp[i-1][0] + matrix[i][0];
for(int j = 1; j < n; j++) //若在第一行,同上
dp[0][j] = dp[0][j-1] + matrix[0][j];
for(int i = 1; i < m; i++){
for(int j = 1; j < n; j++){
dp[i][j] = Math.min(dp[i-1][j], dp[i][j-1]) + matrix[i][j];
}
}
return dp[m - 1][n - 1];
}
}
顺时针旋转矩阵
题目描述
有一个NxN整数矩阵,请编写一个算法,将矩阵顺时针旋转90度。
给定一个NxN的矩阵,和矩阵的阶数N,请返回旋转后的NxN矩阵,保证N小于等于300。
示例1:
输入:[[1,2,3],[4,5,6],[7,8,9]],3
返回值:[[7,4,1],[8,5,2],[9,6,3]]
方法一:找规律
import java.util.*;
public class Solution {
public int[][] rotateMatrix(int[][] mat, int n) {
// write code here
//找规律
int[][] dp = new int[n][n];
for(int i = 0; i < n; i++)
for(int j = 0; j < n; j++)
dp[j][n-i-1] = mat[i][j];
return dp;
}
}
方法二:两次翻转
//两次翻转,先对角线,再沿竖轴上下反转
//对角线
for(int i = 0; i < n; i++)
for(int j = i + 1; j < n; j++){ //注意j的取值(对角线)
int tmp = mat[i][j];
mat[i][j] = mat[j][i];
mat[j][i] = tmp;
}
for(int i = 0; i < n; i++)
for(int j = 0; j < n / 2; j++){
int tmp = mat[i][j];
mat[i][j] = mat[i][n - j - 1];
mat[i][n - j - 1] = tmp;
}
return mat;
矩阵查找
题目描述
请写出一个高效的在m*n矩阵中判断目标值是否存在的算法,矩阵具有如下特征:
每一行的数字都从左到右排序
每一行的第一个数字都比上一行最后一个数字大
例如:
对于下面的矩阵:
[
[1, 3, 5, 9],
[10, 11, 12, 30],
[230, 300, 350, 500]
]
要搜索的目标值为3,返回true;
示例1
输入:[[1,3,5,9],[10,11,12,30],[230, 300, 350, 500]],3
返回值:true
思路:二分;规律
//二分法
if(matrix == null || matrix.length == 0 || matrix[0].length == 0)
return false;
int left = 0;
int right = matrix[0].length * matrix.length - 1;
int m = matrix.length;
int n = matrix[0].length;
while(left <= right){
int mid = left + (right - left) / 2;
if(target == matrix[mid / n][mid % n])
return true;
else if(target < matrix[mid / n][mid % n])
right = mid - 1;
else left = mid + 1;
}
return false;
//首先选取右上角的数字,如果该数字大于要查的数字,就去掉此数字所在列,若小于则去掉行
int i = 0, j = matrix[0].length - 1;
while(i < matrix.length && j >= 0){
if(matrix[i][j] == target)
return true;
else if(matrix[i][j] > target)
j --;
else
i ++;
}
return false;
加起来和为目标值的组合
题目描述
给出一组候选数C 和一个目标数 T,找出候选数中起来和等于 T 的所有组合。
C 中的每个数字在一个组合中只能使用一次。
注意:
·题目中所有的数字(包括目标数 T )都是正整数
·组合中的数字 (a1, a2, … , ak) 要按非递增排序 (a1 ≤a2 ≤…≤ak ).
·结果中不能包含重复的组合
·组合之间的排序按照索引从小到大依次比较,小的排在前面,如果索引相同的情况下数值相同,则比较下一个索引。
示例1
输入:[100,10,20,70,60,10,50],80
返回值:[[10,10,60],[10,20,50],[10,70],[20,60]]
说明:给定的候选数集是[100,10,20,70,60,10,50],目标数是80
import java.util.*;
public class Solution {
public ArrayList<ArrayList<Integer>> combinationSum2(int[] num, int target) {
ArrayList<ArrayList<Integer>> result = new ArrayList<>();
ArrayList<Integer> list = new ArrayList<>();
if(num == null || num.length == 0) return null;
Arrays.sort(num);
dfs(num, 0, target, list, result);
return result;
}
public void dfs(int[] num, int start, int target, ArrayList<Integer> list, ArrayList<ArrayList<Integer>> result){
if(target == 0){
//result.add(list) —— 将result尾部指向list地址,后续list变化会影响result
//浅拷贝,开辟了一个独立的地址,其中存放list链表,后续list的变化不会影响到result
result.add(new ArrayList<Integer>(list));
return;
}
if(start >= num.length)
return;
for(int i = start; i < num.length; i++){
if(i > start && num[i] == num[i-1]) //去重
continue;
if(num[i] <= target){
list.add(num[i]);
dfs(num, i + 1, target - num[i], list, result);
list.remove(list.size() - 1); //剪枝
}
}
return;
}
}
集合的所有子集
题目描述
现在有一个没有重复元素的整数集合S,求S的所有子集
注意:
你给出的子集中的元素必须按升序排列
给出的解集中不能出现重复的元素
示例1
输入:[1,2,3]
返回值:[[],[1],[2],[3],[1,2],[1,3],[2,3],[1,2,3]]
import java.util.*;
public class Solution {
ArrayList<ArrayList<Integer>> result = new ArrayList<>();
public ArrayList<ArrayList<Integer>> subsets(int[] S) {
ArrayList<Integer> list = new ArrayList<>();
Arrays.sort(S);
//找到该数组内0个,1个,2个....n个元素的组成方法
for(int i = 0; i <= S.length; i++){
backtracking(S, 0, i, list);
}
return result;
}
//回溯模板
public void backtracking(int[] S, int start, int k, ArrayList<Integer> list){
if(k == 0){
result.add(new ArrayList<>(list));
return;
}
for(int i = start; i < S.length; i++){
list.add(S[i]);
backtracking(S, i + 1, k - 1, list);
list.remove(list.size() - 1);
}
}
}
子数组的最大乘积
题目描述
给定一个double类型的数组arr,其中的元素可正可负可0,返回子数组累乘的最大乘积。
示例1
输入:[-2.5,4,0,3,0.5,8,-1]
返回值:12.00000
public class Solution {
public double maxProduct(double[] arr) {
if(arr.length == 0 || arr == null)
return 0;
//二者分别代表以前一个数结尾的子数组的最大和最小乘积
double imax = 1.0, imin = 1.0;
double res = arr[0]; //注
for(int i = 0; i < arr.length; i++){
if(arr[i] < 0){
double tmp = imax;
imax = imin;
imin = tmp;
}
imax = Math.max(arr[i], imax * arr[i]);
imin = Math.min(arr[i], imin * arr[i]);
res = Math.max(res, imax);
}
return res;
}
}
合并区间
题目描述
给出一组区间,请合并所有重叠的区间。
示例1
输入:[[10,30],[20,60],[80,100],[150,180]]
返回值:[[10,60],[80,100],[150,180]]
/**
* Definition for an interval.
* public class Interval {
* int start;
* int end;
* Interval() { start = 0; end = 0; }
* Interval(int s, int e) { start = s; end = e; }
* }
*/
import java.util.*;
public class Solution {
public ArrayList<Interval> merge(ArrayList<Interval> intervals) {
//对左边界进行排序,如果下一个区间的左边界在前一个的边界之内,则考虑是否刷新边界
ArrayList<Interval> res = new ArrayList<>();
//自定义排序规则
intervals.sort((a, b) -> (a.start - b.start));
int len = intervals.size();
int i = 0;
while(i < len){
int left = intervals.get(i).start;
int right = intervals.get(i).end;
while(i < len - 1 && intervals.get(i+1).start <= right){
i++;
//比较当前区间的右边界和下一个区间的左边界
right = Math.max(right, intervals.get(i).end);
}
res.add(new Interval(left, right));
i++;
}
return res;
}
}