刷代码随想录day01-数组-优快云博客

数组是存放在连续内存空间上的相同类型数据的集合。（了解不同语言创建数组的机制）

二分查找

代码实现：while/递归

1.易错：区间判断left </<= right,left = middle/left = middle-1

-->1.[left,right]即left = 0, right = nums.size-1

递归结束条件：left > right；nums[middle]!=target时:left/right = middle-/+1;（个人多用）

-->2.[left,right)即left = 0, right = nums.size

递归结束条件：left == right；

nums[middle]!=target时:right = middle/left = middle+1;(依然保持区间左闭右开）

关于middle：既然nums[middle] != target,意味着target的下标可以排除middle

2.p.s.

一:. - 力扣（LeetCode）

int——>long long

二 mid = left +((rightt-left)>>2) 位运算防止mid值溢出

见:【二分查找】二分查找mid值溢出问题-阿里云开发者社区 (aliyun.com)

3.递归：

对递归回溯的理解:

图源自：图解递归算法-清晰易懂_递归栈执行过程图示-优快云博客

3.1---->简言之：不断往下延伸，直到返回一个值，进行回溯。

3.2---->更深的理解：

1.关于写不写return：

int find(vector<int>& nums, int target,int left,int right){
        int mid = left+((right-left)>>1);
        if(left>right){
            return left;
        }
        if(nums[mid]> target){
            return find(nums,target,left,mid-1);  //写不写return
        }else if(nums[mid] < target){
            return find(nums,target,mid+1,right);  //写不写return
        }else{
            return mid;
        }
    }

既然是int find(), 运行到这个函数的时候必然要返回一个int,即每一个if分支都需要return，否则编译不通过。

2.关于递归：

整个过程就是栈的应用，如上图，find()以指针形式依次push压入栈,直到有一个具体的数字出现，栈进行pop操作。

为了理解内核，这里有用数据结构栈手搓递归：干货｜模拟栈实现手写递归 - 知乎 (zhihu.com)

n阶乘栈代码如下：（本人暂时没有全理解）

int fact2(int n)
{
    int ret;
    struct data
    {
        int a0;//当前递归的参数n
        int v0;//存储递归的返回值。
        int ra;//递归的“返回地址”，用于模拟递归的不同阶段
    };
    stack<data> S;
    S.push({n,0,0});//递归栈初始化，ra=0表示先进入代码块0
    while(!S.empty())
    {
        data now=S.top();S.pop();//取出栈顶元素
        int a0=now.a0;
        int ra=now.ra;
        int v0=now.v0;
        switch(ra)//如果a0==1，直接设置返回值。否则，将当前状态标记为需要再次处理（ra=1），并将n-1的状态压栈以模拟递归调用。
        {
            case 0:
            {
                if(a0==1)//递归结束条件
                {
                    S.push({a0,1,1});//此条语句也可省略
                    ret=1;//将本层返回值传给ret
                }
                else
                {
                    S.push({a0,v0,1});//本层入栈，排队准备进入代码块1
                    S.push({a0-1,v0,0});//下一层入栈，马上执行代码块0
                }
                continue;
            }
            case 1:
            {
                v0=a0*ret;//将下层的返回值和自己的a0相乘并变为自己的返回值
                ret=v0;//将自己的返回值赋给ret，供自己的上一层使用
                continue;//不会有push语句，也就是对应正常递归里面的本层执行完毕就注销内存了
            }
        }
    }
    return ret;
}

移除元素

27. 移除元素 - 力扣（LeetCode）

原来思路是删除之后和非val值交换，仿照快排双指针（left，right），没想明白

法一：每找到一个目标值，将后面的数往前挪，进行覆盖，即for双层循环

注意：

外循环终止条件：i后面元素有count个
内循环k结束的位置
内循环结束后整体左移一个，但i++

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int count = 0;
        int m;
        for(int i = 0;i<nums.size();i++){
            if(nums[i] == val){
                count++;
               
                for(int k = i;k<nums.size()-1;k++){//nums.size()-1
                    nums[k] = nums[k+1];
                }
                i--;//

            }
            m = nums.size()-count-1;
            if(i == m){
                break;
            }
        }
        return nums.size()- count;
    }
};

法二：双指针，遍历数组，符合要求的萝卜（fast）放在坑(slow)里，

慢指针相当于开了一个空数组。