C++链表小结

已于 2022-10-14 22:14:09 修改
阅读量846 收藏 6
点赞数
分类专栏： 数据结构 文章标签： 链表 c++ 数据结构
于 2022-10-14 22:11:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mxh3600/article/details/127323902
版权

基础知识：

链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）

链接的入口节点称为链表的头节点也就是head。如图所示

 上面是单链表

双链表

单链表中的指针域只能指向节点的下一个节点。

双链表：每一个节点有两个指针域，一个指向下一个节点，一个指向上一个节点。

双链表 既可以向前查询也可以向后查询。

如图所示：

循环链表

循环链表，顾名思义，就是链表首尾相连。

循环链表可以用来解决约瑟夫环问题。

 链表的存储方式

数组是在内存中是连续分布的，但是链表在内存中可不是连续分布的。

链表是通过指针域的指针链接在内存中各个节点。

所以链表中的节点在内存中不是连续分布的 ，而是散乱分布在内存中的某地址上，分配机制取决于操作系统的内存管理。

如图所示：

 这个链表起始节点为2， 终止节点为7， 各个节点分布在内存的不同地址空间上，通过指针串联在一起。

链表的定义

// 单链表
struct ListNode {
    int val;  // 节点上存储的元素
    ListNode *next;  // 指向下一个节点的指针
    ListNode(int x) : val(x), next(NULL) {}  // 节点的构造函数
};

有同学说了，我不定义构造函数行不行，答案是可以的，C++默认生成一个构造函数。

但是这个构造函数不会初始化任何成员变量，下面我来举两个例子：

通过自己定义构造函数初始化节点：

ListNode* head = new ListNode(5);

使用默认构造函数初始化节点：

ListNode* head = new ListNode();
head->val = 5;

所以如果不定义构造函数使用默认构造函数的话，在初始化的时候就不能直接给变量赋值！

链表的操作

删除节点

删除D节点，如图所示：

只要将C节点的next指针 指向E节点就可以了。

那有同学说了，D节点不是依然存留在内存里么？只不过是没有在这个链表里而已。

是这样的，所以在C++里最好是再手动释放这个D节点，释放这块内存。

其他语言例如Java、Python，就有自己的内存回收机制，就不用自己手动释放了。

添加节点

如图所示：

 可以看出链表的增添和删除都是O(1)操作，也不会影响到其他节点。

但是要注意，要是删除第五个节点，需要从头节点查找到第四个节点通过next指针进行删除操作，查找的时间复杂度是O(n)

性能分析

再把链表的特性和数组的特性进行一个对比，如图所示：

插入/删除(时间复杂度)查询(时间复杂度)适用场景
数组O(n)O(1)数据量固定，频繁查询，较少增删
链表O(1)O(n)数据量不固定，频繁增删，较少查询

题目一：移除链表元素

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

输入：head = [1,2,6,3,4,5,6], val = 6
输出：[1,2,3,4,5]
输入：head = [7,7,7,7], val = 7
输出：[]

思路：

这里以链表 1 4 2 4 来举例，移除元素4。

 如果使用C，C++编程语言的话，不要忘了还要从内存中删除这两个移除的节点， 清理节点内存之后如图：

 这种情况下的移除操作，就是让节点next指针直接指向下下一个节点就可以了，

那么因为单链表的特殊性，只能指向下一个节点，刚刚删除的是链表的中第二个，和第四个节点，那么如果删除的是头结点又该怎么办呢？

这里就涉及如下链表操作的两种方式：

  • 直接使用原来的链表来进行删除操作。
  • 设置一个虚拟头结点在进行删除操作。

来看第一种操作：直接使用原来的链表来进行移除。

 移除头结点和移除其他节点的操作是不一样的，因为链表的其他节点都是通过前一个节点来移除当前节点，而头结点没有前一个节点。

所以头结点如何移除呢，其实只要将头结点向后移动一位就可以，这样就从链表中移除了一个头结点。

 依然别忘将原头结点从内存中删掉。

 那么可不可以 以一种统一的逻辑来移除 链表的节点呢。

其实可以设置一个虚拟头结点，这样原链表的所有节点就都可以按照统一的方式进行移除了。

来看看如何设置一个虚拟头。依然还是在这个链表中，移除元素1。

这里来给链表添加一个虚拟头结点为新的头结点，此时要移除这个旧头结点元素1。

这样是不是就可以使用和移除链表其他节点的方式统一了呢？

来看一下，如何移除元素1 呢，还是熟悉的方式，然后从内存中删除元素1。

最后呢在题目中，return 头结点的时候，别忘了 return dummyNode->next;， 这才是新的头结点

 直接使用原来的链表来进行移除节点操作：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
         while(head !=NULL&&head->val == val){
         ListNode* tmp = head;         //直接让头节点指向下一个指针
         head = head->next;
         delete tmp;
         }
         //删除非头节点
         ListNode* cur = head;
         while(cur !=NULL && cur->next!=NULL){
            if(cur->next->val == val){
                ListNode* tmp = cur->next;
                cur->next = cur->next->next;
                delete tmp;
            }
            else{
                cur = cur->next;
            }
         }
         return head;
    }
};

 设置一个虚拟头结点在进行移除节点操作：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution{
public:
     ListNode* removeElements(ListNode* head,int val){
         ListNode* dummyHead = new ListNode(0);
         dummyHead->next = head;
         ListNode* cur = dummyHead;
         while(cur->next != NULL){
            if(cur->next->val == val){
                ListNode* tmp = cur->next;
                cur->next = cur->next->next;
                delete tmp;
            }
            else{
                cur = cur->next;
            }
         }
         head = dummyHead->next;
         delete dummyHead;
         return head;
     }
};

题目二：设计链表

在链表类中实现这些功能：

  • get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
  • addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
  • addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
  • addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val  的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
  • deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

思路： 

删除链表节点：

 添加链表节点：

这道题目设计链表的五个接口：

  • 获取链表第index个节点的数值
  • 在链表的最前面插入一个节点
  • 在链表的最后面插入一个节点
  • 在链表第index个节点前面插入一个节点
  • 删除链表的第index个节点

可以说这五个接口，已经覆盖了链表的常见操作，是练习链表操作非常好的一道题目

链表操作的两种方式：

  1. 直接使用原来的链表来进行操作。
  2. 设置一个虚拟头结点在进行操作。
class MyLinkedList {
public:
    //定义链表节点结构体
    struct LinkedNode{
        int val;
        LinkedNode* next;
        LinkedNode(int val):val(val),next(nullptr){}
    };
    //初始化链表
    MyLinkedList() {
       _dummyHead = new LinkedNode(0);
       _size = 0;
    }
    //获取到第index个节点
    int get(int index) {
      if(index > (_size - 1) || index < 0){
          return -1;
      }
      LinkedNode* cur = _dummyHead->next;
      while(index--){
          cur = cur->next;
      }
      return cur->val;
    }
    //在链表最后面添加一个节点
    void addAtHead(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        newNode->next = _dummyHead->next;
        _dummyHead->next = newNode;
        _size++;
    }
    
    void addAtTail(int val) {
       LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = _dummyHead;
        while(cur->next != nullptr){
            cur = cur->next;
        }
        cur->next = newNode;
        _size++;
    }
    
    void addAtIndex(int index, int val) {
       if(index > _size || index < 0){
           return;
       }
       LinkedNode* newNode = new LinkedNode(val);
       LinkedNode* cur = _dummyHead;
       while(index--){
          cur= cur->next;
       }
       newNode->next = cur->next;
       cur->next = newNode;
       _size++;
    }
    //删除第index个节点，如果index大于等于链表的长度，直接return，注意index是从0开始
    void deleteAtIndex(int index) {
       if(index >= _size || index < 0){
           return;
       }
       LinkedNode* cur = _dummyHead;
       while(index--){
           cur = cur->next;
       }
       LinkedNode* tmp = cur->next;
       cur->next = cur->next->next;
       delete tmp;
       _size--;
    }
    void printLinkedList(){
        LinkedNode* cur = _dummyHead;
        while (cur->next != nullptr){
            cout << cur->next->val << " ";
            cur = cur->next;
        }
        cout << endl;
    }
private:
      int _size;
      LinkedNode* _dummyHead;
};

/**
 * Your MyLinkedList object will be instantiated and called as such:
 * MyLinkedList* obj = new MyLinkedList();
 * int param_1 = obj->get(index);
 * obj->addAtHead(val);
 * obj->addAtTail(val);
 * obj->addAtIndex(index,val);
 * obj->deleteAtIndex(index);
 */
class MyLinkedList{
public:
     //定义链表结构体
     struct LinkedNode{
         int val;
         LinkedNode* next;
         LinkedNode(int val):val(val),next(nullptr){}
     };
     //初始化链表
     MyLinkedList(){
         _dummyHead = new LinkedNode(0);//这里定义的头节点 是一个虚拟头节点，而不是真正的链表
         _size = 0;
     }
     //获取到第index个节点数值，如果index是非法数值直接返回-1，注意index是从0开始的，第0个节点就是头节点
     int get(int index){
         if(index > (_size - 1) || index < 0){
             return -1;
         }
         LinkedNode* cur = _dummyHead->next;
         while(index--){
             cur = cur->next;
         }
         return cur->val;
     }
     //在链表最前面插入一个节点，插入完成后，新插入的节点为链表的新的头节点
     void addAtHead(int val){
         LinkedNode* newNode = new LinkedNode(val);
         newNode->next = _dummyHead->next;
         _dummyHead->next = newNode;
         _size++;
     }
     //在链表最后面添加一个节点
     void addAtTail(int val){
         LinkedNode* newNode = new LinkedNode(val);
         LinkedNode* cur = _dummyHead;
         while(cur->next!=nullptr){
             cur = cur->next;
         }
        cur->next = newNode;
        _size++;
     }
     //在第index个结点之前插入一个新节点
     void addAtIndex(int index,int val){
         if(index > _size || index < 0){
             return;
         }
         LinkedNode* newNode = new LinkedNode(val);
         LinkedNode* cur = _dummyHead;
         while(index--){
             cur = cur->next;
         }
         newNode->next = cur->next;
         cur->next = newNode;
         _size++;
     }
     //删除第index个节点，如果index大于等于链表的长度，直接return，注意index是从0开始的
     void deleteAtIndex(int index){
         if(index >= _size || index < 0){
             return;
         }
         LinkedNode* cur = _dummyHead;
         while(index--){
             cur = cur->next;
         }
         LinkedNode* tmp = cur->next;
         cur->next = cur->next->next;
         delete tmp;
         _size--;
     }
     //打印链表
     void printLinkedList(){
         LinkedNode* cur = _dummyHead;
         while(cur->next!=nullptr){
             cout << cur->next->val << " ";
             cur = cur->next;
         }
         cout << endl;
     }
     private:
          int _size;
          LinkedNode* _dummyHead;
};

题目三：反转链表

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

思路：如果再定义一个新的链表，实现链表元素的反转，其实这是对内存空间的浪费。

其实只需要改变链表的next指针的指向，直接将链表反转 ，而不用重新定义一个新的链表，如图所示:

之前链表的头节点是元素1， 反转之后头结点就是元素5 ，这里并没有添加或者删除节点，仅仅是改变next指针的方向。

首先定义一个cur指针，指向头结点，再定义一个pre指针，初始化为null。

然后就要开始反转了，首先要把 cur->next 节点用tmp指针保存一下，也就是保存一下这个节点。

为什么要保存一下这个节点呢，因为接下来要改变 cur->next 的指向了，将cur->next 指向pre ，此时已经反转了第一个节点了。

接下来，就是循环走如下代码逻辑了，继续移动pre和cur指针。

最后，cur 指针已经指向了null，循环结束，链表也反转完毕了。 此时我们return pre指针就可以了，pre指针就指向了新的头结点。

//双指针法
//pre就是指向靠近头节点的一个空指针
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* temp; // 保存cur的下一个节点
        ListNode* cur = head;
        ListNode* pre = NULL;
        while(cur) {
            temp = cur->next;  // 保存一下 cur的下一个节点，因为接下来要改变cur->next
            cur->next = pre; // 翻转操作
            // 更新pre 和 cur指针
            pre = cur;
            cur = temp;
        }
        return pre;
    }
};
//递归法
class Solution {
public:
    ListNode* reverse(ListNode* pre,ListNode* cur){
        if(cur == NULL) return pre;
        ListNode* temp = cur->next;
        cur->next = pre;
        // 可以和双指针法的代码进行对比，如下递归的写法，其实就是做了这两步
        // pre = cur;
        // cur = temp;
        return reverse(cur,temp);
    }
    ListNode* reverseList(ListNode* head) {
        // 和双指针法初始化是一样的逻辑
        // ListNode* cur = head;
        // ListNode* pre = NULL;
        return reverse(NULL, head);
    }

};

 题目四：两两交换链表中的节点

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。

你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

输入：head = [1,2,3,4]
输出：[2,1,4,3]

建议使用虚拟头结点，这样会方便很多，要不然每次针对头结点（没有前一个指针指向头结点），还要单独处理。

接下来就是交换相邻两个元素了，此时一定要画图，不画图，操作多个指针很容易乱，而且要操作的先后顺序

初始时，cur指向虚拟头结点，然后进行如下三步：

 操作之后，链表如下：

 看这个可能就更直观一些了：

 代码

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummyHead = new ListNode(0); // 设置一个虚拟头结点
        dummyHead->next = head; // 将虚拟头结点指向head，这样方面后面做删除操作
        ListNode* cur = dummyHead;
        while(cur->next != nullptr && cur->next->next != nullptr) {
            ListNode* tmp = cur->next; // 记录临时节点
            ListNode* tmp1 = cur->next->next->next; // 记录临时节点

            cur->next = cur->next->next;    // 步骤一
            cur->next->next = tmp;          // 步骤二
            cur->next->next->next = tmp1;   // 步骤三

            cur = cur->next->next; // cur移动两位，准备下一轮交换
        }
        return dummyHead->next;
    }
};

题目五：删除链表的倒数第N个节点

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

输入：head = [1,2,3,4,5], n = 2 输出：[1,2,3,5] 示例 2：

输入：head = [1], n = 1 输出：[] 示例 3：

输入：head = [1,2], n = 1 输出：[1]

思路：双指针的经典应用，如果要删除倒数第n个节点，让fast移动n步，然后让fast和slow同时移动，直到fast指向链表末尾。删掉slow所指向的节点就可以了。

  • 定义fast指针和slow指针，初始值为虚拟头结点，如图：

 fast首先走n + 1步 ，为什么是n+1呢，因为只有这样同时移动的时候slow才能指向删除节点的上一个节点（方便做删除操作），如图：

fast和slow同时移动，直到fast指向末尾，如题：

 

 删除slow指向的下一个节点，如图：

 代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
      ListNode* dummyHead = new ListNode(0);
      dummyHead->next = head;
      ListNode* slow = dummyHead;
      ListNode* fast = dummyHead;
      while(n-- && fast != NULL){
          fast = fast->next;
      }
      fast = fast->next;
      while(fast != NULL){
          fast = fast->next;
          slow = slow->next;
      }
      slow->next = slow->next->next;
      return dummyHead->next;
    }
};

题目六：链表相交

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at '8'
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

思路：

简单来说，就是求两个链表交点节点的指针。 这里同学们要注意，交点不是数值相等，而是指针相等。

为了方便举例，假设节点元素数值相等，则节点指针相等。

看如下两个链表，目前curA指向链表A的头结点，curB指向链表B的头结点：

 我们求出两个链表的长度，并求出两个链表长度的差值，然后让curA移动到，和curB 末尾对齐的位置，如图：

此时我们就可以比较curA和curB是否相同，如果不相同，同时向后移动curA和curB，如果遇到curA == curB，则找到交点。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
       ListNode* curA = headA;
       ListNode* curB = headB;
       int lenA = 0,lenB = 0;
       while(curA != NULL){      //求链表A的长度
           lenA++;
           curA = curA->next;
       } 
       while(curB != NULL){      //求链表B的长度
           lenB++;
           curB = curB->next;
       }
       curA = headA;
       curB = headB;
       //让curA为最长链表的头，lenA为其长度
       if(lenB > lenA){
           swap(lenA,lenB);
           swap(curA,curB);
       }
       //求长度差
       int gap = lenA - lenB;
       //让curA与curB在同一起点上(末尾位置对齐)
       while(gap--){
           curA = curA->next;
       }
       //遍历curA和curB，遇到相同则直接返回
       while(curA != NULL){
           if(curA == curB){
               return curA;
           }
           curA = curA->next;
           curB = curB->next;
       }
       return NULL;
    }
};

法二

class Solution{
public:
     ListNode *getIntersectionNode(ListNode *headA,ListNode *headB){
         ListNode *A = headA,*B= headB;
         while(A!=B){
             A = A != nullptr ? A->next : headB;
             B = B != nullptr ? B->next : headA;
         }
         return A;
     }
};

 题目七：环形链表

题意： 给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

为了表示给定链表中的环，使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。

思路：可以使用快慢指针法，分别定义 fast 和 slow 指针，从头结点出发，fast指针每次移动两个节点，slow指针每次移动一个节点，如果 fast 和 slow指针在途中相遇 ，说明这个链表有环。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode* fast = head;
        ListNode* slow = head;
        while(fast != NULL && fast->next != NULL){
            slow = slow->next;
            fast = fast->next->next;
            if(slow == fast){
                ListNode* index1 = fast;
                ListNode* index2 = head;
            while(index1 != index2){
                index1 = index1->next;
                index2 = index2->next;
            }
            return index2;
            }
        }
        return NULL;
    }
};

三个刺客
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[Python]数据结构--链表
Festinatione facit vastum
01-11 617
[Python]数据结构–链表 ‘Festinatione facit vastum’ 链表的概念 单链表的实现 循环单链表的实现 链表 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另
数据结构-链表（链表的基本实现C++）
qq_64997742的博客
11-20 273
​线性表是最常用而且简单的一种数据结构，一个线性表是n个数据元素的有限序列。当线性表需要频繁查找，较少插入和删除时，通常采用顺序存储结构，若需要频繁插入和删除，通常采用基于链表的形式；当线性表的元素个数变化较大或不确定时，最好用链表，这样不需要考虑存储空间大小问题，当事先知道线性表的大小长度，用顺序存储结构效率会高一些。
C C++最新链表（基础详解、实现、OJ笔试题），2024年最新写给程序员的Flutter详细教程
最新发布
2401_84976104的博客
05-15 684
链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。非连续的意思就是链表的每一部分可以在内存的任意一块区域存在，且这块区域的地址是随机的，所以一般用动态内存来开辟这块空间的地址。数据域和指针域，通过指针域即可访问其他结点的数据。
c++链表
2301_76461941的博客
02-14 813
c++链表
c++数据结构——链表
qq_35686734的博客
06-13 2万+
1.链表基础知识： 链表分类：单链表、双链表、循环链表 链表的存储：散乱分布，通过指针域的指针链接在一起 链表的定义：此处给出单链表的c++定义 struct ListNode { int val; // 节点上存储的元素 ListNode *next; // 指向下一个节点的指针 ListNode(int x) : val(x), next(NULL) {} // 节点的构造函数 }; 链表初始化及调用： ListNode* head = new ListNode(5);
c++链表（详解版）
热门推荐
slandarer的博客
06-13 21万+
在自学C++的时候，看到好多人都在提链表，于是就自学了一下，看了很多别人的文章，加入了一些自己的理解，做了一下总结
C++ vector的用法小结
09-04
`vector`在内存中是连续存储的，这使得它可以像数组一样高效地进行随机访问，同时还能像链表一样方便地插入和删除元素。 首先，`vector`的定义和初始化方式多种多样。最简单的定义方式是`vector<typeName> v1;`，这...
C/C++指针小结
09-05
《C/C++指针小结》 指针是C/C++编程中不可或缺的一部分，它具有强大的功能和灵活性，但同时也带来了复杂性。理解和掌握指针是深入学习这两种语言的关键。本文将围绕指针的四方面内容展开：指针的类型、指针所指向的...
C++课程信息管理系统链表STL版.pdf
11-27
完成该项目时，学生需要提交一个大作业报告，包含需求分析、系统分析与设计、程序设计与实现、系统测试和个人小结等部分。在报告中，学生需要详细描述代码的设计思路、关键知识点、功能模块，以及进行系统测试以验证...
画图板小结
08-12
标题“画图板小结”表明我们即将探讨的是一个与图形绘制工具相关的主题，可能是关于一个自定义的、开源的或者是教学性质的画图应用程序。这个工具可能具有基础的绘图功能，如选择颜色、线条粗细、形状绘制等，也可能...
java链表 个人总结
12-12
例如，在C++中，我们可以使用指针来创建链表；在Python中，有内置的list类型，但也可以自定义链表结构。理解了Java的链表，就能轻松理解其他语言中的链表实现，并进行跨语言的开发。 总的来说，理解和掌握Java链表...
C++算法学习二.链表
weixin_55605689的博客
12-21 1260
移除链表元素，采用虚拟头节点方法将指针指向删除节点的下一个指针域即可，不要忘记释放节点设计链表：首先定义链表节点的结构体，数据域，指针域，有参构造，删除节点，以及打印，加值删除值，反转链表：双指针方法实现，快指针指向头节点，慢指针指向空指针，注意断开连接时需要找个临时节点接入断开节点的下一个节点，每次两个指针向前移动。两两交换链表：其实就是模拟反转的过程，但是需要采用两个临时节点接入，而且注意顺序，循环条件的顺序也要注意，其他就是模拟一下链表的反转操作流程。
C++ 数据结构算法 学习笔记(3)-链表
2201_75704074的博客
04-07 483
链表是线性表的链式存储方式，逻辑上相邻的数据在计算机内的存储位置不必须相邻，那么 怎么表示逻辑上的相邻关系呢？可以给每个元素附加一个指针域，指向下一个元素的存储位 置。如图所示：从图中可以看出,每个结点包含两个域：数据域和指针域，指针域存储下一个结点的地址， 因此指针指向的类型也是结点类型。
链表C++详解（知识点+相关LeetCode题目）
qq_60831089的博客
09-18 362
主要阐述了数据结构中链表的相关知识，也包括了链表相关的经典力扣题目。
C++ 链表知识总结
crazyfox的博客
07-28 200
C++ 链表知识总结1、创建链表 1、创建链表 一般创建链表都会设置一个虚拟头节点，也叫做哨兵 创建链表需要一个头节点，一个当前节点，而头节点设置为哨兵的话，当前节点就可以直接初始化为头节点，最后返回哨兵的next即可，这样的做法可以简化代码，因为这样就不用当前处理当前节点为空节点的情况。 链接：https://www.nowcoder.com/questionTerminal/d8b6b4358f774294a89de2a6ac4d9337?answerType=1&f=discussion 来源
C++课程总结——链表
qq_55395656的博客
05-22 156
链表 什么是链表？ 举个例子，玩侦探游戏，首先给你一个线索，钥匙，这又指向下一个线索——你必须找到一个锁，找到锁以后，又指向下一个线索——锁是为了锁什么东西……最后找到出口，可以简单看成下图。 由此可见列表是由一个结构体数组组成的，有两个成员——1，value指这个节点本来存的值.2，next表示指向下一个节点的地址，链表最开头为"head"指向第一个节点的value，最后一个结点的next为"NULL"——空地址，链表结束，但也有循环列表最后节点指向第一个节点。 链表定义 str
C++学习———数据结构
JACKSONMHLK的博客
02-21 211
链表。 #include <iostream> using namespace std; class myLinkedList{ private: int _size; LinkedNode* _dummyHead; public: struct LinkedNode { int val; LinkedNode* next; LinkedNode(int val) : val(val), next(nullptr) {}
【leetcode学习日志day2】 JAVA与C++ null\NULL的区别|链表的用法 dummyHead
qq_43581709的博客
07-28 166
学习日志1忘记保存了 具体内容是C++数组长度的获得。vector获得长度的方法以及，vector的用法。 在JAVA与C++ 空字符写法不同 C++ ----------------------------------NULL java ----------------------------------null 在数据链表的使用中通常使用dummyHead dummyHead是自己单独定义的一个头结点，返回他的next那就是他的下一个节点就是我们要的链表了， curr是为了操作dummyHead的nex
C++ 链表
DevLe2010的博客
11-25 1108
关于的C++ 链表，是比较有趣的。其中要用到指针与结构体。现在带你快速学会链表。
C++链表的应用场景
08-13
- *1* *2* *3* [C++链表小结](https://blog.csdn.net/mxh3600/article/details/127323902)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值