• 单向链表(Singly Linked List)


    一、简介

            链表是由一系列节点组成的线性结构,每个节点包括两个部分:存储空间元素和下一个节点地址的指针。

            链表的元素个数不受限制,添加元素时存储个数会随之改变。

            链表的有点在于确定大小,插入和删除元素都是相当方便;但缺点是不能随机访问。

            在链表中会有一个头指针变量,这个变量可以用来找到这个链表,头指针指向的是第一个节点。

    二、创建

    1、声明

    1. struct ListNode
    2. {
    3. int val;
    4. struct ListNode* next;
    5. ListNode(int x):
    6. val(x);
    7. next(NULL){}
    8. };

    2、创建

    • 创建head节点,并将该节点指向头节点;
    • 创建下一个节点q,并将当前节点p指向q;
    • 节点p向后移一位。
    1. int num;
    2. cin>>num;
    3. ListNode *head=new ListNode(num);
    4. ListNode *p=head;
    5. while(cin>>num){
    6. ListNode*q=new ListNode(num);
    7. p->next=q;
    8. p=p->next;
    9. }

    三、基本操作 

    1、遍历

    只需要每次判断当前是不是空指针,然后输出当前值并指向下一位即可。

    1. ListNode *m=head;
    2. while (m!=nullptr)//nullprt:空指针
    3. {
    4. cout<val<
    5. m=m->next;
    6. }

    2、插入

    • 首先判断现在的链表是不是空的,如果是,那么头节点就指向现在新增的节点;
    • 如果不是空的,那就在链表的尾部插入新节点即可。
    1. ListNode* insertNode(ListNode* head,int data){
    2. ListNode *newNode=new ListNode(data);
    3. ListNode *p=head;
    4. if (p==nullptr){
    5. head=newNode;
    6. }
    7. else
    8. {
    9. while (p->next!=nullptr)
    10. {
    11. p=p->next;
    12. }
    13. p->next=newNode;
    14. }
    15. return head;
    16. }

     3、删除

    • 首先判断是不是空节点,如果是,那就不用执行了;
    • 判断是不是删除头节点,如果是,那么头节点head要先指向下一位,避免找不到链表;
    • 如果有该节点,那就遍历到它的前一个节点;
    • 如果没有找到该节点,那就不用执行了;
    • 否则进行delete。
    1. ListNode *deleteNode(ListNode* head, int data)
    2. {
    3. ListNode *p=head;
    4. if (p==nullptr)
    5. {
    6. return head;
    7. }
    8. else
    9. {
    10. if (p->val==data)
    11. {
    12. head=p->next;
    13. delete p;
    14. return head;
    15. }
    16. else
    17. {
    18. while(p->next!=nullptr&&p->next->val!=data)
    19. {
    20. p=p->next;
    21. }
    22. if(p->next==nullptr)
    23. {
    24. return head;
    25. }
    26. else
    27. {
    28. ListNode *deleteNode=p->next;
    29. p->next=deleteNode->next;
    30. delete deleteNode;
    31. return head;
    32. }
    33. }
    34. }
    35. }

     4、查询指定的节点

    • 查询与遍历很像;
    • 首先,判断当前指针是不是NULL;
    • 然后,判断是不是与目标相等,如果相等,就返回当前节点;
    • 继续下一个节点。
    1. struct Node *FindNode(int a)
    2. {
    3. struct Node *temp=head;
    4. while(temp!=NULL)
    5. {
    6. if(a==temp->a)
    7. {
    8. return temp;
    9. }
    10. temp=temp->next;
    11. }
    12. return NULL;
    13. }

     5、清空

    • 一个一个释放当前节点,最后实现全部释放。
    1. void FreeList()
    2. {
    3. struct Node *temp=head;
    4. while(temp!=NULL)
    5. {
    6. struct Node *pt=temp;
    7. temp=temp->next;
    8. free(pt);
    9. }
    10. head=NULL;
    11. end=NULL;
    12. }

    以上就是本文的全部内容啦!

    参考文献:https://blog.csdn.net/Forever_wj/article/details/107517451

  • 相关阅读:
    python中pickle向redis中存储数据
    linux os cpufreq 调频
    pip 清华镜像
    【Flutter -- 实战】快速入门 Flutter
    010 springboot整合mybatis-plus 登录页面和首页不拦截
    Shiro安全(二):Shiro-550内存马注入
    01.AJAX 概念和 axios 使用
    node-sass报错无法安装
    分割回文串 II[动规典中典]
    工号不够用了怎么办?
  • 原文地址:https://blog.csdn.net/weixin_46522531/article/details/126560733