代码随想录二刷 Day1

704. 二分查找 - 力扣（LeetCode）

class Solution {
public:
    int search(vector<int>& nums, int target) 
    {
        //二分查找，使用 i <= j 模板
        int i = 0, j = nums.size() - 1;
        while(i <= j )
        {
            int mid = i + (j - i) / 2;
            if(nums[mid] > target)
            {
                j = mid - 1;
            }
            else if(nums[mid] < target)
            {
                i = mid + 1;
            }
            else
            {
                return mid;
            }
        }
        return -1;
    }
};

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

class Solution {
public:
    int removeElement(vector<int>& nums, int val) 
    {
       int i = 0;
       int count = 0;
       for(int j = 0; j < nums.size(); j++)
       {
            if(nums[j] == val)
            {
                continue;
            }
            nums[i++] = nums[j];
            count++;
       }
        return count;
    }
};

977. 有序数组的平方 - 力扣（LeetCode）

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) 
    {
        //采用非递减排序，最终也要实现非递减顺序排序
        //所以数组最左边的位置和数组最最右边的位置就是当前可能的最大值的出现位置
        //采用双指针，一个指向0，一个指向nums.size()-1,哪个位置用了就向前移动
        //用一个新数组来存放排序后的数据
        int i = 0, j = nums.size() - 1;
        vector<int> result(nums.size(), 0);
        for(int k = result.size() - 1; k >= 0; k--)
        {
            int a = nums[i] * nums[i];
            int b = nums[j] * nums[j];
            if(a > b)
            {   
                i++;
                result[k] = a;
            }
            else
            {   
                j--;
                result[k] = b;
            }
        }
        return result;
    }
};

209. 长度最小的子数组 - 力扣（LeetCode）

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) 
    {
        
        //子数组必须是连续的，一个连续区间就可以使用滑动窗口
        int min = INT32_MAX;
        int slow = 0, fast = 0;
        int sum = 0;
        for(; fast < nums.size(); fast++)
        {
            sum += nums[fast];
            while(sum >= target)
            {
                int length = fast - slow + 1;
                if(min > length)
                {
                    min = length;
                }
                sum -= nums[slow++];
            }
        }
        if(min == INT32_MAX)
            return 0;
        else
            return min;
        
    }
};

59. 螺旋矩阵 II - 力扣（LeetCode）

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) 
    {
        //螺旋矩阵最主要的就是控制每一轮的每个方向的区间
        //首先划分方向区间：从左到右->从上到下->从右到左->从下到上,然后进入下一轮
        //然后控制前进区间，很明显，每次可以前进的范围都会收缩一步
        //最后是行动轮次控制，需要循环的轮数是 n / 2
        //如果是奇数，最后需要在正中央补上本身，也就是(n/2, n/2) = n;

        int loopTime = n / 2;//控制循环次数
        int offSet = 0;//每次收缩的量，随着轮次增加增加
        int startX = 0, startY = 0;//从(0, 0)点开始
        int count = 1;//填数
        //生成矩阵
        vector<vector<int>> matrix(n , vector<int>(n , 0));

        while(loopTime > 0)
        {
            //从左到右
            for(int i = startY; i < n - offSet - 1; i++)
            {
                matrix[startX][i] = count++;
            }
            //从上到下
            for(int i = startX; i < n - offSet - 1; i++)
            {
                matrix[i][n - offSet - 1] = count++;
            }
            //从右到左
            for(int i = n - startX - 1; i > 0 + offSet; i--)
            {
                matrix[n - offSet - 1][i] = count++;
            }
            //从下到上
            for(int i = n - startY - 1; i > 0 + offSet; i--)
            {
                matrix[i][startX] = count++;
            }
            loopTime--;
            offSet++;
            startX++;
            startY++;
        }
        if( n % 2 == 1 )
        {
            matrix[n / 2][n / 2] = n * n;
        }
        return matrix;
    }
};

232. 用栈实现队列 - 力扣（LeetCode）

//总体思路是两个栈，一个是充当入栈，一个充当出栈。
//整体逻辑如下
//push()时就压入入栈，此时根据FILO的原则，如果调用peek或着pop就只能调用到入栈栈顶元素，也就是最后进入队列的元素，这与队列FIFO冲突
//所以调用peek和pop的时候，先检测出栈中是否有元素，有元素的话pop就弹出，peek就返回出栈栈顶元素。
//如果出栈中没有元素，就将入栈中的元素全部压入出栈，根据栈FILO的原则，最后出栈中的顺序就是符合队列FIFO的顺序
//比如1,2,3,4压入入栈，入栈中取出的顺序就是4,3,2,1, 此时按这个顺序压入出栈，出栈从栈顶到栈底的顺序就是1,2,3,4,符合队列原则

class MyQueue {
public:
    stack<int> inStack;
    stack<int> outStack;
    MyQueue() 
    {
       
    }
    
    void push(int x) 
    {
        inStack.push(x);
    }
    
    int pop() 
    {
        //看出栈是否为空，不为空就将出栈top取出，为空就将进栈压入
        if(outStack.empty())
        {   
            //先将入栈压入
            while(!inStack.empty())
            {
                int tmp = inStack.top();
                inStack.pop();
                outStack.push(tmp);
            }
        }
        //取出头顶
        int num = outStack.top();
        outStack.pop();
        return num;
    }
    
    int peek() 
    {
        if(outStack.empty())
        {   
            while(!inStack.empty())
            {
                int tmp = inStack.top();
                inStack.pop();
                outStack.push(tmp);
            }
        }
        int num = outStack.top();
        return num;
    }
    
    bool empty() 
    {
        if(inStack.empty() && outStack.empty() )
        {
            return true;
        }
        else
        {
            return false;
        }
    }
};

/**
 * Your MyQueue object will be instantiated and called as such:
 * MyQueue* obj = new MyQueue();
 * obj->push(x);
 * int param_2 = obj->pop();
 * int param_3 = obj->peek();
 * bool param_4 = obj->empty();
 */

225. 用队列实现栈 - 力扣（LeetCode）

class MyStack {
public:

    queue<int> inQueue;//主使用队列
    queue<int> backUp;//用于存储副本的队列

    MyStack() {

    }
    
    void push(int x) 
    {
        inQueue.push(x);
    }
    
    int pop() 
    {
        //因为队列只会删除头元素（先插入的元素）
        //所以每次pop需要先将inQueue的元素删到只剩一个，删掉的存到backUp内，然后将inQueue剩下的元素弹出，再把backUp的元素返回到inQueue
        while(!inQueue.empty() && inQueue.size() > 1)
        {
            int temp = inQueue.front();
            inQueue.pop();
            backUp.push(temp);
        }
        int num = inQueue.front();
        inQueue.pop();
        //元素返回
        while(!backUp.empty())
        {
            int temp = backUp.front();
            backUp.pop();
            inQueue.push(temp);
        }
        return num;
    }
    
    int top() 
    {
        if(!inQueue.empty())
        {
            return inQueue.back();
        }
        else
        {
            return -1;
        }
    }
    
    bool empty() 
    {
       return inQueue.empty();
    }
};

/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack* obj = new MyStack();
 * obj->push(x);
 * int param_2 = obj->pop();
 * int param_3 = obj->top();
 * bool param_4 = obj->empty();
 */

        第一天主要是复习，将数组部分完成，加上栈实现队列是因为笔试碰到但是没思路导致笔试G了，特此恶补，并连带队列实现栈。