参考
https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/solution/er-fen-cha-zhao-suan-fa-xi-jie-xiang-jie-by-labula/
二分查找进阶：上下界二分
首先标准的二分的实现细节：
while(left<=right){
‘’’’’’’’’’‘left=mid+1;
‘’’’’’’’’'right=mid-1;
}
其中查找时失败时[right+1,right]即left=right+1
而对于有重复元素的二分:
while(left<right)
这样查找区间是[left,right)【即右区间是搜索不到的】
所以为了让整个数组nums完整搜索应该 left=0,right=nums.length
其中查找时失败时[right,right）
寻找相同元素的下界：
int left_bound(int[] nums, int target) {
if (nums.length == 0) return -1;
int left = 0;
int right = nums.length; // 为了保证Nums所有元素都能访问
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; // 原因在于搜索区间[)
}
// target 比所有数都大
if (left == nums.length) return -1;
// 类似之前算法的处理方式
return nums[left] == target ? left : -1;
}
关键在于 if (nums[mid] == target) {right = mid;}即查找到时不是返回，而是向左缩小区间
注意，因为是排序数组，所以此[left，mid）的值仅仅能<=nums[mid]
所以[left,right)若所有元素都小于nums[mid]（无重复元素）right指针会一直不东,left右移直到leftright
若存在元素numsmid，则right指针会左移，重复上述行为。
寻找相同元素的上界
int left_bound(int[] nums, int target) {
if (nums.length == 0) return -1;
int left = 0;
int right = nums.length; // 为了保证Nums所有元素都能访问
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; // 原因在于搜索区间[)
}
// target 比所有数都大
if (left == nums.length) return -1;
// 类似之前算法的处理方式
return nums[left-1] == target ? left-1 : -1;
}
大体与上述一样，只是 if (nums[mid] == target) {left = mid+1;}即将区间右移
为什么不能left=mid
因为想象若只有[n,n+1)的区间
mid=(left+right )/2=left
a[mid]a[left] 所以left=mid又进入此循环，会无限循环，所以出错。
仅能left=mid+1
所以对于区间[left,right)若所有元素都大于nums[mid]（无重复元素）left指针会一直不东,right左移直到leftright
若存在元素==numsmid，则left指针会左移，重复上述行为。
所以结束时判断return nums[left-1] == target ? left-1 : -1;
题目一：
leetcode71
以 Unix 风格给出一个文件的绝对路径，你需要简化它。或者换句话说，将其转换为规范路径。
在 Unix 风格的文件系统中，一个点（.）表示当前目录本身；此外，两个点 （…） 表示将目录切换到上一级（指向父目录）；两者都可以是复杂相对路径的组成部分。更多信息请参阅：Linux / Unix中的绝对路径 vs 相对路径
请注意，返回的规范路径必须始终以斜杠 / 开头，并且两个目录名之间必须只有一个斜杠 /。最后一个目录名（如果存在）不能以 / 结尾。此外，规范路径必须是表示绝对路径的最短字符串。
示例 1：
输入："/home/"
输出："/home"
解释：注意，最后一个目录名后面没有斜杠。
示例 2：
输入："/…/"
输出："/"
解释：从根目录向上一级是不可行的，因为根是你可以到达的最高级。
示例 3：
输入："/home//foo/"
输出："/home/foo"
解释：在规范路径中，多个连续斜杠需要用一个斜杠替换。
示例 4：
输入："/a/./b/…/…/c/"
输出："/c"
示例 5：
输入："/a/…/…/b/…/c//.//"
输出："/c"
示例 6：
输入："/a//bc/d//././/…"
输出："/a/b/c"
class Solution {
public String simplifyPath(String path) {
String []str=path.split("/");
Stack<String> sta=new Stack<>();
for (int i = 0; i < str.length; i++) {
if (!sta.isEmpty() && str[i].equals(".."))
sta.pop();
else if (!str[i].equals("") && !str[i].equals(".") && !str[i].equals(".."))
sta.push(str[i]);
}
if(sta.isEmpty())return "/";
StringBuilder result=new StringBuilder();
for(String str1:sta)result.append("/"+str1);
return result.toString();
}
}
题目二：
leetcode73
给定一个 m x n 的矩阵，如果一个元素为 0，则将其所在行和列的所有元素都设为 0。请使用原地算法。
示例 1:
输入:
[
[1,1,1],
[1,0,1],
[1,1,1]
]
输出:
[
[1,0,1],
[0,0,0],
[1,0,1]
]
示例 2:
输入:
[
[0,1,2,0],
[3,4,5,2],
[1,3,1,5]
]
输出:
[
[0,0,0,0],
[0,4,5,0],
[0,3,1,0]
]
解析：利用二次遍历矩阵
class Solution {
public void setZeroes(int[][] matrix) {
List<Integer>row=new LinkedList<>();
List<Integer>col=new LinkedList<>();
for(int i=0;i<matrix.length;i++){
for(int j=0;j<matrix[0].length;j++){
if(matrix[i][j]==0){
row.add(i);
col.add(j);
}
}
}
for(int i=0;i<matrix.length;i++){
for(int j=0;j<matrix[0].length;j++){
if(row.contains(i)||col.contains(j)){
matrix[i][j]=0;
}
}
}
}
}
解析：利用第一行第一列作为标志位
class Solution {
public void setZeroes(int[][] matrix) {
int row = matrix.length;
int col = matrix[0].length;
boolean row0_flag = false;
boolean col0_flag = false;
// 第一行是否有零
for (int j = 0; j < col; j++) {
if (matrix[0][j] == 0) {
row0_flag = true;
break;
}
}
// 第一列是否有零
for (int i = 0; i < row; i++) {
if (matrix[i][0] == 0) {
col0_flag = true;
break;
}
}
// 把第一行第一列作为标志位
for (int i = 1; i < row; i++) {
for (int j = 1; j < col; j++) {
if (matrix[i][j] == 0) {
matrix[i][0] = matrix[0][j] = 0;
}
}
}
// 置0
for (int i = 1; i < row; i++) {
for (int j = 1; j < col; j++) {
if (matrix[i][0] == 0 || matrix[0][j] == 0) {
matrix[i][j] = 0;
}
}
}
if (row0_flag) {
for (int j = 0; j < col; j++) {
matrix[0][j] = 0;
}
}
if (col0_flag) {
for (int i = 0; i < row; i++) {
matrix[i][0] = 0;
}
}
}
}
题目三：
leetcode74
编写一个高效的算法来判断 m x n 矩阵中，是否存在一个目标值。该矩阵具有如下特性：
每行中的整数从左到右按升序排列。
每行的第一个整数大于前一行的最后一个整数。
示例 1:
输入:
matrix = [
[1, 3, 5, 7],
[10, 11, 16, 20],
[23, 30, 34, 50]
]
target = 3
输出: true
示例 2:
输入:
matrix = [
[1, 3, 5, 7],
[10, 11, 16, 20],
[23, 30, 34, 50]
]
target = 13
输出: false
class Solution {
public boolean searchMatrix(int[][] matrix, int target) {
int value,low,high;
if(matrix.length==1)value=0;
else{
low=0;high=matrix.length-1;
while(low<=high){
int mid=(low+high)/2;
if(matrix[mid][0]<target){
low=mid+1;
}
if(matrix[mid][0]>target){
high=mid-1;
}
if(matrix[mid][0]==target){
return true;
}
}
value=right;
if(value<0)return false;
}
low=0;
high=matrix[0].length-1;
while(low<=high){
int mid=(low+high)/2;
if(matrix[value][mid]<target){
low=mid+1;
}
if(matrix[value][mid]>target){
high=mid-1;
}
if(matrix[value][mid]==target){
return true;
}
}
return false;
}
}
解析：将二维矩阵转化一维矩阵 关键在于行列下标对应关系pivotElement = matrix[pivotIdx / n][pivotIdx % n];
class Solution {
public boolean searchMatrix(int[][] matrix, int target) {
int m = matrix.length;
if (m == 0) return false;
int n = matrix[0].length;
// 二分查找
int left = 0, right = m * n - 1;
int pivotIdx, pivotElement;
while (left <= right) {
pivotIdx = (left + right) / 2;
pivotElement = matrix[pivotIdx / n][pivotIdx % n];
if (target == pivotElement) return true;
else {
if (target < pivotElement) right = pivotIdx - 1;
else left = pivotIdx + 1;
}
}
return false; }}
扫一扫
654
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
