每日一题（4.12）

最新推荐文章于 2024-11-15 22:13:14 发布

别看我只是一只杨女士1

最新推荐文章于 2024-11-15 22:13:14 发布

阅读量877

点赞数 6

文章标签： leetcode 算法

本文链接：https://blog.csdn.net/2301_81022805/article/details/137697688

版权

本文详细介绍了LeetCode中的两个题目，一个是螺旋矩阵的顺时针遍历算法，另一个是链表两数相加的逆序相加方法。通过示例和代码实现，展示了如何解决这些问题。

摘要由CSDN通过智能技术生成

Leecode-54-螺旋矩阵

题目

给你一个 m 行 n 列的矩阵 matrix ，请按照顺时针螺旋顺序，返回矩阵中的所有元素。

示例

示例1

输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[1,2,3,6,9,8,7,4,5]

示例2
示例2

输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
输出：[1,2,3,4,8,12,11,10,9,5,6,7]

解题思路

从左到右遍历上侧元素，依次为 (top,left) 到 (top,right)

从上到下遍历右侧元素，依次为 (top+1,right)到 (bottom,right)

如果 left<right 且 top<bottom，则从右到左遍历下侧元素，依次为 (bottom,right−1) 到 (bottom,left+1)，以及从下到上遍历左侧元素，依次为 (bottom,left) 到 (top+1,left）

遍历完当前层的元素之后，将 left 和 top 分别增加 1，将 right 和 bottom 分别减少 1，进入下一层继续遍历，直到遍历完所有元素为止。

代码实现

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */

int* spiralOrder(int** matrix, int matrixSize, int* matrixColSize, int* returnSize) {\
    if (matrixSize == 0 || matrixColSize[0] == 0) {
        *returnSize = 0;
        return NULL;
    }

    int *res = (int *)malloc(sizeof(int)*matrixSize*matrixColSize[0]);

    int top = 0,bottom = matrixSize-1;
    int left = 0,right = matrixColSize[0]-1;
    *returnSize = 0;
    while(left <= right && top <= bottom){
        for(int j = left; j <= right; j++){
            res[(*returnSize)++] = matrix[top][j];
        }
        for(int i = top + 1 ; i <= bottom; i++){
            res[(*returnSize)++] = matrix[i][right];
        }
        if(left < right && top < bottom){
            for(int j = right - 1;j > left; j--){
                res[(*returnSize)++] = matrix[bottom][j];
            }
            for(int i = bottom; i > top; i--){
                res[(*returnSize)++] = matrix[i][left];
            }
        }
        left++;
        right--;
        top++;
        bottom--;
    }
    
    return res;
}

Leecode-445-两数相加II

题目

给你两个非空链表来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储一位数字。将这两数相加会返回一个新的链表。

你可以假设除了数字 0 之外，这两个数字都不会以零开头。

示例

示例1
示例1

输入：l1 = [7,2,4,3], l2 = [5,6,4]
输出：[7,8,0,7]

示例2

输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[8,0,7]

示例3

输入：l1 = [0], l2 = [0]
输出：[0]

解题思路

先反转链表l1、l2，使链表存储的数据变成逆序
依次开辟空间，将链表中的数据相加，并用尾插法存储到新创建的头节点中
再次反转链表，使之正序，返回即可

代码实现

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */

struct ListNode* reverse(struct ListNode* head){
    struct ListNode* pPrev = NULL;
    struct ListNode* pCurrent = head;
    while(pCurrent){
        struct ListNode* tmp = pCurrent->next;
        pCurrent->next = pPrev;
        pPrev = pCurrent;
        pCurrent = tmp;
    }
    return pPrev;
}

struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2){
    struct ListNode* p1 = reverse(l1);
    struct ListNode* p2 = reverse(l2);

    struct ListNode* head = (struct ListNode*)malloc(sizeof(struct ListNode));
    head->next = NULL;
    struct ListNode* foot = head;

    int sum = 0;
    while(p1 || p2 || sum){
        int n1 = p1 ? p1->val : 0;
        int n2 = p2 ? p2->val : 0;
        sum += n1 + n2;

        foot->next = (struct ListNode*)malloc(sizeof(struct ListNode));
        foot->next->next = NULL;
        foot = foot->next;
        foot->val = sum % 10;
        sum /= 10;
        
        if(p1){
            p1 = p1->next;
        }

        if(p2){
            p2 = p2->next;
        }
    }
    
    struct ListNode* res = reverse(head->next);
    return res;
}