1、在一个 n * m 的二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个高效的函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
示例:
现有矩阵 matrix 如下：
[
[1, 4, 7, 11, 15],
[2, 5, 8, 12, 19],
[3, 6, 9, 16, 22],
[10, 13, 14, 17, 24],
[18, 21, 23, 26, 30]
]
给定 target = 5，返回 true。
给定 target = 20，返回 false。
限制：
0 <= n <= 1000
0 <= m <= 1000
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/er-wei-shu-zu-zhong-de-cha-zhao-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
题解
很明显数组有一定的规律，即每行从左到右递增，每列从上往下递增，可以从右上开始进行判断，若给定值相等，return true，如果小于右上，则列–，否则行++，重复进行，直至得到相等的值，如果循环结束后仍不存在相同的值，则可以判定不存在，返回false
class Solution {
public boolean findNumberIn2DArray(int[][] matrix, int target) {
if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
return false;
}
int rows = matrix.length, columns = matrix[0].length;
int row = 0, column = columns - 1;
while (row < rows && column >= 0) {
int num = matrix[row][column];
if (num == target) {
return true;
} else if (num > target) {
column--;
} else {
row++;
}
}
return false;
}
}
2、给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。
示例 1:
输入: s = “abcabcbb”
输出: 3
解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。
示例 2:
输入: s = “bbbbb”
输出: 1
解释: 因为无重复字符的最长子串是 “b”，所以其长度为 1。
示例 3:
输入: s = “pwwkew”
输出: 3
解释: 因为无重复字符的最长子串是 “wke”，所以其长度为 3。
请注意，你的答案必须是 子串 的长度，“pwke” 是一个子序列，不是子串。
示例 4:
输入: s = “”
输出: 0
提示：
0 <= s.length <= 5 * 104
s 由英文字母、数字、符号和空格组成
题解
对于此题，我们要寻找的是一段连续字符串的最大不重复子串，因此可以采用双指针的方式进行查找，即窗口。左指针从字符串首字符开始查找，右指针设置为-1，即认为是指针末尾。另外设置一个HashSet集合用来存储不重复的字符，首先左指针不动，然后右指针不断右移，如果当前右指针所指示的字符不存在set中，则将该字符存入set集合中，同时右指针后移，重复进行，如果当前右指针已经存在set中，则从set集合中删除此字符，同时左指针右移。此时字符串长度为res-i+1
代码如下：
public int lengthOfLongestSubstring(String s) {
int n = s.length();
int res = -1, max=0;//设置右指针为-1，max用于存储最长字符长度，即最终结果
Set<Character> set = new HashSet<Character>();//设置set集合存储字符判断字符是否出现过
for(int i=0;i<n;++i){
if(i!=0){
//左指针右移，删除一个元素
set.remove(s.charAt(i-1));
}
while(res+1<n && !set.contains(s.charAt(res+1))){
//不断移动右指针
set.add(s.charAt(res+1));
res++;
}
//第i到res个字符是一个最长的字符串
max = Math.max(max,res-i+1);
}
return max;
}
3.请实现一个函数，把字符串 s 中的每个空格替换成"%20"。
示例 1：
输入：s = “We are happy.”
输出：“We%20are%20happy.”
限制：
0 <= s 的长度 <= 10000
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/ti-huan-kong-ge-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
题解
一、利用char数组存储新字符串
public String replaceSpace(String s) {
char[] chars = new char[s.length()*3];
int size = 0;
for(int i=0;i<s.length();i++){
char c = s.charAt(i);
if(c==' '){
chars[size++]='%';
chars[size++]='2';
chars[size++]='0';
}
else{
chars[size++]=c;
}
}
String newStr = new String(chars, 0, size);
return newStr;
}
二、利用StringBuilder存储新字符串，利用append添加字符
public String replaceSpace(String s) {
StringBuilder sb = new StringBuilder();
for(int i=0;i<s.length();i++){
char c = s.charAt(i);
if(c==' '){
sb.append("%20");
}else{
sb.append(c);
}
}
return sb.toString();
}
4.给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。
示例 1：
输入：nums1 = [1,3], nums2 = [2]
输出：2.00000
解释：合并数组 = [1,2,3] ，中位数 2
示例 2：
输入：nums1 = [1,2], nums2 = [3,4]
输出：2.50000
解释：合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5
示例 3：
输入：nums1 = [0,0], nums2 = [0,0]
输出：0.00000
示例 4：
输入：nums1 = [], nums2 = [1]
输出：1.00000
示例 5：
输入：nums1 = [2], nums2 = []
输出：2.00000
提示：
nums1.length == m
nums2.length == n
0 <= m <= 1000
0 <= n <= 1000
1 <= m + n <= 2000
-106 <= nums1[i], nums2[i] <= 106
进阶：你能设计一个时间复杂度为 O(log (m+n)) 的算法解决此问题吗？
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/median-of-two-sorted-arrays
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
利用两个数组的指针进行数组的删除（理论上排除一部分不需要的值，同时需要修改k的值）
class Solution {
public double findMedianSortedArrays(int[] nums1, int[] nums2) {
int length1 = nums1.length, length2 = nums2.length;
int totalLength = length1 + length2;
if (totalLength % 2 == 1) {
int midIndex = totalLength / 2;
double median = getKthElement(nums1, nums2, midIndex + 1);
return median;
} else {
int midIndex1 = totalLength / 2 - 1, midIndex2 = totalLength / 2;
double median = (getKthElement(nums1, nums2, midIndex1 + 1) + getKthElement(nums1, nums2, midIndex2 + 1)) / 2.0;
return median;
}
}
public int getKthElement(int[] nums1, int[] nums2, int k) {
/* 主要思路：要找到第 k (k>1) 小的元素，那么就取 pivot1 = nums1[k/2-1] 和 pivot2 = nums2[k/2-1] 进行比较
* 这里的 "/" 表示整除
s1 中小于等于 pivot1 的元素有 nums1[0 .. k/2-2] 共计 k/2-1 个
* nums2 中小于等于 pivot2 的元素有 nums2[0 .. k/2-2] 共计 k/2-1 个
ivot = min(pivot1, pivot2)，两个数组中小于等于 pivot 的元素共计不会超过 (k/2-1) + (k/2-1) <= k-2 个
* 这样 pivot 本身最大也只能是第 k-1 小的元素
pivot = pivot1，那么 nums1[0 .. k/2-1] 都不可能是第 k 小的元素。把这些元素全部 "删除"，剩下的作为新的 nums1 数组
* 如果 pivot = pivot2，那么 nums2[0 .. k/2-1] 都不可能是第 k 小的元素。把这些元素全部 "删除"，剩下的作为新的 nums2 数组
们 "删除" 了一些元素（这些元素都比第 k 小的元素要小），因此需要修改 k 的值，减去删除的数的个数
*/
int length1 = nums1.length, length2 = nums2.length;
int index1 = 0, index2 = 0;
int kthElement = 0;
while (true) {
// 边界情况
if (index1 == length1) {
return nums2[index2 + k - 1];
}
if (index2 == length2) {
return nums1[index1 + k - 1];
}
if (k == 1) {
return Math.min(nums1[index1], nums2[index2]);
}
// 正常情况
int half = k / 2;
int newIndex1 = Math.min(index1 + half, length1) - 1;
int newIndex2 = Math.min(index2 + half, length2) - 1;
int pivot1 = nums1[newIndex1], pivot2 = nums2[newIndex2];
if (pivot1 <= pivot2) {
k -= (newIndex1 - index1 + 1);
index1 = newIndex1 + 1;
} else {
k -= (newIndex2 - index2 + 1);
index2 = newIndex2 + 1;
}
}
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Aq1z4Rca-1619352644070)(C:\Users\Lin\AppData\Roaming\Typora\typora-user-images\image-20210425163606566.png)]
题解
一、使用递归，分别构建左子树和右子树。首先找到根节点在中序遍历中的位置，从而得到左子树和右子树的长度，进而递归构建（每次修改指针，指向下一个根节点（子树的根节点））
public class Solution1 {
private Map<Integer,Integer> indexMap;
public TreeNode myBuildTree(int[] preorder, int preorderLeft,int preorderRight, int[] inorder , int inorderLeft, int inorderRight) {
if (preorderLeft>preorderRight){
return null;
}
//查得头结点
int pre_root = preorderLeft;
int in_root = indexMap.get(preorder[pre_root]);
//构建根节点
TreeNode root = new TreeNode(preorder[pre_root]);
//构建左子树
int size_leftTree = in_root - inorderLeft;
root.left = myBuildTree(preorder,preorderLeft+1,preorderLeft+size_leftTree,inorder,inorderLeft,in_root);
//构建右子树
root.right = myBuildTree(preorder,preorderLeft+size_leftTree+1,preorderRight,inorder,in_root+1,inorderRight);
return root;
}
public TreeNode buildTree(int[] preorder,int[] inorder){
int n = preorder.length;
indexMap = new HashMap<>();
for (int i = 0; i < n; i++) {
indexMap.put(inorder[i],i);
}
return myBuildTree(preorder,0,n-1,inorder,0,n-1);
}
}
解法二、使用迭代进行构建，利用栈进行构建，思路：将前序遍历的值进行压栈，直到找到左子树的根节点（此时栈顶的值等于中序遍历序列的第一个），然后转而构建右子树，同理进行迭代，对于中序遍历，需要一个指针，每次出栈指针后移一位。
public class Solution2 {
public TreeNode buildTree(int[] preorder, int[] inorder) {
int n = preorder.length;
if (n<=0){
return null;
}
//对中序遍历序列设置指针，从零开始指向第一个元素
int index = 0;
Deque<TreeNode> stack = new LinkedList<>();
//构建根节点，并入栈
TreeNode root = new TreeNode(preorder[0]);
stack.push(root);
//构建子树
for (int i = 1; i < n; i++) {
//取出栈顶元素
TreeNode treeNode = stack.peek();
//如果栈顶元素值不等于中序遍历指针对应的值，说明此元素为栈顶节点的左子树
if (treeNode.val!=inorder[index]){
//链接并入栈
treeNode.left = new TreeNode(preorder[i]);
stack.push(treeNode.left);
}else {//此时说明已经找到左子树的最后一个元素，即最左下，依次弹出栈顶元素并将index指针后移一位，当栈顶元素值不等于指针对应元素的值时，说明当前i指针指向的值为前节点的右子树
while (!stack.isEmpty()&&stack.peek().val==inorder[index]){//此处treeNode=刚才弹出的栈顶元素，不能使用，仍需使用peek()取出此时的栈顶元素的值
treeNode = stack.pop();
++index;
}
//连接右子树，并压栈
treeNode.right = new TreeNode(preorder[i]);//前序遍历总是根节点优先访问
stack.push(treeNode.right);
}
}
return root;
}
}
扫一扫
794
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
