代码随想录3

代码随想录打卡第三天

今天碰到很多困难，螺旋数组花了两个小时才解决，主要困难是对二维数组不够了解，以及二维数组malloc初始化方式，延伸到数组指针，很多知识点都没搞明白。
其次是在链表删除元素题中，题设的head头结点是可能存储元素的，因此需要加上head的元素是否等于val的判定条件。

今日题目
螺旋矩阵||（难度中等）
移除链表元素（思路简单，但细节出错）

螺旋矩阵||

题目：
给定一个正整数 n，生成一个包含 1 到 n^2 所有元素，且元素按顺时针顺序螺旋排列的正方形矩阵。

示例:

输入: 3 输出: [ [ 1, 2, 3 ], [ 8, 9, 4 ], [ 7, 6, 5 ] ]

思路：
这道题全靠代码随想录的视频才明白的。而求解本题依然是要坚持循环不变量原则。

模拟顺时针画矩阵的过程:

填充上行从左到右
填充右列从上到下
填充下行从右到左
填充左列从下到上
由外向内一圈一圈这么画下去。

在具体代码编写中，需要注意的有：

1. 坚持循环不变量原则，一圈一圈的规律，每转完一圈，格子都会小一圈。
2. 在进行一圈的赋值时，要考虑到边界问题。如下图所示，在进行边的循环赋值时，为避免重复赋值，需要坚持左闭右开的原则，即下图第一行1的赋值到边界前便停止，灰色的格子留给右边一列2赋值。
3. 当给定n为奇数时，会出现最后剩下单独一格元素的情况，因此最后需要判定奇数的情况。当给定n为奇数时，直接给最中间的格子赋值即可。
   

具体思路在代码随想录中，这里提一点在二维数组初始化中遇到的困难。
下面是标准初始化步骤，row为行，col为列。

//二维数组使用malloc静态分配
	int row, col, i, j;
	int** array;	
	scanf("%d %d", &row, &col);
	array = (int**)malloc(row * sizeof(int*));//行
	for (i = 0; i < row; i++)
		array[i] = (int*)malloc(col * sizeof(int));//列

其次是通过指针访问二维数组的不同形式，具体内容可参考该帖子

上面初始化和指针的内容有些地方没看懂，以后有时间专门研究一下。尤其是随想录示例代码对二维数组的使用。
附上代码及注释

int** generateMatrix(int n, int* returnSize, int** returnColumnSizes){
    * returnSize = n;
    * returnColumnSizes = (int*)malloc(sizeof(int)*n);
    int startx = 0;
    int starty = 0;
    int offset = 1;//每转完一圈的坐标偏移值
    int count = 1;
    int i,j;//i表示行坐标，j表示列坐标
    int loop = n/2;
    
    //编写时缺少以下代码，没有为二维数组申请空间
    int** ans = (int**)malloc(sizeof(int*) * n);//初始化返回结果数组ans
    for( int k = 0; k < n; k++) {
        ans[k] = (int*)malloc(sizeof(int) * n);//ans[i]相当于一维数组，二维数组中每一行元素都相当于一个一维数组
        (*returnColumnSizes)[k] = n;
    }

    while(loop--){     
        for(j=starty; j<n-offset; j++){//从左到右赋值上面一行，i不变
            ans[startx][j] = count++;
        }
        for(i=startx; i<n-offset; i++){//从上到下赋值右边一列，j不变
            ans[i][j] = count++;
        }
        for( ; j>starty; j--){//从右到左赋值下面一行，i不变
            ans[i][j] = count++;
        }
        for( ; i>startx; i--){//从下到上赋值左边一列，j不变
            ans[i][j] = count++;
        }
        //赋值完一圈后
        startx++;
        starty++;
        offset++;//这里偏移值应该每次加1
    }
    if(n%2){//如果n为奇数,说明赋值后存在最中间的一格没有被赋值，直接赋值即可
        ans[n/2][n/2] = count; //此处不是ans[i][j]
    }
    return ans;
}

下面是示例代码，我不太明白returnColumnSizes和returnSize的意思和使用方法。

int** generateMatrix(int n, int* returnSize, int** returnColumnSizes){
    //初始化返回的结果数组的大小
    *returnSize = n;
    *returnColumnSizes = (int*)malloc(sizeof(int) * n);
    //初始化返回结果数组ans
    int** ans = (int**)malloc(sizeof(int*) * n);
    int i;
    for(i = 0; i < n; i++) {
        ans[i] = (int*)malloc(sizeof(int) * n);
        (*returnColumnSizes)[i] = n;//这里没看懂
    }

    //设置每次循环的起始位置
    int startX = 0;
    int startY = 0;
    //设置二维数组的中间值，若n为奇数。需要最后在中间填入数字
    int mid = n / 2;
    //循环圈数
    int loop = n / 2;
    //偏移数
    int offset = 1;
    //当前要添加的元素
    int count = 1;

    while(loop) {
        int i = startX;
        int j = startY;
        //模拟上侧从左到右
        for(; j < startY + n - offset; j++) {
            ans[startX][j] = count++;
        }
        //模拟右侧从上到下
        for(; i < startX + n - offset; i++) {
            ans[i][j] = count++;
        }
        //模拟下侧从右到左
        for(; j > startY; j--) {
            ans[i][j] = count++;
        }
        //模拟左侧从下到上
        for(; i > startX; i--) {
            ans[i][j] = count++;
        }
        //偏移值每次加2
        offset+=2;
        //遍历起始位置每次+1
        startX++;
        startY++;
        loop--;
    }
    //若n为奇数需要单独给矩阵中间赋值
    if(n%2)
        ans[mid][mid] = count;

    return ans;
}

---

下面是链表的部分了，关于数组我会单独做一个简单总结，总结下题目所用思想，以及自己犯的错误和不懂的地方。

移除链表元素

题目：
给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

示例 1：

输入：head = [1,2,6,3,4,5,6], val = 6
输出：[1,2,3,4,5]
示例 2：

输入：head = [], val = 1
输出：[]
示例 3：

输入：head = [7,7,7,7], val = 7
输出：[]

思想：
写的时候我以为head是空的头结点，到头来看了示例代码才知道题目的head是存储结点元素的。
编写代码时我遇到了一个错误

Leetcode报错：runtime error: member access within null pointer of type
‘struct ListNode‘ (solution.c)

我的错误代码：

    struct ListNode* pre = head;
    struct ListNode* p = head->next; //这里报错
    if(p==NULL)
    return head;

原因：编译器不知道你正在使用的是不是空指针中的元素，所以报错。参考文章

解决方法：提前判断head是否为空，之后再赋值结点

    struct ListNode* pre = head;
    struct ListNode* p ; 
    if(pre==NULL)
    return head;
    p=head->next;

其次，由于head可能存储元素，所以需要加上下面的判定代码

    // 当头结点存在并且头结点的值等于val时
    while(head && head->val == val) {
        temp = head;
        // 将新的头结点设置为head->next并删除原来的头结点
        head = head->next;
        free(temp);
    }

最终代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* removeElements(struct ListNode* head, int val){
    struct ListNode* pre = head;
    struct ListNode* p ; 
    if(pre==NULL)
    return head;
    p=head->next;
    struct ListNode* q = (struct ListNode *)malloc(sizeof(struct ListNode));
    while(p){
        if(p->val == val){
            q = p;
            p = p->next;
            free(q);
            pre->next = p;
            
        }else{
            p = p->next;
            pre = pre->next;
        }
        
    }
    struct ListNode* temp;
    // 当头结点存在并且头结点的值等于val时
    while(head && head->val == val) {
        temp = head;
        // 将新的头结点设置为head->next并删除原来的头结点
        head = head->next;
        free(temp);
    }
    return head;
}