day01
static 关键字
1、修饰属性
Java静态属性和类相关, 和具体的实例无关. 换句话说, 同一个类的不同实例共用同一个静态属性
2、修饰方法
如果在任何方法上应用 static 关键字，此方法称为静态方法。
静态方法属于类，而不属于类的对象。
可以直接调用静态方法，而无需创建类的实例。
静态方法可以访问静态数据成员，并可以更改静态数据成员的值
注意事项1: 静态方法和实例无关, 而是和类相关. 因此这导致了两个情况:
静态方法不能直接使用非静态数据成员或调用非静态方法(非静态数据成员和方法都是和实例相关的).
this和super两个关键字不能在静态上下文中使用(this 是当前实例的引用, super是当前实例父类实例的引用, 也
是和当前实例相关).
注意事项2
我们曾经写的方法为了简单, 都统一加上了 static. 但实际上一个方法具体要不要带 static, 都需要是情形而定.
main 方法为 static 方法
3、代码块
4、修饰类
day02
1、方法没有返回值一般都是说构造函数，void叫返回值为空
2、给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
你可以假设数组中无重复元素。
示例 1:
输入: [1,3,5,6], 5
输出: 2
示例 2:
输入: [1,3,5,6], 2
输出: 1
示例 3:
输入: [1,3,5,6], 7
输出: 4
示例 4:
输入: [1,3,5,6], 0
输出: 0
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/search-insert-position
class Solution {
public int searchInsert(int[] nums, int target) {
//二分查找
int left = 0;
int right = nums.length - 1;
while(left <= right){
int mid = (left + right) / 2;
if(nums[mid] == target){
return mid;
}else if(nums[mid] > target){
right = mid - 1;
}else{
left = mid + 1;
}
}
return left;
// for(int i = 0; i < nums.length; i++){
// if(target <= nums[i]){
// return i;
// }
// }
// return nums.length;
}
}
day03
链接：https://www.nowcoder.com/questionTerminal/18bbe97d85584ea9a83042c6a4287d5c
来源：牛客网
下面的方法，当输入为2的时候返回值是多少？
public static int getValue(int i) {
int result = 0;
switch (i) {
case 1:
result = result + i;
case 2:
result = result + i * 2;
case 3:
result = result + i * 3;
}
return result;
}
case只是个入口，如果没有break;会从入口处将后面所有的case全部执行一次。
383.赎金信：
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/ransom-note
给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，判断第一个字符串ransom能不能由第二个字符串magazines里面的字符构成。如果可以构成，返回 true ；否则返回 false。
(题目说明：为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，组成单词来表达意思。)
注意：
你可以假设两个字符串均只含有小写字母。
canConstruct(“a”, “b”) -> false
canConstruct(“aa”, “ab”) -> false
canConstruct(“aa”, “aab”) -> true
class Solution {
public boolean canConstruct(String ransomNote, String magazine) {
if(ransomNote.length() > magazine.length()) {
return false;
}
int[] caps = new int[26];
for(char c : ransomNote.toCharArray()) {
int index = magazine.indexOf(c, caps[c - 'a']);
if(index == -1){
return false;
}
caps[c - 'a'] = index + 1;
}
return true;
}
}
9.回文数
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/palindrome-number
判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
示例 1:
输入: 121
输出: true
示例 2:
输入: -121
输出: false
解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。
示例 3:
输入: 10
输出: false
解释: 从右向左读, 为 01 。因此它不是一个回文数。
进阶:
你能不将整数转为字符串来解决这个问题吗？
class Solution {
public boolean isPalindrome(int x) {
if(x < 0 || (x % 10 == 0 && x != 0)){
return false;
}
int num = 0;
while(x > num){
num = num * 10 + x % 10;
x /= 10;
}
return x == num || x == num / 10;
}
}
day04
链接：https://www.nowcoder.com/questionTerminal/870eeb30a78e4a03b15c6d45e5f16bf9
来源：牛客网
1.下面有关java final的基本规则，描述错误的是？
A.final修饰的类不能被继承
B.final修饰的成员变量只允许赋值一次，且只能在类方法赋值
C.final修饰的局部变量即为常量，只能赋值一次。
D.final修饰的方法不允许被子类覆盖
答案为：B
final修饰的成员变量为基本数据类型是，在赋值之后无法改变。当final修饰的成员变量为引用数据类型时，在赋值后其指向地址无法改变，但是对象内容还是可以改变的。
final修饰的成员变量在赋值时可以有三种方式。1、在声明时直接赋值。2、在构造器中赋值。3、在初始代码块中进行赋值。
final修饰的方法，不允许被子类覆盖。
final修饰的类，不能被继承。
final修饰的变量，不能改变值。
final修饰的引用类型，不能再指向别的东西，但是可以改变其中的内容。
链接：https://www.nowcoder.com/questionTerminal/ee86c59bd1914239b148133793194f05?orderByHotValue=1&page=1&onlyReference=false
来源：牛客网
2.选项中哪一行代码可以替换 //add code here 而不产生编译错误
public abstract class MyClass {
public int constInt = 5;
//add code here
public void method() {}
}
A.public abstract void method(int a);
B.consInt=constInt+5;
C.public int method();
D.public abstract void anotherMethod(){}
解释：
A方法的重载（正确）
C重载：方法名相同，参数列表不同，返回值不作要求
D抽象方法不能有方法体，即后面不能有括号
3.给定一个仅包含大小写字母和空格 ’ ’ 的字符串 s，返回其最后一个单词的长度。
如果字符串从左向右滚动显示，那么最后一个单词就是最后出现的单词。
如果不存在最后一个单词，请返回 0 。
说明：一个单词是指仅由字母组成、不包含任何空格的 最大子字符串。
示例:
输入: “Hello World”
输出: 5
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/length-of-last-word
class Solution {
public int lengthOfLastWord(String s) {
if(s == null || s.length() == 0 || " ".equals(s)){
return 0;
}
String[] newS = s.split(" ");
if(newS.length == 0){
return 0;
}
return newS[newS.length - 1].length();
}
}
4.给定两个有序整数数组 nums1 和 nums2，将 nums2 合并到 nums1 中，使得 num1 成为一个有序数组。
class Solution {
public void merge(int[] nums1, int m, int[] nums2, int n) {
System.arraycopy(nums2, 0, nums1, m, n);
Arrays.sort(nums1);
}
}
day05
1、下列java程序的输出结果为( )。
public class Example{
String str=new String("hello");
char[]ch={'a','b'};
public static void main(String args[]){
Example ex=new Example();
ex.change(ex.str,ex.ch);
System.out.print(ex.str+" and ");
System.out.print(ex.ch);
}
public void change(String str,char ch[]){
str="test ok";
ch[0]='c';
}
}
A: hello and ab
B: hello and cb
C: hello and a
D: test ok and ab
字符串是一种不可变对象. 它的内容不可改变.
String 类的内部实现也是基于 char[] 来实现的, 但是 String 类并没有提供 set 方法之类的来修改内部的字符数组
2、 transient 变量和下面哪一项有关？ ( )
A: Cloneable
B: Serializable
C: Runnable
D: Comparable
我们都知道一个对象只要实现了Serilizable接口，这个对象就可以被序列化，java的这种序列化模式为开发者提供了很多便利，我们可以不必关系具体序列化的过程，只要这个类实现了Serilizable接口，这个类的所有属性和方法都会自动序列化。
这个类的有些属性需要序列化，而其他属性不需要被序列化；
java 的transient关键字为我们提供了便利，你只需要实现Serilizable接口，将不需要序列化的属性前添加关键字transient，序列化对象的时候，这个属性就不会序列化到指定的目的地中。
- 在序列化的时候，被transient或者static修饰的属性，不可以序列化。
- 一个类可以被序列化，那么它的子类也可以被序列化。
- 序列化可以实现深复制，而Object中的clone实现的就只是浅复制。
3、已知有下列Test类的说明，在该类的main方法内，则下列哪个语句是正确的？（ ）
public class Test {
private float f = 1.0f;
int m = 12;
static int n = 1;
public static void main (String args[]) {
Test t = new Test();
}
}
A: t.f;
B: this.n;
C: Test.m
D: Test.f
选A
5. main方法是个static方法，然后static方法中不能直接访问非static的属性。
6. 静态块或者静态方法中不能有this，super关键字
7. m不是静态属性，所以不能类名访问。
1、类变量的调用：（1）静态、非静态方法中，可以直接调用。
2、成员变量的调用有2种方法：（1）非静态方法中，可以通过this关键字直接调用。因为成员变量的初始化时间先于类的构造函数执行前,自然保证了成员变量已经被赋值。（2）静态方法中，先实例化类，利用实例化类的引用才能调用。
3、this关键字：（1）不能在静态方法中使用。
217.存在重复元素
给定一个整数数组，判断是否存在重复元素。
如果任何值在数组中出现至少两次，函数返回 true。如果数组中每个元素都不相同，则返回 false。
class Solution {
public boolean containsDuplicate(int[] nums) {
if(nums.length == 0 || nums.length == 1){
return false;
}
for(int i = 0; i < nums.length; i++){
for(int j = i + 1; j < nums.length; j++){
if(nums[i] == nums[j]){
return true;
}
}
}
return false;
}
}
class Solution {
public boolean containsDuplicate(int[] nums) {
Arrays.sort(nums);
for(int i = 0; i < nums.length - 1; i++){
if(nums[i] == nums[i + 1]){
return true;
}
}
return false;
}
}
925.长按键入
你的朋友正在使用键盘输入他的名字 name。偶尔，在键入字符 c 时，按键可能会被长按，而字符可能被输入 1 次或多次。
你将会检查键盘输入的字符 typed。如果它对应的可能是你的朋友的名字（其中一些字符可能被长按），那么就返回 True。
示例 1：
输入：name = “alex”, typed = “aaleex”
输出：true
解释：‘alex’ 中的 ‘a’ 和 ‘e’ 被长按。
示例 2：
输入：name = “saeed”, typed = “ssaaedd”
输出：false
解释：‘e’ 一定需要被键入两次，但在 typed 的输出中不是这样。
示例 3：
输入：name = “leelee”, typed = “lleeelee”
输出：true
示例 4：
输入：name = “laiden”, typed = “laiden”
输出：true
解释：长按名字中的字符并不是必要的。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/long-pressed-name
class Solution {
public boolean isLongPressedName(String name, String typed) {
int n = name.length();
int t = typed.length();
if(t < n){
return false;
}
int i = 0;
int j = 0;
while(i < n && j < t){
//charAt()方法就是指定位置的字符输出，类似于数组中的引用下标
//其范围是0到"".length() - 1
if(name.charAt(i) == typed.charAt(j)){
i++;
j++;
}else if(j > 0 && typed.charAt(j) == typed.charAt(j - 1)){
j++;
}else{
return false;
}
}
return i == n;
}
}
day06
1.下面关于JAVA的垃圾回收机制，正确的是 B
A.程序可以任意指定释放内存的时间
B.JAVA程序不能依赖于垃圾回收的时间或者顺序
C.程序可明确地标识某个局部变量的引用不再被使用
D.程序可以显式地立即释放对象占有的内存
java提供了一个系统级的线程，即垃圾回收器线程。用来对每一个分配出去的内存空间进行跟踪。当JVM空闲时，自动回收每块可能被回收的内存，GC是完全自动的，不能被强制执行。程序员最多只能用System.gc()来建议执行垃圾回收器回收内存，但是具体的回收时间，是不可知的。
当对象的引用变量被赋值为null，可能被当成垃圾。
C项错误的原因：局部变量存放在栈上，栈上的垃圾回收，由finalize()来实现
2.以下会产生信息丢失的类型转换是( B）
A.float a=10
B.int a=（int）8846.0
C.byte a=10； int b=-a
D.double d=100
精度丢失只会发生在从大范围到小范围的转换
byte 1字节
char 2字节
short 2字节
int 4字节
float 4字节
long 8字节
double 8字节
boolean 没有(其实是占八分之一个字节，也就是1个位)
3.多态，意味着一个对象有着多重特征，可以在特定的情况下，表现不同的状态，从而对应着不同的属性和方法。 动态绑定，是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。 作用消除类型之间的耦合关系。
4.给定一个字符串 S，返回 “反转后的” 字符串，其中不是字母的字符都保留在原地，而所有字母的位置发生反转。
示例 1：
输入：“ab-cd”
输出：“dc-ba”
示例 2：
输入：“a-bC-dEf-ghIj”
输出：“j-Ih-gfE-dCba”
示例 3：
输入：“Test1ng-Leet=code-Q!”
输出：“Qedo1ct-eeLg=ntse-T!”
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-only-letters
最笨的办法，但最容易理解
class Solution {
public String reverseOnlyLetters(String S) {
char[] value = S.toCharArray();
int left = 0;
int right = S.length() - 1;
while(left < right){
if(((value[left] >= 65 && value[left] <= 90) ||
(value[left] >= 97 && value[left] <= 122)) &&
((value[right] >= 65 && value[right] <= 90) ||
(value[right] >= 97 && value[right] <= 122))){
char tmp = value[left];
value[left] = value[right];
value[right] = tmp;
left++;
right--;
}else if(value[left] < 65 || (value[left] > 90 && value[left] < 97) || value[left] > 122){
left++;
}else if(value[right] < 65 || (value[right] > 90 && value[right] < 97) || value[right] > 122){
right--;
}
}
return new String(value);
}
}
day07
1、在Java中，while()括号里参数必须是boolean布尔类型,在C语言中，while()括号里参数只要是大于0的int值都会被认为是true.
2、在各自最优条件下,对N个数进行排序,哪个算法复杂度最低的是 A
A插入排序
B快速排序
C堆排序
D归并排序
改正：冒泡排序的最好情况是O（N）
905、按奇偶排序数组
给定一个非负整数数组 A，返回一个数组，在该数组中， A 的所有偶数元素之后跟着所有奇数元素。
你可以返回满足此条件的任何数组作为答案。
class Solution {
public int[] sortArrayByParity(int[] A) {
int j = 0;
for(int i = 0; i < A.length; i++){
if(A[i] % 2 == 0){
//判断A[i]是偶数，才发生交换，并且j++，否则j不变
int tmp = A[i];
A[i] = A[j];
A[j] = tmp;
j++;
}
}
return A;
}
public int[] sortArrayByParity(int[] A){
int left = 0;
int right = A.length - 1;
while(left < right){
while(left < right && A[left] % 2 == 0)
left++;
while(left < right && A[right] % 2 != 0)
right--;
int temp = A[left];
A[left] = A[right];
A[right] = temp;
}
return A;
}
}
- 寻找数组的中心索引
给定一个整数类型的数组 nums，请编写一个能够返回数组“中心索引”的方法。
我们是这样定义数组中心索引的：数组中心索引的左侧所有元素相加的和等于右侧所有元素相加的和。
如果数组不存在中心索引，那么我们应该返回 -1。如果数组有多个中心索引，那么我们应该返回最靠近左边的那一个。
示例 1:
输入:
nums = [1, 7, 3, 6, 5, 6]
输出: 3
解释:
索引3 (nums[3] = 6) 的左侧数之和(1 + 7 + 3 = 11)，与右侧数之和(5 + 6 = 11)相等。
同时, 3 也是第一个符合要求的中心索引。
示例 2:
输入:
nums = [1, 2, 3]
输出: -1
解释:
数组中不存在满足此条件的中心索引。
大神的思路，简单易懂↓
class Solution {
public int pivotIndex(int[] nums) {
int sum = 0;
int sumleft = 0;
for(int i = 0; i < nums.length; i++){
sum += nums[i];
}
for(int i = 0; i < nums.length; i++){
if(sumleft * 2 + nums[i] == sum){
return i;
}
sumleft += nums[i];
}
return -1;
}
}
day08
66.加一
给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。
最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。
你可以假设除了整数 0 之外，这个整数不会以零开头。
示例 1:
输入: [1,2,3]
输出: [1,2,4]
解释: 输入数组表示数字 123。
示例 2:
输入: [4,3,2,1]
输出: [4,3,2,2]
解释: 输入数组表示数字 4321。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/plus-one
别人的思路总是简介明了，哭咧
class Solution {
public int[] plusOne(int[] digits) {
for(int i = digits.length - 1; i >= 0; i--){
if(digits[i] != 9){
digits[i] += 1;
return digits;
}
digits[i] = 0;
}
int[] newArr = new int[digits.length + 1];
newArr[0] = 1;
return newArr;
}
}
- 第三大的数
给定一个非空数组，返回此数组中第三大的数。如果不存在，则返回数组中最大的数。要求算法时间复杂度必须是O(n)。
示例 1:
输入: [3, 2, 1]
输出: 1
解释: 第三大的数是 1.
示例 2:
输入: [1, 2]
输出: 2
解释: 第三大的数不存在, 所以返回最大的数 2 .
示例 3:
输入: [2, 2, 3, 1]
输出: 1
解释: 注意，要求返回第三大的数，是指第三大且唯一出现的数。
存在两个值为2的数，它们都排第二。
class Solution {
public int thirdMax(int[] nums) {
if(nums.length == 1) {
return nums[0];
}
if(nums.length == 2){
return Math.max(nums[0], nums[1]);
}
int max1 = Integer.MIN_VALUE;
int max2 = Integer.MIN_VALUE;
int max3 = Integer.MIN_VALUE;
boolean f = true;
int flag = 0;
for(int i = 0; i <nums.length; i++){
if(nums[i] == Integer.MIN_VALUE && f){
flag++;
f = false;
}
if(nums[i] > max1){
flag++;
max3 = max2;//原先第二大传递给第三大
max2 = max1;//原先最大值传递给第二大
max1 = nums[i];//更新最大值
}else if(nums[i] > max2 && nums[i] < max1){
flag++;
max3 = max2;
max2 = nums[i];
}else if(nums[i] > max3 && nums[i] < max2){
flag++;
max3 = nums[i];
}
}
return flag >= 3 ? max3 : max1;
}
}
扫盲：
Integer.MIN_VALUE，即-2147483648，二进制位如下：
1000 0000 0000 0000 0000 0000 0000 0000
在计算机的运算中，“-”（前缀）运算表示各二制位取反再加1，也就是说 b = -a 在计算机内部是 b = ~a + 1 这样处理的，所以上面的位就变成了：
1000 0000 0000 0000 0000 0000 0000 0000 Integer.MIN_VALUE
取反 0111 1111 1111 1111 1111 1111 1111 1111 （取反之后变成了Integer.MAX_VALUE）
加１ 1000 0000 0000 0000 0000 0000 0000 0000 -Integer.MIN_VALUE（与原来的结果一样）
在JDK中，整形类型是有范围的，最大值为Integer.MAX_VALUE，即2147483647，最小值为Integer.MIN_VALUE -2147483648。
对整形最大值加1，2147483648（越界了），那么此时值为多少呢？结果是-2147483648，即是Integer.MIN_VALUE。
类似的，对Integer.MIN_VALUE取反或者取绝对值呢？仍为Integer.MIN_VALUE，因为值为-2147483648，绝对值2147483648超过Integer.MAX_VALUE 2147483647。
所以就有以下结果
Integer.MAX_VALUE + 1 = Integer.MIN_VALUE
Math.abs(Integer.MIN_VALUE) = Integer.MIN_VALUE （绝对值）
Long，short，byte的结论是相同的。
day09
1、在java中，无论在何处调用，使用静态属性必须以类名做前缀。
A.正确
B.错误
1如果是本类使用，可以直接就用静态变量名。2如果是其他类使用，可以使用类名来调用，也可以创建一个实例对象来调用。3如果静态变量所在的类是静态类，那么不管在本类里或者在其他外部类，都可以直接使用静态变量名
2、哪个关键字可以对对象加互斥锁？（）
A、synchronized
B、volatile
C、serialize
D、static
A、synchronized：修饰方法，代码块。互斥锁（对象锁），同步锁定，即保证了可见性又保证了原子性。
B、volatile：修饰变量，保证了可见性，但是没有保证原子性。同时禁止了指令重排序。
1. 可见性，是因为JMM将工作内存置为无效，每次线程读取和写入数据都是直接操作了主内存。（lock指令的作用）
2. 禁止了指令重排序：
1. 当程序执行到volatile变量的读操作或者写操作时，在其前面的操作的更改肯定全部已经进行，且结果已经对后面的操作可见；在其后面的操作肯定还没有进行；
2. 在进行指令优化时，不能将在对volatile变量访问的语句放在其后面执行，也不能把volatile变量后面的语句放到其前面执行。
C、serialize：代表序列化，一个类想要可以序列化，必须实现序列化接口（Serializable），序列化是为了把对象变成流进行传递（内部、外部序列化）。
1. 序列化时，属性可以序列化，方法不可以，序列ID必须写成public static final形式的。
2. 序列化时，static和transient修饰的变量不可序列化。
3. 反序列化时，需要class文件。
D、static：修饰类，方法，成员变量（不可修饰局部变量，局部变量和形参只能使用final修饰）。被staic修饰的变量属于类本身，而不是某一个类的某一个实例对象。同时静态方法不可直接访问非静态成员，因为类加载的顺序问题。静态块、方法中不能出现this，super。
synchronized 关键字 : 用来给对象和方法或者代码块加锁，当它锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行这个段代码。
volatile：用来确保将变量的跟新操作通知到其他线程，当把变量声明为volatile类型后，编译器与运行时都会注意到这个变量是共享的，因此不会将该变量上的操作与其他内存操作一起重排序。然而，在访问volatile变量时不会执行加锁操作，因此也就不会使执行线程阻塞，因此volatile变量是一种比 synchronized关键字更轻量级的同步机制。
serialize：Java 对象序列化为二进制文件。
static关键字： static关键字可以修饰变量，方法，静态代码块。
静态变量:
由static修饰的变量称为静态变量
静态变量属于类，而不属于某个对象
静态变量它的副本只有一个(静态变量在类中只加载一)
静态方法：
在静态方法中只能调用静态变量和静态方法
在非静态方法中，可以调用静态方法或者变量。
在静态方法中不能使用this和super关键字。
静态代码块
作用:用来给静态成员变量初始化
3、
- 两数之和
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
class Solution {
public int[] twoSum(int[] nums, int target) {
for(int i = 0; i < nums.length; i++){
for(int j = i + 1; j < nums.length; j++){
if(nums[j] == target - nums[i]){
return new int[] {i, j};
}
}
}
throw new IllegalArgumentException("No two sum solution");
}
}
day10
1、一个Java源程序文件中定义几个类和接口，则编译该文件后生成几个以.class为后缀的字节码文件
2、要使某个类能被同一个包中的其他类访问，但不能被这个包以外的类访问，可以(A)
A让该类不使用任何关键字
B使用private关键字
C使用protected关键字
D使用void关键字
default和protected的区别是：
前者只要是外部包，就不允许访问。
后者只要是子类就允许访问，即使子类位于外部包。
总结：default拒绝一切包外访问；protected接受包外的子类访问
3、判断对错。在java的多态调用中，new的是哪一个类就是调用的哪个类的方法。×
错
多态有两种情况：重载和覆写
在覆写中，运用的是动态单分配，是根据new的类型确定对象，从而确定调用的方法；
在重载中，运用的是静态多分派，即根据静态类型确定对象，因此不是根据new的类型确定调用的方法
8、字符串转换整数 (atoi)
请你来实现一个 atoi 函数，使其能将字符串转换成整数。
https://leetcode-cn.com/problems/string-to-integer-atoi/
class Solution {
public int myAtoi(String str) {
int ret = 0;
int flag = 1;
char[] charArr = str.toCharArray();
int length = str.length();
int i = 0;
int pop = 0;
for( ; i < length; i++) {
if(charArr[i] == ' ') {
continue;
}else{
if(charArr[i] == '-') {
i++;
flag = -1;
break;
}
if(charArr[i] == '+') {
i++;
break;
}
if(charArr[i] < '0' || charArr[i] >'9') {
return 0;
}else{
break;
}
}
}
if(i == length){
return 0;
}
for( ; i < length; i++) {
if(charArr[i] < '0' || charArr[i] > '9') {
return ret;
}
pop = (charArr[i] - 48) * flag;
if(ret > Integer.MAX_VALUE / 10 || (ret == Integer.MAX_VALUE / 10 && pop > 7)) {
return Integer.MAX_VALUE;
}
if(ret < Integer.MIN_VALUE / 10 || (ret == Integer.MIN_VALUE / 10 && pop < -8)) {
return Integer.MIN_VALUE;
}
ret = ret * 10 + pop;
}
return ret;
}
}
- 在排序数组中查找元素的第一个和最后一个位置
给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。
你的算法时间复杂度必须是 O(log n) 级别。
如果数组中不存在目标值，返回 [-1, -1]。
示例 1:
输入: nums = [5,7,7,8,8,10], target = 8
输出: [3,4]
示例 2:
输入: nums = [5,7,7,8,8,10], target = 6
输出: [-1,-1]
学习了大佬写的二分查找的边界问题代码，瞬间感觉开了窍,也对二分查找算法提升了更高的认识
class Solution {
public int[] searchRange(int[] nums, int target) {
return new int[] {left_bound(nums, target), right_bound(nums, target)};
}
private int left_bound(int[] nums, int target) {
if(nums.length == 0) {
return -1;
}
int left = 0;
int right = nums.length;
while(left < right) {
int mid = (left + right) / 2;
if(nums[mid] == target) {
right = mid;
}else if(nums[mid] < target) {
left = mid + 1;
}else if(nums[mid] > target) {
right = mid;
}
}
if(left == nums.length) {
return -1;
}
return nums[left] == target ? left : -1;
}
private int right_bound(int[] nums, int target) {
if(nums.length == 0) {
return -1;
}
int left = 0;
int right = nums.length;
while(left < right) {
int mid = (left + right) / 2;
if(nums[mid] == target) {
left = mid + 1;
}else if(nums[mid] < target) {
left = mid + 1;
}else if(nums[mid] > target) {
right = mid;
}
}
if(left == 0) {
return -1;
}
return nums[left - 1] == target ? (left - 1) : -1;
}
}
//学习了大佬写的二分查找的边界问题代码，瞬间感觉开了窍,也对二分查找算法提升了更高的认识