java题集
java题集
第一天
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/two-sum
个人思路
class Solution {
public int[] twoSum(int[] nums, int target) {
for(int i=0;i map=new HashMap<>();
for(int i=0;i 给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。
示例 1:
输入: 123
输出: 321
示例 2:
输入: -123
输出: -321
示例 3:
输入: 120
输出: 21
注意:
假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−231, 231 − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。
class Solution {
public static int reverse(int x) {
if(x==0){
return 0;
}
if(x>(Math.pow(2, 31))-1 || x<(-1*Math.pow(2, 31))){
return 0;
}
long sum = 0;
while(x!=0){
sum = sum*10 + x % 10;
x=x/10;
}
if(sum>(Math.pow(2, 31))-1 || sum<(-1*Math.pow(2, 31))){
return 0;
}else {
return (int) sum;
}
}
}
第二天
给你一个有效的 IPv4 地址 address，返回这个 IP 地址的无效化版本。
所谓无效化 IP 地址，其实就是用 “[.]” 代替了每个 “.”。
示例 1：
输入：address = “1.1.1.1”
输出：“1[.]1[.]1[.]1”
class Solution {
public String defangIPaddr(String address) {
return address.replace(".","[.]");
}
}
给定字符串J 代表石头中宝石的类型，和字符串 S代表你拥有的石头。 S 中每个字符代表了一种你拥有的石头的类型，你想知道你拥有的石头中有多少是宝石。
J 中的字母不重复，J 和 S中的所有字符都是字母。字母区分大小写，因此"a"和"A"是不同类型的石头。
示例 1:
输入: J = “aA”, S = “aAAbbbb”
输出: 3
//思路1：双层循环
class Solution {
public int numJewelsInStones(String J, String S) {
int nums=0;
char[] jcode=J.toCharArray();
char[] scode=S.toCharArray();
for(int i=0;i= 'a' && ch <= 'z'){
b[ch - 'a'] = true;
}else {
b[ch -'A' + 26] = true;
}
}
int length = 0;
for (char ch : S.toCharArray()){
if (ch >= 'a' && ch <= 'z'){
if (b[ch - 'a']){
length++;
}
}else {
if (b[ch -'A' + 26]){
length++;
}
}
}
return length;
}
}
//网上优化思路三
//利用hash思想 内存消耗比思路二稍大
class Solution {
public static int numJewelsInStones(String J, String S) {
int[] s = new int[128];
int count = 0;
char[] c1 = J.toCharArray();
char[] c2 = S.toCharArray();
for(char i:c1) {//a,97 C1出现的字符对应的asc码依次存在数组中相同就覆盖了。
s[i]=1;
}
for(char i:c2) {//a,97 C2出现的字符对应的asc码依次遍历下对应数组s位置是否有值，有的话就说明出现了一次。
if(s[i]==1) {
count++;
}
}
return count;
}
}
第三天
请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点，你将只被给定要求被删除的节点。
思路
因为给定的节点就是要删除的节点, 单链表的话,无法获取当前节点的前置节点
所以只能值删除, 由于要删除的节点并非末尾节点, 所以使用下一个节点的值, 覆盖当前节点, 相当于当前节点已经被删除了
因为下一个节点的值已经保存到当前节点了, 所以只需要将下一个节点删除即可
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {
public void deleteNode(ListNode node) {
node.val = node.next.val;
node.next = node.next.next;
node = node.next;
}
}
编写一个 SQL 查询，查找 Person 表中所有重复的电子邮箱。
示例：
| Id | Emai |
|---|---|
| 1 | [email protected] |
| 2 | [email protected] |
| 3 | [email protected] |
根据以上输入，你的查询应返回以下结果：
| Emai |
|---|
| [email protected] |
//方案1
SELECT DISTINCT P1.Email
FROM Person P1
LEFT JOIN Person P2
ON P1.Email=P2.Email
WHERE P1.Id!=P2.Id;
//方案2
select Email
from Person
group by Email
having count(Email)>1;
删除最外层的括号
有效括号字符串为空 ("")、"(" + A + “)” 或 A + B，其中 A 和 B 都是有效的括号字符串，+ 代表字符串的连接。
例如，""，"()"，"(())()" 和 “(()(()))” 都是有效的括号字符串。
如果有效字符串 S 非空，且不存在将其拆分为 S = A+B 的方法，我们称其为原语（primitive），其中 A 和 B 都是非空有效括号字符串。
给出一个非空有效字符串 S，考虑将其进行原语化分解，使得：S = P_1 + P_2 + … + P_k，其中 P_i 是有效括号字符串原语。
对 S 进行原语化分解，删除分解中每个原语字符串的最外层括号，返回 S 。
//效率极其低下
class Solution {
public String removeOuterParentheses(String S) {
String str="";
Stackstack=new Stack();
for(char c:S.toCharArray()){
if(c=='('){
if(!stack.isEmpty()){
str+='(';
}
stack.push(c);
}
if(c==')'){
if(stack.peek()=='('){
stack.pop();
}if(!stack.isEmpty()){
str+=')';
}
}
}
return str;
}
}
//效率好一倍，但同样低下
//将所有的字符放入栈中，然后每次判断当left等于right时就是一个合法的括号，放入list中，然后将每个list中截取中间的那个
class Solution {
public String removeOuterParentheses(String S) {
Stack tem = new Stack<>();
for (int i = 0; i < S.length(); i++) {
tem.push(S.charAt(i));
}
int left = 0;
int right = 0;
List s = new ArrayList<>();
int start = S.length();
int end = S.length();
while (!tem.isEmpty()) {
if(left == right && left != 0){
s.add(S.substring(start,end));
end = start;
}
char s1 = tem.pop();
if(s1 == '('){
left ++;
}else {
right ++;
}
start --;
}
s.add(S.substring(start,end));
String result = "";
for (String string : s) {
result = string.substring(1, string.length() - 1) + result;
}
return result;
}
}
//效率再番几倍，仍不算好
//将字符串中的字符依次入栈：当前字符为"(" => 直接入栈当前字符为")"：
//栈中元素个数 > 1 => 栈顶元素出栈
//栈中元素个数 == 1 => 栈顶元素出栈，标记这两个括号是最外层括号
//将原字符串中被标记为最外层括号的字符全部删除
class Solution {
public String removeOuterParentheses(String S) {
if (S == null || S.length() == 0) {
return "";
}
LinkedList stack = new LinkedList<>();
boolean[] remains = new boolean[S.length()];
int top;
StringBuilder result = new StringBuilder();
Arrays.fill(remains, true);
stack.push(0);
remains[0] = false;
for (int i = 1; i < S.length(); ++i) {
switch (S.charAt(i)) {
case '(':
stack.push(i);
break;
case ')':
top = stack.pop();
if (stack.size() == 0) {
remains[i] = false;
remains[top] = false;
}
break;
}
}
for (int i = 0; i < S.length(); ++i) {
if (remains[i]) {
result.append(S.charAt(i));
}
}
return result.toString();
}
}
第四天
二叉搜索树的范围和
给定二叉搜索树的根结点 root，返回 L 和 R（含）之间的所有结点的值的和。
二叉搜索树保证具有唯一的值。
示例 1：
输入：root = [10,5,15,3,7,null,18], L = 7, R = 15
输出：32
示例 2：
输入：root = [10,5,15,3,7,13,18,1,null,6], L = 6, R = 10
输出：23
ps:忘记二叉搜索树是啥：大致推出中序遍历，知识点转接地址：https://blog.csdn.net/csdn0123zl/article/details/81253648
//网上思路一：递归思想，时间效率惊人，空间消耗大 地址：https://blog.csdn.net/ca1m0921/article/details/90346983
class Solution {
public int rangeSumBST(TreeNode root, int L, int R) {
int count = 0;
if(root == null){
return 0;
}
if(root.val >= L && root.val <= R){
count += root.val;
count += rangeSumBST(root.left, L, R);
count += rangeSumBST(root.right, L, R);
}
if(root.val < L){
count += rangeSumBST(root.right, L, R);
}
if(root.val > R){
count += rangeSumBST(root.left, L, R);
}
return count;
}
}
大的国家
这里有张 World 表
+-----------------+------------+------------+--------------+---------------+
| name | continent | area | population | gdp |
+-----------------+------------+------------+--------------+---------------+
| Afghanistan | Asia | 652230 | 25500100 | 20343000 |
| Albania | Europe | 28748 | 2831741 | 12960000 |
| Algeria | Africa | 2381741 | 37100000 | 188681000 |
| Andorra | Europe | 468 | 78115 | 3712000 |
| Angola | Africa | 1246700 | 20609294 | 100990000 |
+-----------------+------------+------------+--------------+---------------+
如果一个国家的面积超过300万平方公里，或者人口超过2500万，那么这个国家就是大国家。
编写一个SQL查询，输出表中所有大国家的名称、人口和面积。
输出
+--------------+-------------+--------------+
| name | population | area |
+--------------+-------------+--------------+
| Afghanistan | 25500100 | 652230 |
| Algeria | 37100000 | 2381741 |
+--------------+-------------+--------------+
我的答案
SELECT name,population,area
FROM World
WHERE population>25000000 OR area>3000000
第五天
合并二叉树
给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。
你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为 NULL 的节点将直接作为新二叉树的节点。
示例 1:
输入:
Tree 1 Tree 2
1 2
/ \ / \
3 2 1 3
/ \ \
5 4 7
输出:
合并后的树:
3
/ \
4 5
/ \ \
5 4 7
class Solution {
public TreeNode mergeTrees(TreeNode t1, TreeNode t2) {
if(t1==null &&t2==null) {
return null;
}else if(t1 == null){
return t2;
}else if(t2 == null){
return t1;
}else {
t1.val += t2.val;
t1.left = mergeTrees(t1.left, t2.left);
t1.right = mergeTrees(t1.right, t2.right);
return t1;
}
}
}
第六天
请实现一个算法，在不使用额外数据结构和储存空间的情况下，翻转一个给定的字符串(可以使用单个过程变量)。
给定一个string iniString，请返回一个string，为翻转后的字符串。保证字符串的长度小于等于5000。
测试样例：
“This is nowcoder”
返回：“redocwon si sihT”
import java.util.*;
public class Reverse {
public String reverseString(String iniString) {
// write code here
String str =iniString;
String s="";
for(int i=str.length()-1;i>=0;i--){
char c=str.charAt(i);
s+= String.valueOf(c);
}
return s;
}
}
翻转图像
给定一个二进制矩阵 A，我们想先水平翻转图像，然后反转图像并返回结果。
水平翻转图片就是将图片的每一行都进行翻转，即逆序。例如，水平翻转 [1, 1, 0] 的结果是 [0, 1, 1]。
反转图片的意思是图片中的 0 全部被 1 替换， 1 全部被 0 替换。例如，反转 [0, 1, 1] 的结果是 [1, 0, 0]。
示例 1:
输入: [[1,1,0],[1,0,1],[0,0,0]]
输出: [[1,0,0],[0,1,0],[1,1,1]]
解释:
首先翻转每一行: [[0,1,1],[1,0,1],[0,0,0]]；
然后反转图片: [[1,0,0],[0,1,0],[1,1,1]]
class Solution {
public int[][] flipAndInvertImage(int[][] A) {
int[][] B;
for(int i=0;i第七天
二叉树反转
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
public TreeNode invertTree(TreeNode root) {
if(root==null){
return null;
}
if(root.left==null&&root.right==null){
return null;
}
TreeNode temp=root.left;
root.left=root.right;
root.right=temp;
invertTree(root.left);
invertTree(root.right);
return root;
}
}
第八天
二叉树的最大深度
给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。
示例：
给定二叉树 [3,9,20,null,null,15,7]
3
/ \
9 20
/ \
15 7
返回它的最大深度 3 。