力扣题目记录

力扣刷题记录704. 二分查找
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/binary-search
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

#include <iostream>
#include<vector>
using namespace std;
class Solution {
public:
    int search(vector<int>& nums, int target) {
        int start = 0, final = nums.size()-1;
        int middle=0;
        int flag = 0;
        while (start <=final)
        {
             middle = (start + final) / 2;
            if (target < nums[middle])
            {
                final = middle-1;
            }
            else if (target > nums[middle])
            {
                start = middle+1;
            }
            else 
            {
                flag = 1;
                break;
            }
        }
        if (flag == 1)
        {
            return nums[middle];
        }
        else
        {
            return -1;
        }
        
    }
};
int main()
{
    vector<int>v{1,2,3,5,7,8};
    int target = 7;
    Solution s1;
    cout<<s1.search(v, target)<<endl;
}

用二分法对升序数组进行排序，首先是判断循环条件
34. 在排序数组中查找元素的第一个和最后一个位置
给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。

如果数组中不存在目标值 target，返回 [-1, -1]。

// 02learn.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include<vector>
using namespace std;
class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        int left = 0, right = nums.size()-1;
        int middle = 0,flag=0;
        vector<int> nums2;
        while (left <= right)
        {
            middle = (left + right) / 2;
            if (target < nums[middle])
            {
                right = middle - 1;
            }
            else if (target > nums[middle])
            {
                left = middle + 1;
            }
            else
            {
               // nums2.push_back(middle);
                flag = 1;
                break;
            }
        }
        if (flag == 1)
        {
            int i = middle+1;
            int j = middle;
            while ((j -1>= 0) && nums[j] == nums[j-1])
            {
                j--;   
            }
            nums2.push_back(j++);
            while (i < nums.size()&&nums[i] == nums[middle])
            {
                i++;
            }
            nums2.push_back(i - 1);
        }
        else 
        {
            nums2.push_back(-1);
            nums2.push_back(-1);
        }
        return nums2;
    }
};
int main()
{
    vector<int> num{1,2,3,3,3,3,4,5,9};
    vector<int> nu;
    int target = 3;
    Solution s1;
    nu=s1.searchRange(num, target);
    for (int i = 0; i < nu.size(); i++)
    {
        cout << nu[i] << " ";
    }
    cout << endl;
    
}

二分法查找升序数组中出现元素的初始位置和结束位置，用二分法找一个在数组中的元素的位置
怎么用复杂度为logn进行寻找，思考ing,先找第一个等于target的位置，再往后找第一个不等于target的位置
给你一个非负整数 x ，计算并返回 x 的 算术平方根 。

由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去 。

注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/sqrtx
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
public:
    int mySqrt(int x) {
     int left = 0, right = x;
        int middle = 0,flag=0,ans=x;
        while (left <= right)
        {
            middle = (left + right) /2;
            
            if (x>(long long) middle * middle)
            {
                left = middle + 1;
            }
            else if (x<(long long)middle * middle)
            {
                ans = middle-1;
                right = middle - 1;
            } 
            else
            {
                ans = middle;
                flag = 1;
                break;
            }
        }
            return ans;
    }
};

844. 比较含退格的字符串
     给定 s 和 t 两个字符串，当它们分别被输入到空白的文本编辑器后，请你判断二者是否相等。# 代表退格字符。

如果相等，返回 true ；否则，返回 false 。

注意：如果对空文本输入退格字符，文本继续为空。

class Solution {
public:
    bool backspaceCompare(string s, string t) {
        int left1 = -1, right1 = 0, n1 = s.size();
        int flag = 0,flag1=0,flag2=0;
        while (right1 < n1)
        {
            if (s[right1] == '#' && left1>=0)
            {
                left1--;
                right1++;
                flag1 = 1;
            }
            else if (s[right1] == '#' && left1 ==-1)
            {
                right1++;
            }
            else
            {
                left1++;
                s[left1] = s[right1];
                right1++;
                flag1 = 2;
            }
        }
        
        int left2 = -1, right2 = 0, n2 = t.size();
        while (right2 < n2)
        {
            if (t[right2] == '#' && left2 >= 0)
            {
                left2--;
                right2++;
                flag2 = 1;
            }
            else if (t[right2] == '#' && left2 == -1)
            {
                right2++;
            }
            else
            {
                left2++;
                t[left2] = t[right2];
                right2++;
                flag2 = 2;
            }
        }
        
        bool len = (left1 == left2);
        if (len == 1)
        {
            if (left1 == -1)
            {
                return true;
            }
            for (int i = 0; i <=left1; i++)
            {
                if (s[i] != t[i])
                {
                    flag = 1;
                    break;
                }
            }
            if (flag == 1)
            {
                return false;
            }
            else
            {
                return true;
            }
        }
        else
        {
            return false;
        }
    }
};

用左右指针，保证[0,left]的字符是有效字符，其中注意left的值