• 链表收尾(8.2)


     例题解析

    138. 随机链表的复制 - 力扣(LeetCode)

    1.拷贝节点插入原节点的后面(核心)

    这样做的目的是方便找 random 节点,知道原节点可以找 random,知道上一个 random 可以找下一个 random 。

    1. struct Node* cur=head;
    2. while(cur)
    3. {
    4. //通过一前一后两个指针来插入节点
    5. struct Node* next=cur->next;
    6. struct Node* copy=(struct Node*)malloc(sizeof(struct Node));
    7. copy->val=cur->val;
    8. //链接
    9. cur->next=copy;
    10. copy->next=next;
    11. //cur移动
    12. cur=next;
    13. }

    2.放置每个拷贝节点的 random 

    我们可以通过原节点的 random 轻松找到拷贝的 random 

    1. cur=head;
    2. //放置拷贝节点的random
    3. while(cur)
    4. {
    5. //从cur的下一个节点开始遍历
    6. struct Node* copy=cur->next;
    7. //如果原节点的random为空,拷贝节点的random也为空
    8. if(cur->random==NULL)
    9. {
    10. copy->random=NULL;
    11. }
    12. else
    13. //否则拷贝节点的random等于原节点的random的拷贝节点
    14. {
    15. copy->random=cur->random->next;
    16. }
    17. //cur后移动一位
    18. cur=copy->next;
    19. }

    3.将拷贝节点与原链表解开,尾插到一起,并恢复原链表的链接

    1. cur=head;
    2. //创建新链表的头尾节点便于插入
    3. struct Node* copyhead=NULL,*copytail=NULL;
    4. while(cur)
    5. {
    6. struct Node* copy=cur->next;
    7. struct Node* next=copy->next;
    8. //copy节点尾插到新链表
    9. if(copyhead==NULL)
    10. {
    11. copy= copyhead=copytail;
    12. }
    13. else
    14. {
    15. copytail->next=copy;
    16. copytail=copytail->next;
    17. }
    18. //恢复原节点
    19. cur->next=next;
    20. cur=next;
    21. }

    完整代码:

    1. /**
    2. * Definition for a Node.
    3. * struct Node {
    4. * int val;
    5. * struct Node *next;
    6. * struct Node *random;
    7. * };
    8. */
    9. struct Node* copyRandomList(struct Node* head) {
    10. //拷贝节点到原节点的后面
    11. struct Node* cur=head;
    12. while(cur)
    13. {
    14. //通过一前一后两个指针来插入节点
    15. struct Node* next=cur->next;
    16. struct Node* copy=(struct Node*)malloc(sizeof(struct Node));
    17. copy->val=cur->val;
    18. //链接
    19. cur->next=copy;
    20. copy->next=next;
    21. //cur移动
    22. cur=next;
    23. }
    24. cur=head;
    25. //放置拷贝节点的random
    26. while(cur)
    27. {
    28. //从cur的下一个节点开始遍历
    29. struct Node* copy=cur->next;
    30. //如果原节点的random为空,拷贝节点的random也为空
    31. if(cur->random==NULL)
    32. {
    33. copy->random=NULL;
    34. }
    35. else
    36. //否则拷贝节点的random等于原节点的random的拷贝节点
    37. {
    38. copy->random=cur->random->next;
    39. }
    40. //cur后移动一位
    41. cur=copy->next;
    42. }
    43. cur=head;
    44. //创建新链表的头尾节点便于插入
    45. struct Node* copyhead=NULL,*copytail=NULL;
    46. while(cur)
    47. {
    48. struct Node* copy=cur->next;
    49. struct Node* next=copy->next;
    50. //copy节点尾插到新链表
    51. if(copytail==NULL)
    52. {
    53. copyhead=copytail=copy;
    54. }
    55. else
    56. {
    57. copytail->next=copy;
    58. copytail=copytail->next;
    59. }
    60. //恢复原节点
    61. cur->next=next;
    62. cur=next;
    63. }
    64. return copyhead;
    65. }

    4.顺序表和链表的区别

    拓展学习:

  • 相关阅读:
    Codeforces Round #815 (Div. 2)(A~D1)
    hystrix功能汇总
    21 移动网络的前世今生
    caffe 安装
    路径规划算法:基于群居蜘蛛优化的路径规划算法- 附代码
    1. 查询语句基础
    Redisson实现分布式锁案例
    Flutter 视频video_player与缓存flutter_cache_manager
    Python中安装hnswlib包出错的解决方法
    vim命令编辑完文件后,按ESC键退出编辑模式,无法进入命令模式解决方案
  • 原文地址:https://blog.csdn.net/dn235z/article/details/133949465