y总方法详细注释版

//模拟
#include<iostream>
using namespace std;

int arr[110][110];
//数组开在堆上，初始值全为0

int main()
{
    int n ,m;
    cin >> n >> m;
    int res=1;//待填充的值，也是遍历次数的判断条件
    int x=0, y=0;//待填充坐标
    int dir_x[]={0, 1, 0, -1}, dir_y[]={1, 0, -1, 0};//决定x，y往哪个地方走
    int index=0;//dir_x、dir_y的下标，表明下一个待填充的位置怎么走。通过下标决定下一个填充位置的方向

    for(res=1; res<=n*m; res++)
    {
        arr[x][y] = res;
        int i=0, j=0; //用来临时存储坐标，防止有效坐标被更改
        //使用i，j来测试下一个有效坐标在哪里，是否需要转向
        i = x + dir_x[index];
        j = y + dir_y[index];
            //判断i， j是不是有效坐标；这里可以画图模拟一遍！
        if(i<0||i>=n || j<0||j>=m || arr[i][j])
        {
            //到这里就代表i，j不是有效坐标，需要转向
            index = (index+1)%4;//让index一直在数组中循环0~3
            //更新正确的i，j
            i = x + dir_x[index];
            j = y + dir_y[index];
        }
        x = i;
        y = j;
    }

    //output
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<m; j++)
        {
            cout << arr[i][j] << " ";
        }
        cout << endl;
    }



    return 0;
}

//模拟
#include<iostream>
using namespace std;

int arr[110][110];
//数组开在堆上，初始值全为0

int main()
{
    int n ,m;
    cin >> n >> m;
    int res=1;//待填充的值，也是遍历次数的判断条件
    int x=0, y=0;//待填充坐标
    int dir_x[]={0, 1, 0, -1}, dir_y[]={1, 0, -1, 0};//决定x，y往哪个地方走
    int index=0;//dir_x、dir_y的下标，表明下一个待填充的位置怎么走。通过下标决定下一个填充位置的方向

    for(res=1; res<=n*m; res++)
    {
        arr[x][y] = res;
        int i=0, j=0; //用来临时存储坐标，防止有效坐标被更改
        //使用i，j来测试下一个有效坐标在哪里，是否需要转向
        i = x + dir_x[index];
        j = y + dir_y[index];
            //判断i， j是不是有效坐标
        if(i<0||i>=n || j<0||j>=m || arr[i][j])
        {
            //到这里就代表i，j不是有效坐标，需要转向
            index = (index+1)%4;//让index一直在数组中循环0~3
            //更新正确的i，j
            i = x + dir_x[index];
            j = y + dir_y[index];
        }
        x = i;
        y = j;
    }

    //output
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<m; j++)
        {
            cout << arr[i][j] << " ";
        }
        cout << endl;
    }



    return 0;
}

一、使用栈容器

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution 
{
public: // 最先想到的思路就是栈
    vector<int> printListReversingly(ListNode* head) 
    {
        stack<int> s;
        vector<int> vec; //用来返回结果
        //遍历链表，节点值入栈
        for(ListNode* i=head; i!=NULL; i=i->next)
            s.push(i->val);
        //出栈入vector
        while(!s.empty())
        {
            vec.push_back(s.top());
            s.pop();
        }
        return vec;
    }
};

一、申请两个数组来辅助存储

class Solution 
{
public:
    void reOrderArray(vector<int> &array) 
    {
        //申请两个数组来分别存储奇数、偶数     
        int arr1[100], arr2[100];
        int m=0, n=0;
        for(int i=0; i<array.size(); i++)
        {
            if(array[i]%2 != 0)
                arr1[m++] = array[i];
            else
                arr2[n++] = array[i];
        }
        //现在拿到的m，n都是数组中最后一个元素的下一个位置
        //把arr2拷贝到arr1的后半部分
        for(int i=0; i<n; i++)
            arr1[m+i]=arr2[i];
        //再把arr1全部拷贝到array里面
        for(int i=0; i<array.size(); i++)
            array[i] = arr1[i];

    }
};

一、哪里漏水补哪里。不断提交试错，直到枚举所有情况【🐶】

class Solution {
public:
    int getMissingNumber(vector<int>& nums) {
        if(nums.empty()==true)
            return 0;
        if(nums[0]==0 && nums.size()==1)
            return 1;
        int i=0;
        for(i=0; i<nums.size(); i++)
        {
            if(i!=nums[i])
                return i;
        }
        if(i==nums.size())
            return i;
    }
};

二、二分性解题，不断二分找到最终值

//这种方法一定要把图画清晰！不然很绕

class Solution 
{
public:
    int getMissingNumber(vector<int>& nums) 
    {
        //二分法，有两段，每段符合的条件不一样
        //特派情况一、穿进来的是空数组
        if(nums.empty()) return 0;
        //特派情况二、一整段都是符合的，缺少的那个元素是末尾的（最大的那个）
        //有(n-1)=size()个元素，最大下标是size()-1=n-2，
        //按照这种情况二，最大下标处对应的值也应该是size()-1=n-2
        //但是每个下标位置的取值范围是[0~n-1]
        if(nums.size()-1 == nums.back()) return nums.size();

        //缺失的点在中间，二段性成立，使用二分法求下标值，因为缺失的元素可以在下标中找到
        int left=0, right=nums.size()-1;
        while(left < right)
        {
            int mid = (left+right) >> 1; //右移一位相当于除2
            if(nums[mid] != mid)
                right=mid; // 说明mid在元素值和下标不相等的第二段处，把右边界挪到mid处
            else
                left = mid+1; 
            // 下标和元素值相等，肯定不是我要找的元素，挪边界的时候多挪一个
        }
        return right; //这里写left和right都一样
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution 
{
public://还是双指针
    ListNode* merge(ListNode* l1, ListNode* l2) 
    {
        ListNode * head = new ListNode(-1);

        ListNode * tail = head;
        while(l1 && l2)
        {
            if(l1->val < l2->val)
            {
                tail->next = l1;
                tail = tail->next;
                l1 = l1->next;
            }
            else
            {
                tail->next = l2;
                tail = tail->next;
                l2 = l2->next;
            }
        }

        if(l1!=NULL) tail->next = l1;
        if(l2!=NULL) tail->next = l2;

        return head->next;
    }

};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution 
{
public:
    void deleteNode(ListNode* node) 
    {
        node->val = node->next->val;
        node->next = node->next->next;
        //用该节点后面的一个节点全面覆盖该节点，达到输出目的
        //但是实际上删除的并不是该节点，而是屏蔽跳过了该节点后面的那个节点
        //画图便一目了然
    }
};

class Solution 
{
public:
    int getSum(int n) 
    {
        int ans=n;
        n>0 && (ans += getSum(n-1));

        return ans;
    }

};

一、库函数版本

class Solution {
public:
    string leftRotateString(string str, int n) 
    {
        string a = str.substr(0, n);
        str.erase(0, n);
        str += a;
        return str;
    }
};

二、手动循环实现翻转

class Solution 
{
public:
    string leftRotateString(string str, int n) 
    {
        while(n--)
        {
            char temp = str[0];
            for(int i=1; i<str.size(); i++)
                str[i-1]=str[i];
            str[str.size()-1] = temp;
        }
        return str;
    }
};