刷代码随想录03--数组+链表

一·螺旋矩阵II

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

初始思路：怀疑是在找规律，是的，（看了一眼提示），划分为左闭右开5块4块（中间一个数字单独考虑）

出现的问题：

1.一圈划分为5块还是4块挣扎了很久

2.没有考虑奇数偶数的差异（基数会多位于中心的一个数字）

3.vector二维数组初始化：【C++】详解vector二维数组的全部操作（超细图例解析！！！）_二维vector-CSDN博客

4.其他见代码注释

一些提醒：

1.3块对称；2,4块对称，写col和row可以参考

整个过程就是在调试代码

class Solution {
public:
    vector<vector<int> > generateMatrix(int n) {
        int i = 0;
        int col, row;
        vector<vector<int> > matrix(n, vector<int>(n, 0)); // vector二维数组初始化
        if(n == 1){
        	matrix[0][0] = 1;
        	return matrix;
		}
		int x = 0; //初始化的位置放错了
        for (int k = 1; k <= (n / 2); k++) {  // 有几个4圈
			    
            for (int j = 1; j <= 4; j++) {         // 转4圈
            	
                for (int m = 1; m <= n - 1-2*x; m++) { // 每一圈从+1到+n-1-2*x(原来写的和k有关，但是k算错了)
                    i++;
                    switch (j) { // 注意行列均-1
                    case 1:
                        row = k - 1;
                        col = k + m - 2;
                        break; // 忘记了

                    case 2:
                        col = n - k;
                        row = k + m - 2;
                        break; // 忘记了

                    case 3:
                        row = n - k;
                        col = n - k + 1 - m;
                        break; // 忘记了

                    case 4:
                        col = k - 1;
                        row = n - k - m + 1;
                        break; // 忘记了
                    }
                    matrix[row][col] = i;
                    
                }
                
            }
//            if(n!=2){
//            	i++; // 第5圈,放错位置了
//            	matrix[--row][col] = i;//不是row--
//			}
            x++;
        }
        if (n % 2 != 0) {
            i++;
            matrix[row][++col] = i;//++col,不是col++
        }
        return matrix;
    }
};

二·移除链表元素

203. 移除链表元素 - 力扣（LeetCode）

考虑：

1.移除链表中元素，主要考虑删除头的不同点；由于单链表单方向的特性，需要用到两个指针

2.C/C++需要考虑内存手动释放（delete）

p.s.链表一般要考虑head?=nullptr

1.最普通的方法:

考虑四种情况：

now是否是头结点；now->val?=val；

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode *last = nullptr, *now = head;
        while (now != nullptr) { // 终止条件要考虑清楚

            if (last == nullptr) { // 刚开始last->next != now时
                if (now->val == val) {
                    head = now->next;
                    delete now;
                    now = head;
                } else {
                    last = head;
                    now = head->next;
                }
            } else {
                if (now->val == val) { // last->next == now且now节点需要删除
                    last->next = now->next;
                    ListNode*p = now;
                    now = p->next;
                    delete p;
                } else { // last->next == now且now节点不需要删除
                    last = now;
                    now = now->next;
                }
            }
        }
        return head;
    }
};

2.虚拟指针（不需要考虑头的特殊情况了） 

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        if(head == nullptr){
            return head;
        }
        ListNode * dummy = new ListNode(0);
        dummy->next = head;
        ListNode* last,*now;
        last = dummy;
        now = head;
        while(now!=nullptr){
            if(now->val == val){
                last->next = now->next;
                delete now;
                now = last->next;
            }else{
                last = now;
                now= now->next;
            }
        }
        head = dummy->next;
        delete dummy;
        return head;
    }
};

3.递归（挺惊奇的，也可以递归）

递归：解决问题时，若可以将问题转换为若干解法相似的小问题，且小问题间有关系（e.g.n阶乘，二分查找），考虑递归

一般代码：

algorithm{

        结束条件；

        该层问题和上下层问题的关系（调佣该函数以及return）；

}

递归思路：

结束条件：head为空，返回head;

递归情况：检查头节点的值是否为 val，有以下情况：1：如果是则删除头节点，调用函数，参数为head->next；2：如果头节点的值不为 val，调用函数（head->next），head->next=该函数返回值

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        if (head == nullptr) {
            return head;
        }
        if (head->val == val) {
            ListNode* p = removeElements(head->next, val);
            delete head;
            return p;
        } else {
            ListNode* p = removeElements(head->next, val);
            head->next = p;
            return head;
        }
    }
};