代码随想录：代码随想录
一.数组理论基础
数组是存放在连续内存空间上的相同类型数据的集合
数组可以方便的通过下标索引的方式获取到下标对应的数据
需要注意：
- 数组下标都是从0开始的
- 数组内存空间的地址是连续的
- 正是因为数组在内存空间的地址是连续的，所以我们在删除或者增添元素的时候，就难免要移动其他元素的地址（数组的元素是不能删的，只能覆盖）
二维数组
不同编程语言的内存管理是不一样的，在C++中二维数组是连续分布的，在Java中二维数组就不是连续分布的。Java没有指针，同时也不对程序员暴露其元素的地址，寻址操作完全交给虚拟机。
Java的二维数组可能是如下排列的方式：
二.二分查找
2.1 LeetCode：704.二分查找
题目链接：. - 力扣（LeetCode）
题目：给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。
示例一：
输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4
示例二：
输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
解释: 2 不存在 nums 中因此返回 -1
提示：
你可以假设 nums 中的所有元素是不重复的。
n 将在 [1, 10000]之间。
nums 的每个元素都将在 [-9999, 9999]之间。2.1.1 我自己的题解
二分查找的前提：数组为有序数组，数组中无重复元素
用的是左闭右闭即[left, right]的思路，关键点：L<=R、R=M-1、L=M+1
class Solution {
public int search(int[] nums, int target) {
int i = 0;
int j = nums.length - 1;
while(i<=j){
int mid = (i + j)/2;
if(nums[mid] < target){
i = mid + 1;
}else if(nums[mid] > target){
j = mid - 1;
}else{
return mid;
}
}
//未找到索引
return -1;
}
}
//时间复杂度：O(log n)
//空间复杂度：O(1)2.1.2 其他题解一：左闭右开即[left, right)
- while (left < right)，这里使用 < ,因为left == right在区间[left, right)是没有意义的
- if (nums[middle] > target) right 更新为 middle，因为当前nums[middle]不等于target，去左区间继续寻找，而寻找区间是左闭右开区间，所以right更新为middle，即：下一个查询区间不会去比较nums[middle]
class Solution {
public int search(int[] nums, int target) {
int left = 0, right = nums.length;
while (left < right) {
int mid = left + ((right - left) >> 1);
if (nums[mid] == target) {
return mid;
}
else if (nums[mid] < target) {
left = mid + 1;
}
else { // nums[mid] > target
right = mid;
}
}
// 未找到目标值
return -1;
}
}
//时间复杂度：O(log n)
//空间复杂度：O(1)2.2 LeetCode：35.搜索插入位置
题目链接：. - 力扣（LeetCode）
题目：给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。请必须使用时间复杂度为 O(log n) 的算法。
示例 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
提示：
1 <= nums.length <= 104
-104 <= nums[i] <= 104
nums 为 无重复元素 的 升序 排列数组
-104 <= target <= 104插入目标值的四种情况：目标值在数组所有元素之前、目标值等于数组中某一个元素、目标值插入数组中的位置、目标值在数组所有元素之后
2.2.1 我自己的题解
二分法先查看数组中是否有目标值，有则返回下标；如果没有，此时的 i,j 正好标记到了最接近目标值的两个位置，选择在较小位置后面插入即可。
上述思路有冗余，因为当执行完循环，还没有 return 的时候，此时的 j<i 是一定的，不同加if判断，直接 return j+1 即可
可以使用 int middle = left + ((right - left) / 2); 防止溢出，等同于(left + right)/2
class Solution {
public int searchInsert(int[] nums, int target) {
int i=0;
int j=nums.length-1;
while(i<=j){
int mid = (i+j)/2;
// int middle = left + ((right - left) / 2);// 防止溢出 等同于(left + right)/2
if(nums[mid] == target){
return mid;
}else if(nums[mid]<target){
i=mid+1;
}else{
j=mid-1;
}
}
//说明目标值不存在于数组，要进行插入
return j+1;
//if(i<j){
// return i+1;
//}else{
// return j+1;
//}
}
}
//时间复杂度：O(log n)
//空间复杂度：O(1)2.2.2 其他题解一：暴力解法
class Solution {
public int searchInsert(int[] nums, int target) {
for(int i=0; i<nums.length; i++){
if(nums[i] >= target){
return i;
//当发现数组中第一次出现大于或者等于目标值的数，直接返回当前下标
//如果是第一个等于目标值的数，即在数组中找到目标值，返回索引
//如果是第一个大于目标值的数，说明目标值不在数组中，它所在的位置正好是目标值按顺序插入的位置
}
}
//说明目标值大于整个数组的所有值，要插入在数组尾部
return nums.length;
}
}
//时间复杂度：O(n)
//空间复杂度：O(1)2.2.3 其他题解二：二分法的第二种写法左闭右开[left, right)
public int searchInsert(int[] nums, int target) {
int left = 0;
int right = nums.length;
while (left < right) { //左闭右开 [left, right)
int middle = left + ((right - left) >> 1);
if (nums[middle] > target) {
right = middle; // target 在左区间，在[left, middle)中
} else if (nums[middle] < target) {
left = middle + 1; // target 在右区间，在 [middle+1, right)中
} else { // nums[middle] == target
return middle; // 数组中找到目标值的情况，直接返回下标
}
}
// 目标值在数组所有元素之前 [0,0)
// 目标值插入数组中的位置 [left, right) ，return right 即可
// 目标值在数组所有元素之后的情况 [left, right)，因为是右开区间，所以 return right
return right;
}
//时间复杂度：O(log n)
//空间复杂度：O(1)2.3 LeetCode：34.在排序数组中查找元素的第一个和最后一个位置
题目链接：. - 力扣（LeetCode）
题目：给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值 target，返回 [-1, -1]。
进阶：你可以设计并实现时间复杂度为 O(log n) 的算法解决此问题吗？
示例 1：
输入：nums = [5,7,7,8,8,10], target = 8
输出：[3,4]
示例 2：
输入：nums = [5,7,7,8,8,10], target = 6
输出：[-1,-1]
示例 3：
输入：nums = [], target = 0
输出：[-1,-1]2.3.1 我自己的题解
只会暴力求解，遍历整个数组，记录开始位置和结束位置
class Solution {
public int[] searchRange(int[] nums, int target) {
int count=0; //用count表示找到了几个target
int start=0; //用start记录开始位置
int end=0; //用end记录结束位置
for(int i=0; i<nums.length; i++){
//如果在数组中找到目标值
if(nums[i] == target){
//第一次找到，更新start和end
if(count==0){
start=i;
end=i;
count++;
}else{ //不是第一次找到目标值，只需要更新end
end=i;
count++;
}
}
}
int[] arr = new int[]{-1,-1};
//如果数组中存在目标值，要更新返回数组中存储的开始和结束位置下标
if(count!=0){
arr[0] = start;
arr[1] = end;
}
return arr;
}
}
//时间复杂度：O(n)2.3.2 其他解法一：寻找target在数组里的左右边界
采用二分法来去寻找左右边界
有如下三种情况：
- 情况一：target 在数组范围的右边或者左边，例如数组{3, 4, 5}，target为2或者数组{3, 4, 5},target为6，此时应该返回{-1, -1}
- 情况二：target 在数组范围中，且数组中不存在target，例如数组{3,6,7},target为5，此时应该返回{-1, -1}
- 情况三：target 在数组范围中，且数组中存在target，例如数组{3,6,7},target为6，此时应该返回{1, 1}
我是先记录边界位置值再改变R或L，代码随想录里面是先改变R或L再记录边界位置值，所以我的代码中是判断 rightBorder - leftBorder >= 0 ，而代码随想录里面是判断 rightBorder - leftBorder > 1 。
class Solution {
public int[] searchRange(int[] nums, int target) {
int rightBorder = getRightBorder(nums,target);
int leftBorder = getLeftBorder(nums,target);
//情况一：target 在数组范围的右边或者左边
//情况二：target 在数组范围中，且数组中不存在target
//情况三：target 在数组范围中，且数组中存在target
if(rightBorder == -2 || leftBorder == -2){
//情况一：target 在数组范围的右边或者左边
return new int[]{-1,-1};
}else if(rightBorder - leftBorder >= 0){
//情况三：target 在数组范围中，且数组中存在target
return new int[]{leftBorder,rightBorder};
}else{
//情况二：target 在数组范围中，且数组中不存在target
return new int[]{-1,-1};
}
}
public int getRightBorder(int[] nums, int target){
int left = 0;
int right = nums.length - 1;
int rightBorder = -2;
while(left <= right){
int mid = left + (right - left)/2; // 防止溢出 等同于(left + right)/2
if(nums[mid] <= target){ //中间位置的值小于等于目标值，中间位置可能是右边界
rightBorder = mid;
left = mid + 1;
}else{ //中间位置的值大于目标值，中间位置肯定不是右边界
right = mid - 1;
}
}
return rightBorder;
}
public int getLeftBorder(int[] nums, int target){
int left = 0;
int right = nums.length - 1;
int leftBorder = -2;
while(left <= right){
int mid = left + (right - left)/2; // 防止溢出 等同于(left + right)/2
if(nums[mid] >= target){ //中间位置的值大于等于目标值，中间位置可能是左边界
leftBorder = mid;
right = mid -1;
}else{ //中间位置的值小于目标值，中间位置肯定不是左边界
left = mid + 1;
}
}
return leftBorder;
}
}
//时间复杂度： O(logn) ，其中 n 为数组的长度。二分查找的时间复杂度为 O(logn)，一共会执行两次，因此总时间复杂度为 O(logn)。
//空间复杂度：O(1) 。只需要常数空间存放若干变量。
/*
class Solution {
int[] searchRange(int[] nums, int target) {
int leftBorder = getLeftBorder(nums, target);
int rightBorder = getRightBorder(nums, target);
// 情况一
if (leftBorder == -2 || rightBorder == -2) return new int[]{-1, -1};
// 情况三
if (rightBorder - leftBorder > 1) return new int[]{leftBorder + 1, rightBorder - 1};
// 情况二
return new int[]{-1, -1};
}
int getRightBorder(int[] nums, int target) {
int left = 0;
int right = nums.length - 1;
int rightBorder = -2; // 记录一下rightBorder没有被赋值的情况
while (left <= right) {
int middle = left + ((right - left) / 2);
if (nums[middle] > target) {
right = middle - 1;
} else { // 寻找右边界，nums[middle] == target的时候更新left
left = middle + 1;
rightBorder = left;
}
}
return rightBorder;
}
int getLeftBorder(int[] nums, int target) {
int left = 0;
int right = nums.length - 1;
int leftBorder = -2; // 记录一下leftBorder没有被赋值的情况
while (left <= right) {
int middle = left + ((right - left) / 2);
if (nums[middle] >= target) { // 寻找左边界，nums[middle] == target的时候更新right
right = middle - 1;
leftBorder = right;
} else {
left = middle + 1;
}
}
return leftBorder;
}
}
*/2.3.3 其他解法二：通过左右滑动指针来寻找区间
1.首先，在 nums 数组中二分查找 target；
2.如果二分查找失败，则 binarySearch 返回 -1，表明 nums 中没有 target。此时，searchRange 直接返回 {-1, -1}；
3.如果二分查找成功，则 binarySearch 返回 nums 中值为 target 的一个下标。然后，通过左右滑动指针，来找到符合题意的区间
class Solution {
public int[] searchRange(int[] nums, int target) {
int index = binarySearch(nums, target);
if(index == -1){
//说明目标值不存在于数组中
return new int[]{-1,-1};
}
//目标值存在于数组中，index代表目标值在数组中存在的一个位置
//开始查找区间的左右边界
int left = index;
int right = index;
//左边界
while((left - 1) >=0 && nums[left - 1] == nums[left]){
left--;
}
//右边界
while((right + 1) < nums.length && nums[right + 1] == nums[right]){
right++;
}
return new int[]{left,right};
}
public int binarySearch(int[] nums, int target){
int left = 0;
int right = nums.length - 1;
while(left <= right){
int mid = left + (right - left) / 2;
if(nums[mid] == target){
return mid;
}else if(nums[mid] > target){
right = mid - 1;
}else{
left = mid + 1;
}
}
return -1;
}
}2.4 LeetCode：69.x的平方根
题目链接：. - 力扣（LeetCode）
题目：给你一个非负整数 x ，计算并返回 x 的 算术平方根 。由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去 。注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。
示例 1：
输入：x = 4
输出：2
示例 2：
输入：x = 8
输出：2
解释：8 的算术平方根是 2.82842..., 由于返回类型是整数，小数部分将被舍去。
提示：
0 <= x <= 231 - 12.4.1 我自己的题解
注意 int 的范围，巧用 long 型：一开始没有通过的原因是没有考虑到超出 int 的范围的问题
class Solution {
public int mySqrt(int x) {
int left = 1;
int right = x;
while(left <= right){
int mid = left + (right - left) / 2;
//要使用long强转
if((long)mid * mid > x){
right = mid - 1;
}else if((long)mid * mid < x){
left = mid + 1;
}else{
return mid;
}
}
return right;
}
}
//时间复杂度：O(logx)，即为二分查找需要的次数
//空间复杂度：O(1)
/*
class Solution {
public int mySqrt(int x) {
long left = 1;
long right = x;
while(left <= right){
long mid = left + (right - left) / 2;
if(mid * mid > x){
right = mid - 1;
}else if(mid * mid < x){
left = mid + 1;
}else{
return (int)mid;
}
}
return (int)right;
}
}
*/2.4.2 其他解法一：袖珍计算器算法
「袖珍计算器算法」是一种用指数函数 exp 和对数函数 ln 代替平方根函数的方法。
class Solution {
public int mySqrt(int x) {
if(x == 0){
return 0;
}
int ans = (int)Math.exp(0.5 * Math.log(x));
return (long)(ans + 1) * (ans +1) <= x ? ans+1 : ans;
}
}
//时间复杂度：O(1)，由于内置的 exp 函数与 log 函数一般都很快，我们在这里将其复杂度视为 O(1)。
//空间复杂度：O(1)。2.4.3 其他解法二： 牛顿迭代
2.5 LeetCode：367.有效的完全平方数
题目链接：. - 力扣（LeetCode）
题目：给你一个正整数 num 。如果 num 是一个完全平方数，则返回 true ，否则返回 false 。完全平方数 是一个可以写成某个整数的平方的整数。换句话说，它可以写成某个整数和自身的乘积。不能使用任何内置的库函数，如 sqrt 。
示例 1：
输入：num = 16
输出：true
解释：返回 true ，因为 4 * 4 = 16 且 4 是一个整数。
示例 2：
输入：num = 14
输出：false
解释：返回 false ，因为 3.742 * 3.742 = 14 但 3.742 不是一个整数。
提示：
1 <= num <= 2^31 - 12.5.1 我自己的题解
思路同上题
class Solution {
public boolean isPerfectSquare(int num) {
long left = 1;
long right = num;
while(left <= right){
long mid = left + (right - left) / 2;
if(mid * mid > num){
right = mid - 1;
}else if(mid * mid < num){
left = mid + 1;
}else{
return true;
}
}
return false;
}
}![post请求中有[]报400异常](https://i-blog.csdnimg.cn/direct/e93b278fa4db4b5e878f50c863c2fe10.png)
