10.23Leetcode每日一题

//**
 * 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* reverseList(ListNode* head) {
        ListNode * prev =nullptr;//指向前一个节点的指针，并初始化为空，因为最开始没有前一个节点
        ListNode *current =head;//指向当前节点的指针，并指向当前链表的头结点
        while(current !=nullptr){//创造一个循环，直到循环到链表的末尾
            ListNode *next =current->next; //指向下一个节点的指针
            current->next=prev;//核心部分。它将当前节点的 next 指针指向前一个节点，从而反转了指针方向。
            prev=current;//左=右：左指向右
            current=next;
        }
        return prev;//返回反转链表的新头节点
    }
};

当解释这段代码时，我们将逐行说明其功能和执行过程：

1.ListNode* reverseList(ListNode* head) {：这是一个成员函数的定义，它接受一个指向链表头节点的指针作为参数，并返回指向反转后链表的新头节点的指针。
2.ListNode* prev = nullptr;：创建一个指向前一个节点的指针 prev，最初设置为 nullptr，因为在开始时没有前一个节点。
3.ListNode* current = head;：创建一个指向当前节点的指针 current，并将其初始化为输入参数 head，即链表的头节点。
4.while (current != nullptr) {：开始一个循环，直到 current 指向了链表的末尾（即为 nullptr）。
5.ListNode* next = current->next;：创建一个指向下一个节点的指针 next，以便在反转当前节点后能够访问下一个节点。
6.current->next = prev;：这一行代码是实现反转的核心部分。它将当前节点的 next 指针指向前一个节点，从而反转了指针方向。
7.prev = current;：将 prev 指针更新为当前节点，为下一次迭代做准备。
8.current = next;：将 current 指针移动到下一个节点，为下一次迭代做准备。
9.}：结束循环。在循环结束时，所有节点的指针方向都已经被反转。
10.return prev;：返回指向反转后链表的新头节点的指针，即原链表的最后一个节点。

总的来说，这段代码通过迭代遍历单链表，逐个反转节点的指针方向，最终返回一个新链表的头节点，它是原链表的最后一个节点，因为原链表的头节点在反转后成为了链表的尾节点。这是一种常见的反转单链表的算法。

/**
 * 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* mergeTwoLists(ListNode* list1, ListNode* list2) {
        // 创建一个虚拟头节点，简化合并操作
        ListNode* dummyHead = new ListNode(0);
        ListNode* current = dummyHead; // 用于构建新链表

        while (list1 != nullptr && list2 != nullptr) {
            if (list1->val < list2->val) {
                current->next = list1;
                list1 = list1->next;
            } else {
                current->next = list2;
                list2 = list2->next;
            }
            current = current->next;
        }

        // 如果其中一个链表遍历完了，但另一个链表还有剩余节点
        if (list1 != nullptr) {
            current->next = list1;
        } else {
            current->next = list2;
        }

        ListNode* mergedList = dummyHead->next; // 获取合并后的链表
        delete dummyHead; // 释放虚拟头节点的内存
        return mergedList;
    }
};

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int maxDepth(TreeNode* root) {
        if (root == nullptr) {
            // 如果根节点为空，返回深度0
            return 0;
        } else {
            // 递归计算左子树和右子树的深度，取较大者加1
            int leftDepth = maxDepth(root->left);
            int rightDepth = maxDepth(root->right);
            return std::max(leftDepth, rightDepth) + 1;
        }
    }
};