c++中的递归拷贝（Recursive Copy）和递归反转链表（Recursive Reverse Linked List）

前言

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;
}

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