Leetcode 剑指 Offer 24~26

最新推荐文章于 2024-06-29 15:57:26 发布

G0rgeoustray

最新推荐文章于 2024-06-29 15:57:26 发布

阅读量107

点赞数

分类专栏： Leetcode 文章标签： leetcode c++

本文链接：https://blog.csdn.net/G0rgeoustray/article/details/119307251

版权

Leetcode 专栏收录该内容

80 篇文章 2 订阅

订阅专栏

24. 反转链表

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* newHead = NULL;
        ListNode* p = head;
        while (p) {
            ListNode* temp = p->next;
            p->next = newHead;
            newHead = p;
            p = temp;
        }
        return newHead;
    }
};

25. 合并两个排序的链表

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode* p = l1;
        ListNode* q = l2;
        ListNode* ansHead = new ListNode(0);
        ListNode* ansTail = ansHead;
        while (p || q) {
            moveToAns(ansTail, getSmallerOne(p, q));
        }
        return ansHead->next;
    }

    ListNode*& getSmallerOne(ListNode*& a, ListNode*& b) {
        if (!a)
            return b;
        else if (!b)
            return a;
        else
            return a->val < b->val ? a : b;
    }

    void moveToAns(ListNode*& ansTail, ListNode*& head) {
        ListNode* newHead = head->next;
        ansTail->next = head;
        ansTail = head;
        ansTail->next = NULL;
        head = newHead;
    }
};

26. 树的子结构

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isSubStructure(TreeNode* A, TreeNode* B) {
        if (!B)
            return false;
        return traverseTree(A, B);
    }

    bool traverseTree(TreeNode* A, TreeNode* B) {
        if (isSubStructureCore(A, B))
            return true;
        if (A->left != NULL && traverseTree(A->left, B))
            return true;
        if (A->right != NULL && traverseTree(A->right, B))
            return true;
        return false;
    }

    bool isSubStructureCore(TreeNode* A, TreeNode* B) {
        if (!A && !B)
            return true;
        if (A && B) {
            if (A->val != B->val)
                return false;
            else
                return isSubStructureCore(A->left, B->left)
                    && isSubStructureCore(A->right, B->right);
        } else if (!B) {
            return true;
        } else {
            return false;
        }
    }
};