前言

hello大家好啊，这里是文宇，不是文字，是文宇哦。

递归拷贝（Recursive Copy）

C++中的递归拷贝是一种在拷贝对象时使用递归方法的技术。在C++中，为了拷贝一个对象，通常使用拷贝构造函数或拷贝赋值运算符。然而，对于复杂的对象，拷贝构造函数和拷贝赋值运算符可能无法完全拷贝对象的所有成员。这就需要使用递归拷贝来确保所有成员都能被正确地拷贝。

递归拷贝是一种深度拷贝技术，它通过递归地拷贝对象的所有成员，包括成员变量和成员函数。在递归拷贝过程中，每个成员变量都会被递归拷贝，直到所有的成员变量都被拷贝完成。递归拷贝可以确保对象的所有成员都能被正确地拷贝，并且递归拷贝也可以处理动态分配的成员变量，例如指针和容器。

递归拷贝的实现思路是使用递归函数来拷贝对象的成员变量。对于每个成员变量，如果它是一个基本类型，那么直接拷贝它的值；如果它是一个自定义类型，那么递归地调用拷贝构造函数或拷贝赋值运算符来拷贝它。递归拷贝的终止条件是当对象的所有成员变量都被拷贝完成时，递归函数退出。

递归拷贝可以应用于各种复杂的对象，例如嵌套的数据结构和递归定义的数据类型。例如，考虑下面的示例类：

class Node { public:     int data;     Node* next;      Node(int data = 0, Node* next = nullptr) : data(data), next(next) {} }; 

上面的类定义了一个链表节点，有一个整数类型的数据和一个指向下一个节点的指针。如果要拷贝一个链表，通常只拷贝头节点是不够的，还需要递归地拷贝整个链表。递归拷贝可以很方便地处理这种情况，代码如下：

Node* copyNode(Node* node) {     if (node == nullptr) {         return nullptr;     }      Node* newNode = new Node(node->data);     newNode->next = copyNode(node->next);      return newNode; }  Node* copyLinkedList(Node* head) {     return copyNode(head); } 

上面的代码中，copyNode函数用来拷贝一个节点，它首先创建一个新节点，并将原节点的数据拷贝到新节点中。然后，它递归地调用copyNode函数来拷贝下一个节点。最后，它返回新节点的指针。copyLinkedList函数用来拷贝整个链表，它只需要调用copyNode函数来拷贝头节点即可。

递归拷贝除了能够处理嵌套的数据结构外，还可以处理递归定义的数据类型。例如，考虑下面的示例类：

class BinaryTree { public:     int data;     BinaryTree* left;     BinaryTree* right;      BinaryTree(int data = 0, BinaryTree* left = nullptr, BinaryTree* right = nullptr)         : data(data), left(left), right(right) {} }; 

上面的类定义了一个二叉树节点，有一个整数类型的数据和左右子树的指针。如果要拷贝一个二叉树，同样需要递归地拷贝整个二叉树。递归拷贝可以很方便地处理这种情况，代码如下：

BinaryTree* copyBinaryTree(BinaryTree* root) {     if (root == nullptr) {         return nullptr;     }      BinaryTree* newRoot = new BinaryTree(root->data);     newRoot->left = copyBinaryTree(root->left);     newRoot->right = copyBinaryTree(root->right);      return newRoot; } 

上面的代码中，copyBinaryTree函数用来拷贝一个二叉树，它首先创建一个新的根节点，并将原节点的数据拷贝到新节点中。然后，它递归地调用copyBinaryTree函数来拷贝左右子树。最后，它返回新的根节点的指针。

递归拷贝是一种强大而灵活的拷贝技术，可以处理各种复杂的对象，并且可以应用于各种数据结构和数据类型。然而，递归拷贝也有一些缺点，例如可能会导致性能问题和内存泄漏。因此，在使用递归拷贝时需要注意合理使用，并确保资源的正确释放。

递归反转链表（Recursive Reverse Linked List）

递归反转链表是一种常见的链表操作，它通过递归的方式将链表中的节点顺序进行反转。在C++中，可以使用递归的方法来实现链表的反转，这种方法简洁而且易于理解。

在开始之前，让我们先定义一个链表的节点结构，以及一个链表的类：

struct ListNode {     int val;     ListNode* next;     ListNode(int x) : val(x), next(NULL) {} };  class LinkedList { public:     ListNode* head;     LinkedList() : head(NULL) {}      void insert(int val) {         ListNode* newNode = new ListNode(val);         if (head == NULL) {             head = newNode;         } else {             ListNode* curr = head;             while (curr->next != NULL) {                 curr = curr->next;             }             curr->next = newNode;         }     } }; 

接下来，我们可以实现递归的反转函数。该函数将使用两个指针，一个指向当前节点，另一个指向前一个节点。通过递归地反转链表的剩余部分，我们可以将当前节点的next指针指向前一个节点。

ListNode* reverse(ListNode* curr, ListNode* prev) {     // 如果当前节点为空，表示链表已经反转完成     if (curr == NULL) {         return prev;     }          // 保存下一个节点的指针     ListNode* nextNode = curr->next;     // 将当前节点的next指针指向前一个节点     curr->next = prev;          // 递归地反转剩余的链表部分     return reverse(nextNode, curr); } 

最后，我们可以在链表类中添加一个公有的逆转函数，它将把链表头节点传递给递归函数，并更新链表的头指针：

void reverseList() {     head = reverse(head, NULL); } 

现在，我们可以通过以下示例来测试递归反转链表的功能：

int main() {     LinkedList linkedList;     // 在链表中插入一些节点     linkedList.insert(1);     linkedList.insert(2);     linkedList.insert(3);     linkedList.insert(4);          // 打印反转前的链表     ListNode* curr = linkedList.head;     while (curr != NULL) {         cout << curr->val << " ";         curr = curr->next;     }     cout << endl;          // 反转链表     linkedList.reverseList();          // 打印反转后的链表     curr = linkedList.head;     while (curr != NULL) {         cout << curr->val << " ";         curr = curr->next;     }     cout << endl;          return 0; } 

运行以上代码，我们将得到以下输出：

1 2 3 4 4 3 2 1 

可以看到，链表中的节点顺序已经被成功地反转了。

递归反转链表的时间复杂度为O(n)，其中n是链表的长度。空间复杂度为O(n)，因为在递归过程中，系统需要保存每个递归调用的状态。

结语

今日二更结束，睡觉。