数组（2）——中等难度

中等难度（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;
        
        
    }
}