链表的10个题目——第2周打卡

最新推荐文章于 2022-04-30 14:32:22 发布
最新推荐文章于 2022-04-30 14:32:22 发布
阅读量172 收藏 2
点赞数 3
分类专栏： 刷题 LeetCode 文章标签： 链表 算法 面试 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhanly19/article/details/109173722
版权

链表专题：

题目简介LeetCode题号
1-删除链表中的倒数第N个节点LeetCode第19题
2-删除链表中的节点LeetCode第237题
3-删除排序链表中的重复元素LeetCode第83题
4-旋转链表LeetCode第61题
5-两两交换链表中的节点LeetCode第24题
6-翻转链表LeetCode第206题
7-反转链表LeetCode第92题
8-相交链表LeetCode第160题
9-环形链表LeetCode第142题
10排序链表LeetCode第148题

链表的题目一定画图，通过画图确定指针的指向

首先记录一下我之前的一个误区：

在这里插入图片描述

1.删除链表中的倒数第N个节点-LeetCode第19题

题目描述：

在这里插入图片描述

题目分析：

单向链表只有后继指针，要删除某一个节点，就要找到该要删除节点的前一个节点。我们要删除倒数第N个节点，就要先找到倒数第N+1个节点。这个题目有一个要求：只能对链表遍历一遍，这样就不能先遍历一遍求链表的长度，再遍历一遍去找到倒数第N+1个节点。对于可能删除头节点的题目，或者头节点可能会变化的这类题目就有一个技巧：创建一个虚拟的头节点。创建一个虚拟的头节点的好处就是：虚拟节点一定不会被删除，那么这样的话我们就不用去处理头节点被删除的情况了，少了一些判断。这里用了一个双指针算法避免在删除倒数第N个节点的时候需要去遍历两遍。

双指针算法的做法有：

  1. 建立虚拟头结点指向头节点；
  2. 第一个指针first向后走N步；
  3. 再创建一个指针second指向虚拟头节点，first、second同时向后走，当第一个指针走到最后一个节点的时候，第二个指针就指向了倒数第N+1个位置；
  4. 删除的方式是第N+1的指针指向N节点的后一个节点。
    在这里插入图片描述
    在这里插入图片描述

代码：

在这里插入图片描述

/**
 * 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) {
        auto dummy = new ListNode(-1);
        dummy->next = head;
        auto first = dummy,second = dummy;
        while(n--) first = first->next;
        while(first->next)
        {
            first = first->next;
            second = second->next;
        }
        second->next = second->next->next;
        return dummy->next;
    }
};

2-删除链表中的节点 - LeetCode第237题

题目描述：

在这里插入图片描述
在这里插入图片描述

题目分析：

这个题目的思路非常的巧妙

  1. 看到题目传入的参数是ListNode* node，直接指向了要删除的结点，而我们在链表中删除某个节点的时候，一定要找被删除节点的前一个节点，这个题目没法这样做，换了一种思路；
  2. 首先把将要被删除节点的后一个结点覆盖将要被删除的结点（也就是用1去覆盖5）；
  3. 然后把将要被删除节点的后一个结点删除掉。
    在这里插入图片描述

代码：

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    void deleteNode(ListNode* node) {
        node->val = node->next->val;
        node->next = node->next->next;
    }
};

第二种解法：

上面是这个题的第一种解法，那么接下来的方法，我们从C++的角度出发去理解这个题目：首先node是一个指针，那么他肯定是指向某一段地址的开头，而且node是一个结构体类型的，一段是存值的，另一段是存地址的。也就是说下面两行代码实现实现的是把node->next里面的东西复制到node里面去：
在这里插入图片描述
*node表示是整个val和next上的值，这个是C++的特性，所以：上面的那两句话就可以用一句话来代替：

*（node）= *（node->next）;

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    void deleteNode(ListNode* node) {
        //node->val = node->next->val;//覆盖掉要删除的结点
        //node->next = node->next->next; //删除一个节点 
        *(node) = *(node->next);     
    }
};

3-删除排序链表中的重复元素 —LeetCode第83题

题目描述：

83题

题目分析：

链表题的一个思路是非常重要的，拿到链表的题目的话，先不要想着去写代码，而是先考虑思路。因为链表是排号数序的，所以相同的元素都是挨在一起的。并且第一个节点，头节点是不会被删除的，对于连续的元素的话，我们只保留第一个元素。

用一个指针遍历一遍这个链表

  1. 情况1：如果下一个点和当前点相同，则删掉下一个点；
  2. 情况2：如果下一个点和当前点不同，指针移到下一个点。

在这里插入图片描述

代码：

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        auto cur = head;
        while(cur)
        {
            if(cur->next && cur->val == cur->next->val)
                cur->next = cur->next->next;
            else cur = cur->next;
        }
        return head;
    }
};

4-旋转链表—LeetCode第61题

题目描述：

在这里插入图片描述

题目分析：

我感觉这个题目也是思路非常巧妙的，一个容易忽视的点就是这个 K 可能会很大，为了避免做无用功，我们一般先取余：
在这里插入图片描述
首先是尾部节点要指向原来的head节点；然后第倒数第K+1个节点指向空节点（这两个需要的点用双指针方法就可以找出来）；最后倒数第K个节点作为新的头节点。这个题目不需要虚拟头节点。需要步骤1、2、3：

  1. K%n；
  2. first指针从头往后走K步；
  3. second和first同时往后走，当first走到尾巴的时候，停止；（后面始终保持着相差K个数的）

代码：

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* rotateRight(ListNode* head, int k) {
        if(!head) return NULL;
        int n = 0;
        for(auto p = head;p;p = p->next) n++;
        k %= n;
        auto first = head,second = head;
        while(k--) first = first->next;
        //因为下面的fist还要往下走一步，所以这里判断的时候取得的是first->next不为空 
        while(first->next){  
            first = first->next;
            second = second->next;
        }
        first->next = head;
        head = second->next;
        second->next = NULL;
        return head;
    }
};

5-两两交换链表中的节点- LeetCode第24题

题目描述：

在这里插入图片描述

题目分析：

LeetCode第24题，两两交换链表中的节点是一个非常经典的一个题目，如果面试多了的话，就会发现这个是一个必然会问的题目。由于头节点是会变化的，所以说我们在这个题目中需要创建一个虚拟的头节点。这个题目的一个解法就是每次需要枚举一对节点，然后作如下的操作：创建指针p，a，b分别指向头节点和相邻的需要交换的两个节点。

  1. p->next = b；
  2. a->next = b->next;
  3. b-next = a;
  4. p = a 实际上这里因为有三个指针了，这四步不是那么的严格的顺序要求，顺序是可以变换的。
    这个题目是用p这个指针往后移动，带动着a、b往后移动
    在这里插入图片描述

代码：

在这里插入图片描述

/**
 * 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* swapPairs(ListNode* head) {
        auto dummy = new ListNode(-1);
        dummy->next = head;
        for(auto p = dummy;p->next && p->next->next;)
        {
            auto a = p->next,b = p->next->next;
            p->next = b;
            a->next = b->next;
            b->next = a;
            p = a; //如果不明白这个地方的话，就画画图看看          
        }
        return dummy->next;
    }
};

6-反转链表 - LeetCode第206题

题目描述：

在这里插入图片描述

题目分析：

这个题目是先用一个指针保存了一下第三个结点我们要做的就是中间的箭头翻转过来，让head指向5，让1指向空。在实现这个想法的时候，最重要的就是中间节点的指针的翻转，这里是用两个指针来实现的。
在这里插入图片描述
这个题目最重要的是要想明白各个指针是怎么指向的，以及如果判断结束，这个我认为是重点。

代码：

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(!head) return NULL;
        auto a = head,b = head->next;
        while(b)
        {
            auto c = b->next;
            b->next = a;
            a = b;
            b = c;
        }
        head->next = NULL;
        head = a;
        return head;
    }
};

总结一下上面的几个代码的话，几乎就是用两个或三个指针来完成的。

7-反转链表- LeetCode第92题

题目描述：

在这里插入图片描述

题目分析：

在这里插入图片描述

上面就是一个解题的思路，做这个题目的话就是分两步去做，首先是把m->n之间的节点反转过来，然后再把反转之后的一段节点插到原来的序列中去，但是需要提前找到a、m、n、c这是个节点。经过整数值m，走m-1步可以找到指针a；通过整数n走n步到达指针d，然后接着next就可以找到指针b、c。 这个题目头节点时可能会被反转，因为头节点可能会变化，所以这里搞一个虚拟的头节点。指针的设置如上面，这个指针如果整明白了，那么这个题目就会好做很多，但是那个指针指向那个节点一定一定要好好的盯着，很容易出错，思路上都是不难的。

代码：

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseBetween(ListNode* head, int m, int n) {
        if(m==n) return head;
        auto dummy = new ListNode(-1);
        dummy->next = head;
        auto a = dummy,d = dummy;
        for(int i = 0; i < m - 1; i++) a = a->next;
        for(int j = 0; j < n; j++) d = d->next;
        auto b = a->next,c = d->next;
        for(auto p = b,q = p->next;q != c;)
        {
            auto o = q->next;
            q->next = p;
            p = q;
            q = o;
        }
        b->next = c;
        a->next = d;
        return dummy->next;
    }
};


/**
//这个代码是指针换的之后的，自己写的
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseBetween(ListNode* head, int m, int n) {
        auto dummy = new ListNode(-1);
        dummy->next = head;
        auto a = dummy,c = dummy;
        for(int i = 0;i < m-1;i++) a = a->next;
        for(int j = 0;j < n; j++)  c = c->next;
        auto b = a->next,d = c->next;
        for(auto p = b, q = b->next;q != d;)
        {
            auto o = q->next;
            q->next = p;
            p = q;
            q = o;
        }
        a->next = c;
        b->next = d;
        return dummy->next;
    }
};

8-相交链表 - LeetCode第160题

题目描述：

160
在这里插入图片描述

题目分析：

题解的情况有两种：
在这里插入图片描述
这个题目的思路很巧妙，首先看算法的步骤：

  1. 用两个指针分别从两个链表头部开始扫描，每次分别走一步；
  2. 如果指针走到NULL，则从另一个链表头部开始走；
  3. 当两个指针相同时，
    （1） 如果指针不是NULL，则指针位置就是相遇点；
    （2） 如果指针是NULL，则两个链表不相交；
    （3） 访问链表的时间复杂度是o（n）

代码：

在这里插入图片描述

/**
 * 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) {
        auto p = headA,q = headB;
        while(p != q)
        {
            if(p) p = p->next;
            else p = headB;
            if(q) q = q->next;
            else q = headA;
        }
        return p;     
    }
};

题意很长，做起来也不是很容易，但是想到这个方法的话，就太容易了

9-环形链表 - LeetCode第142题

题目描述：

在这里插入图片描述
在这里插入图片描述

题目分析：

在这里插入图片描述
本题想象它是一个这样的形式，这个题目是快慢指针的一个经典题目，fast指针（红色）每次走两步，second指针（蓝色）每次走一步；当蓝色指针从a点走到b点的时候，它走过的距离是X，那么红色指针应该走的距离是2X，也就是从a点先走到b点，然后在这个圈上又走了X远的距离，我们假设红色指针在C’位置上，假设b点到C’位置的距离是y，那么我们在这个圆圈上找到对称的位置C，b到C的距离也是y，让蓝色指针从b到C点（走了y），那么红色指针要走2y，红蓝指针在C点相遇；相遇之后，把蓝颜色的指针放回到开头（此时红颜色依然在C点），这时候红色指针和蓝色指针每次走一步，然后当蓝颜色指针走到b的时候，红颜色也将走到b，即它们一定在b点相遇。
原因的话，我这么解释：红蓝指针在C点相遇之后，蓝色从a—>b走X到b，红色从C每次走一步，走距离X一定到达b，因为原来从b点出发走X步到了C’，那么现在从C出发（起点退后了y）走X应该到b

代码：

在这里插入图片描述

/**
 * 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) {
       auto fast = head,slow = head;
       while(fast){
           fast = fast->next;
           slow = slow->next;
           if(fast) fast = fast->next;
           else break;
           if(fast == slow)
           {
               slow = head;
               while(fast != slow)
               {
                   fast = fast->next;
                   slow = slow->next;
               }
               return slow;
           }
       }
       return NULL;
    }
};

个人觉得代码的难度在于判断条天上面。

10排序链表 - LeetCode第148题

题目描述：

在这里插入图片描述

题目分析：

题解：这个题目因为它有各种要求，时间复杂度是O(nlogn)，空间复杂度是常数(O(1))所以有很多不能用的方法，而是用了一个自底向上的归并排序。因为快速排序的话是要用递归的写法，递归的写法的话肯定是需要用到系统栈的，只要是用到系统栈的题目，如果是递归N层的，一般需要O(logn)空间，故快速排序的话，时间复杂度是满足要求的，但是空间复杂度是不满足要求的。同样的一般的归并排序，递归写法的话也是需要O(logn)空间复杂度的，也是不满足要求。所以这个题目只有一种写法，即自底向上的归并排序的写法，用一个循环的形式，这样的话就不会用到栈了。
自底向上的归并排序的算法：
在这里插入图片描述
在这里插入图片描述

代码：

/**
 * 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* sortList(ListNode* head) {
        int n = 0;
        for(auto p = head;p;p = p->next) n++;

        auto dummy = new ListNode(-1); //头节点可能会变，所以我们创建一个虚拟的头节点
        dummy->next = head;
        for(int i = 1;i < n; i *= 2) //每次隔得间隔
        {
            auto cur = dummy;

            for(int j = 0; j + i < n; j += i * 2)//枚举每一段
            {
                auto left = cur->next, right = cur->next;
                for(int k = 0;k < i; k++) right = right->next;
                //下面要进行归并
                int l = 0,r = 0;
                while(l < i && r < i && right)
                    if(left->val <= right->val)//经典的归并排序
                    {
                        cur->next = left;
                        cur = left;
                        left = left->next;
                        l++;
                    }
                    else//否则把右边放过来,cur始终指向尾部的意思
                    {
                        cur->next = right;
                        cur = right;
                        right = right->next;
                        r++;
                    }
                //下面将两段中没有循环的接起来
                while(l < i)
                {
                    cur->next = left;
                    cur = left;
                    left = left->next;
                    l++;
                }
                while(r < i && right)
                {
                    cur->next = right;
                    cur = right;
                    right = right->next;
                    r++;
                }
                cur->next = right;
            }
        }
        return dummy->next;
    }
};//这个题可以当作一个模版了
海棠未眠d
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构-单链表基本操作带图完整详解
oorik的博客
01-09 7096
1.什么是链表 链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指 针链接次序实现的。 2.为什么要使用链表 在未学习链表时，我们常用的存储数据的方式无非就是数组。使用数组存储数据的好处就是查询快，但是它的弊端也很明显： 1.使用前需声明数组的长度，一旦声明长度就不能更改 2.插入和删除操作需要移动大量的数组元素，效率慢 3. 只能存储一种类型的数据 顺序表就是在计算机中内存以数组的形式保存的线性表，因此这些弊端同理 而链表则可以实现以上这些数组所不具备的功
PHP获取链表中倒数第K个节点的方法
10-18
这样第二个指针就位于倒数第K个节点上。以下是实现此功能的PHP代码： ```php function FindKthToTail($head, $k){ if($head == NULL || $k == 0) { return NULL; } $pre = $head; // 前一个节点 $last = $...
【玩转链表①】单链表动图图解（超详解）
罅隙的博客
03-17 3654
全网最全面细致的单链表讲解
（六）双链表的结构和插入节点
weixin_30278311的博客
01-10 284
（六）双链表的结构和插入节点 双链表结构双链表算法之插入节点（尾部插入）双链表算法之插入节点（头部插入） 双链表结构   双链表并不是有两个链表，而是有两个遍历方向的链表，因此我们说的双链表其实是双向链表的简称。 单链表节点 = 有效数据 + 指针（指向下一个节点） 双链表节点 = 有效数据 + 两个指针（分别指向前一节点和后一节点） 1/* 2*双链表节点 3...
【数据结构从菜鸟到大牛】链表（画图教你手撕单链表）
K_04_10的博客
04-30 1358
📑前言 🌝顺序表优点 之前我们学习了顺序表，其本质就是数组 了解了顺序表是有自己的优点的： 物理空间连续 下标随机访问 我只要知道了首元素的地址，就可以访问顺序表的所有的元素 😅顺序表缺点 空间不够，需要扩容。扩容就有一定的性能消耗，其次一般扩容2倍，存在一些空间浪费 头部或者中间位置插入删除的效率低下，需要挪动---O(N)，尾插尾删比较容易 ⚒️改善方案 1.按需申请释放空间 需要一个就申请一个 ，哪一个不用了我们就释放哪一个 这样开辟的是一个一个的单独独立的空间，...
双链表-详细解释，图文并茂
07-14 2679
网上很多对双向链表解释的文章都是用这个结构： 它们的连接情况是这样的： 相当的不直观，今天我要从详细的地址出发来解释双向链表的原理。 现定义一个结构体如下： struct student { char name; struct student *next; struct student *prior; }; 现在有5个人A,B,C,D,E.这五个人构成的链表如下： 虚线部分为地址值，这个是为了描述方便随便写的值，在创建上述的链表时其实不用关心地址...
C语言实现输出链表中倒数第k个节点
09-04
然后，它使用两个指针 `pKnode` 和 `head` 分别遍历链表，先移动 `k` 步使 `pKnode` 指向倒数第k个节点的前一个节点，再同时移动两个指针直到 `head` 达到链表末尾。此时 `pKnode` 将指向倒数第k个节点。 在 `main`...
某小卡拉米第一次尝试：C语言链表（csdn）————程序.pdf
12-05
它使用一个二级指针`head`来接收链表的头部地址。当用户输入一个非零整数时，它会创建一个新的节点，并将其添加到链表的末尾。这里使用了`do...while`循环来持续读取输入，直到用户输入0为止。如果链表为空，新节点...
LeetCode刷题笔记——19. 删除链表的倒数第N个节点
12-21
给定一个单链表的头节点`head`和一个整数`n`，你需要删除链表中倒数第`n`个节点，并返回调整后的链表头节点。 ### 解题分析： #### 1. 单指针两次遍历法： 首先遍历整个链表，计算链表的长度`length`，然后再次...
php实现反转链表（链表题一定记得画图）（指向链表节点的指针本质就是一个记录地址的变量）（$p->next表示的是取p节点的next域里面的数值，next只是p的一个属性）...
weixin_33709609的博客
05-19 151
php实现反转链表（链表题一定记得画图）（指向链表节点的指针本质就是一个记录地址的变量）（$p->next表示的是取p节点的next域里面的数值，next只是p的一个属性） 一、总结 链表反转两种实现方式：a、头插法（遍历一遍链表即可实现链表反转） b、借助数组反转（遍历一遍链表将数值存在数组，反转数组，将数组里面的值尾插法插入链表，返回链表） 链表题一定记得画图 指向链表节点的指...
高斯克吕格投影中有关带号与经度的关系
皎若太阳升朝霞，灼若芙蕖出渌波
10-19 6562
我国规定：1:2.5万~1:50万地形图采用6度分带，中央经线与带号的关系：λ=n*6-3，n为带号，λ为中央经度。已知某地方的经度确定带号： 6度带 n=[l/6]+1，l代表经度;如：测得经度103，,故n=[103/6]+1=17+1=18。 1:5000、1:1万采用3度分带，中央经线与带号的关系：λ=n*3，n为带号，λ为中央经度。已知某地方的经度确定带号： 3度带 n=[（l-1.5
链表:画图说明问题-
zhang_yin_liang的博客
07-24 1871
1、单向链表 2、双向链表 3、循环链表 链表的逆序函数（相当于把链表重新创建一次，但是要注意保存好下一个指针，这是头插法） node*reverse_node(node *head) { node*record, *current;   if(head== NULL || head->next == NULL) returnhead;   current= head->ne
什么是链表？（图解）
热门推荐
十二匹的博客
09-09 4万+
一：链表是什么 1、链表是物理存储单元上非连续的、非顺序的存储结构，数据元素的逻辑顺序是通过链表的指针地址实现，有一系列结点（地址）组成，结点可动态的生成。 2、结点包括两个部分：（1）存储数据元素的数据域（内存空间），（2）存储指向下一个结点地址的指针域。 3、相对于线性表顺序结构，操作复杂。 4.链表分为 （1）单链表 （2）双链表 （3）单向循环链表 （4）双向循环链表 二：...
数据结构与算法之对于链表数据结构的理解
weixin_52755699的博客
03-14 267
因为自己是个nt所以要做保姆级别的笔记以后才能看懂 建立链表的两种方法： 尾插法： 非循环部分的理解顺序：首先定义三个链表节点指针变量，头尾p：LNode *head,*tail,*p;因为一开始只打算设置一个空结点，所以既是头又是尾，要给他开辟空间：head = tail = (LNode *)malloc(sizeof(Lnode));tail的next属性要初始化所以先指向空：tail->next=NULL; 循环部分的理解顺序：p作为要插入的结点需要先开辟空间p=(LNode *)mallo
【数据结构】单链表超详细解析 | 从零开始步步解读 | 画图理解
有道无术, 术尚可求。有术无道, 止于术。
11-03 2062
本章节将对链表的概念进行介绍，着重讲解单顺序表。对常用的接口函数进行一个个讲解，并进行解析，单链表表讲解部分将从零实现常见单链表接口函数。
数据结构之单链表的增删查改等操作画图详解
小赵小赵福星高照的博客
08-05 2439
单链表 文章目录单链表链表的概念及其结构概念结构链表的实现开辟一个新结点链表的销毁打印链表单链表的尾插单链表的头插单链表的头删单链表的尾删找到单链表中的一个结点在pos位置后插入结点在pos位置前插入一个结点pos位置后删除结点pos位置删除结点返回链表大小判断链表是否为空源代码SList.h(单链表结构及其函数的声明)SList.c(单链表函数的实现)test.c(单链表功能的测试) 为什么有了顺序表，还需要有链表这样的数据结构呢？ 顺序表存在的问题： 中间或者头部插入删除，需要挪动数据时间复杂度为
链表综合算法设计——校园人事信息系统
最新发布
10-12
校园人事信息系统中，可以使用链表来存储员工的信息。每个员工可以用一个结构体来表示，包含姓名、工号、职位、工资等信息。可以使用单向链表或双向链表来实现员工信息的存储和管理。具体实现时，可以设计如下几个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值