剑指offer—day 2（链表）

1.剑指 Offer 06. 从尾到头打印链表【简单】

输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。

思路：最简单的就是放数组里面逆置，因为返回vector，所以直接数组就可以。头插法、甚至用栈也可以，但是没必要…

class Solution { //数组
public:
    vector<int> reversePrint(ListNode* head) {
        vector<int> arr;
        ListNode *p=head; //临时指针
        while(p!=NULL){
            arr.push_back(p->val);//直接用insert的话时间复杂度较高，此处用push_back
            p=p->next;
        }
        reverse(arr.begin(),arr.end());  //逆置
        return arr;
    }
};

class Solution {  //头插（递归）
public:
    vector<int> reversePrint(ListNode* head) {
        if(!head)
            return {};
        vector<int> a=reversePrint(head->next);
        a.push_back(head->val);
        return a;
    }
};

2.剑指 Offer 24. 反转链表【简单】

定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。

思路：经典反转链表，头插法（递归/非递归）

class Solution {   //非递归头插法
public:
    ListNode* reverseList(ListNode* head) {
        ListNode *newhead=new ListNode;
        newhead->next=NULL;      //重开带头结点的链表

        ListNode*p; //临时指针遍历原链表
        while(head!=NULL){  //头插
            p=head;
            head=head->next;
            p->next=newhead->next;
            newhead->next=p;
        }
        return newhead->next;
    }
};

3.剑指 Offer 35. 复杂链表的复制 【中等】

请实现 copyRandomList 函数，复制一个复杂链表。在复杂链表中，每个节点除了有一个 next 指针指向下一个节点，还有一个 random 指针指向链表中的任意节点或者 null。

思路一 （哈希表＋回溯)

对特殊链表进行深拷贝。如果是一般链表，直接依次拷贝val和next即可，但是由于有random指针，我们拷贝某结点时，其random所指的结点可能还没有创立。就算我们复制好val和next，对于每一个结点的random，我们还需要在新的链表中需要找到对应新创立的结点，而这个结点和原结点指向的random完全没有关系。
所以每个结点及其对应的新结点的关系我们应该储存下来，方便事后使用random在新列表中寻找。
此处我们使用 hash表 [关键字：当前结点] [值：新结点] ，每次找对应结点直接在hash表中找即可！

class Solution {
public:
    unordered_map<Node*, Node*> table;   
    Node* copyRandomList(Node* head) {     //hash表每个节点均不同
        if (head == nullptr) 
            return nullptr;
        if (!table.count(head)) {      //count判断当前的节点是否在表中
            Node* headNew = new Node(head->val);       //创建新结点（对象，并初始化）
            table[head] = headNew;          //存入hash表中
            headNew->next = copyRandomList(head->next);     //递归创建所有
            headNew->random = copyRandomList(head->random);  //再回溯找到所有的random
        }
        return table[head];        
    }
};

思路二 （迭代 + 节点拆分)

我们首先将该链表中每一个节点拆分为两个相连的节点，例如对于链表A→B→C，我们可以将其拆分为A→A′→B→B′→C→C′ 。对于任意一个原节点 S，其拷贝节点 S’ 即为其后继节点。
此时，拷贝结点的random所指，为原结点的random所指的结点的下一个结点 。需要注意原节点的random可能为空，我们需要特别判断这种情况。

当我们完成了拷贝节点的random的赋值，我们只需要将这个链表按照原节点与拷贝节点的种类进行拆分即可（不改变原链表，并将拷贝链表拆分出来），只需要遍历一次。同样需要注意最后一个拷贝节点的后继节点为空，我们需要特别判断这种情况。

class Solution {
public:

    Node* copyRandomList(Node* head) {     
        if (head == NULL) { //空链表情况
            return NULL;
        }
        
        for(Node *t=head;t!=NULL;t=t->next->next){  //生成拷贝结点
            Node *p=new Node(t->val);
            p->next=t->next;
            t->next=p;
        }

        for(Node *t=head;t!=NULL;t=t->next->next){  //处理random
            Node *p=t->next;  //p遍历复制的结点 
            if(t->random==NULL)   //注意原结点的random为NULL的情况
                p->random=NULL;	 //若原结点的random为NULL，NULL->next会报错
            else
                p->random=t->random->next;
        }
		//拆分两个链表
        Node *newhead=head->next;  //newhead作为复制的链表头
        for(Node *t=head;t!=NULL;t=t->next){  //p遍历拷贝结点
                Node*p=t->next;
                t->next=t->next->next;
                if(p->next!=NULL)   //该拷贝结点的后面是否还有原结点（是否为最后一个拷贝结点）
                    p->next=p->next->next;
                else 
                    p->next=NULL;   
        }
        return newhead;
    }
};

相关知识

vector的用法

vector<int> a; 		//直接初始化，得到size为0的vector
vector<int>  a(100);  //初始化size=100的vector，值默认为0（int时）
vector<int> a(100,2)  //size=100的vector，初始化值为2


a.insert(i,val);  //第i个值(a[i])前插入
a.push_back(val);   //数组尾部插入

a.reverse(a.begin(),a.end());  //逆置，遍历

类的用法

此处用对象作为结点，而不是struct，所以其写法略不同

// Definition for a Node.
class Node {  //Node是类
public:
    int val;
    Node* next;
    Node* random;
    
    Node(int _val) {    //构造函数
        val = _val;
        next = NULL;
        random = NULL;
    }
};

Node *p=new Node(t->val);  //用new给类指针开空间（后面用构造函数）
//前一个Node是类名，定义类指针，一个是构造构造函数

hash表的用法

click here😶‍🌫️🚾