剑指offer35复杂链表的复制

一、new的用法
在 C++ 中，通过 new 运算符来实现动态内存分配。new 运算符的用法如下：

T *p = new T;//其中，T 是任意类型名，p 是类型为 T* 的指针。这样的语句会动态分配出一片大小为 sizeof(T) 字节的内存空间，并且将该内存空间的起始地址赋值给 p。
T *p =new T[N];//用来动态分配一个任意大小的数组.其中，T 是任意类型名，p 是类型为 T* 的指针，N 代表“元素个数”，可以是任何值为正整数的表达式，表达式中可以包含变量、函数调用等。这样的语句动态分配出 N × sizeof(T) 个字节的内存空间，这片空间的起始地址被赋值给 p。

new operator就是我们平时所使用的new，但在C++中一提到new，至少可能代表以下三种含义：new operator、operator new、placement new。
new operator
内置的new操作符，经常使用的T *ptr = new T()，分配内存，调用构造函数，返回指针

1、调用operator new分配内存，operator new (sizeof(A))
2、调用构造函数生成类对象，A::A() ，调用placement new
3、返回相应指针
　　事实上，分配内存这一操作就是由operator new(size_t)来完成的，如果类A重载了operator new，那么将调用A::operator new(size_t )，否则调用全局::operator new(size_t )，后者由C++默认提供。
operator new
　　像普通运算符一样可以被重载，operator new会去申请内存，申请失败的时候会调用new_handler处理，这是一个循环的过程，如果new_handler不抛出异常，会一直循环申请内存，直到成功。
1、分配size字节的存储空间，如果成功的话返回一个非空指针，将对象类型进行内存对齐，指向分配空间第一个字节。如果失败的话，会抛出bad_alloc异常，不调用构造函数
2、和第一种一样，差别在于，如果失败的话，不抛出异常，而是返回一个null指针，不调用构造函数
3、只是返回ptr指针，并不分配内存空间。这里的ptr应该指向先前已经分配好的空间，这里的new调用对象的构造函数，在ptr指向的内存空间构造对象或对象数组。ptr指向的内存只要不释放，可以重复使用，所以这种用法一般在对象池或内存池实现中使用也就是placement new版本
placement new
除了应该有的size_t size参数，多其他的任何参数都可以看做placement new。

1、这种new允许在一块已经分配成功的内存上重新构造对象或对象数组。placement new不用担心内存分配失败，因为它根本不分配内存，它做的唯一一件事情就是调用对象的构造函数
2、用定位放置new操作，既可以在栈(stack)上生成对象，也可以在堆（heap）上生成对象。
3、使用语句A* p=new (mem) A;定位生成对象时，指针p和数组名mem指向同一片存储区。 会自动调用类A的构造函数，但是由于对象的空间不会自动释放（对象实际上是借用别人的空间），所以必须显示的调用类的析构函数。
参考链接：https://www.cnblogs.com/tianzeng/p/8964215.html

Node* dum = new Node(0);//初始化一个结点，为 val=0的节点开辟内存
Node* node = new Node(cur->val); // 复制节点 cur

二、c++解法
请实现 copyRandomList 函数，复制一个复杂链表。在复杂链表中，每个节点除了有一个 next 指针指向下一个节点，还有一个 random 指针指向链表中的任意节点或者 null。
本题难点： 在复制链表的过程中构建新链表各节点的 random 引用指向。
哈希表

// Definition for a Node.
class Node {
public:
    int val;
    Node* next;
    Node* random;
    
    Node(int _val) {
        val = _val;
        next = NULL;
        random = NULL;
    }
};
*/
class Solution {
public:
    Node* copyRandomList(Node* head) {
        if(head == nullptr) return nullptr;
        Node* cur = head;
        unordered_map<Node*, Node*> map;
        // 3. 复制各节点，并建立 “原节点 -> 新节点” 的 Map 映射
        while(cur != nullptr) {
            map[cur] = new Node(cur->val);
            cur = cur->next;
        }
        cur = head;
        // 4. 构建新链表的 next 和 random 指向
        while(cur != nullptr) {
            map[cur]->next = map[cur->next];
            map[cur]->random = map[cur->random];
            cur = cur->next;
        }
        // 5. 返回新链表的头节点
        return map[head];

        
    }
};

拼接+拆分

class Solution {
public:
    Node* copyRandomList(Node* head) {
        if(head == nullptr) return nullptr;
        Node* cur = head;
        // 1. 复制各节点，并构建拼接链表
        while(cur != nullptr) {
            Node* tmp = new Node(cur->val);
            tmp->next = cur->next;
            cur->next = tmp;
            cur = tmp->next;
        }
        // 2. 构建各新节点的 random 指向
        cur = head;
        while(cur != nullptr) {
            if(cur->random != nullptr)
                cur->next->random = cur->random->next;
            cur = cur->next->next;
        }
        // 3. 拆分两链表
        cur = head->next;
        Node* pre = head, *res = head->next;
        while(cur->next != nullptr) {
            pre->next = pre->next->next;
            cur->next = cur->next->next;
            pre = pre->next;
            cur = cur->next;
        }
        pre->next = nullptr; // 单独处理原链表尾节点
        return res;      // 返回新链表头节点
    }
};