链表模块练习

最新推荐文章于 2024-07-17 12:13:29 发布
最新推荐文章于 2024-07-17 12:13:29 发布
阅读量1.1k 收藏 26
点赞数 43
文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45101231/article/details/139308332
版权

203. 移除链表元素

题目介绍：

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

示例 1:
在这里插入图片描述

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

示例 2:

输入：head = [], val = 1
输出：[]

示例 3:

输入：head = [7,7,7,7], val = 7
输出：[]

提示：
列表中的节点数目在范围 [0, 10^4] 内
1 <= Node.val <= 50
0 <= val <= 50

思路：

此类题型可以创建一个虚拟头结点指向链表的头结点，这样可以避免讨论需要移除的结点是不是头结点，此外由于C++没有内存回收机制，所以需要手动清除。
具体代码如下：

/**
 * 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* temp = cur->next ;        //临时结点保存cur->next,用于释放内存
                cur->next = cur->next->next  ;      
                delete temp ; 
                temp = NULL ; 
            }else{
                cur = cur->next ;
            }
        }

        head = dummyHead->next ; 
        delete dummyHead ;      //删除虚拟头结点
        return head ;
    }
};

707. 设计链表

题目介绍：

你可以选择使用单链表或者双链表，设计并实现自己的链表。
单链表中的节点应该具备两个属性：val 和 next 。val 是当前节点的值，next 是指向下一个节点的指针/引用。
如果是双向链表，则还需要属性 prev 以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。
实现 MyLinkedList 类：
MyLinkedList() 初始化 MyLinkedList 对象。
int get(int index) 获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1 。
void addAtHead(int val) 将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。
void addAtTail(int val) 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
void addAtIndex(int index, int val) 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。如果 index 比长度更大，该节点将 不会插入 到链表中。
void deleteAtIndex(int index) 如果下标有效，则删除链表中下标为 index 的节点。

示例 1:

输入
["MyLinkedList", "addAtHead", "addAtTail", "addAtIndex", "get", "deleteAtIndex", "get"]
[[], [1], [3], [1, 2], [1], [1], [1]]
输出
[null, null, null, null, 2, null, 3]

解释
MyLinkedList myLinkedList = new MyLinkedList();
myLinkedList.addAtHead(1);
myLinkedList.addAtTail(3);
myLinkedList.addAtIndex(1, 2);    // 链表变为 1->2->3
myLinkedList.get(1);              // 返回 2
myLinkedList.deleteAtIndex(1);    // 现在，链表变为 1->3
myLinkedList.get(1);              // 返回 3

提示：
0 <= index, val <= 1000
请不要使用内置的 LinkedList 库。
调用 get、addAtHead、addAtTail、addAtIndex 和 deleteAtIndex 的次数不超过 2000 。

思路：

考察链表的创建等常规操作，有助于熟悉链表。
具体代码如下：

class MyLinkedList {
public:
    struct LinkedNode{
        //定义链表结点结构
        int val ; 
        LinkedNode* next ; 
        LinkedNode(int val ): val(val),next(NULL){}  ;
    };
    //构造函数
    MyLinkedList() {
        _size = 0 ; 
        _dummyHead = new LinkedNode(0) ; 
    }
    //获取指定索引的结点的值
    int get(int index) {
        if( index > _size -1 || index < 0 )  return -1 ;    //当索引为负数或者索引大于链表节点数-1 ，则下标无效
        LinkedNode* cur = _dummyHead->next ; 
        while( index-- ){
            cur  = cur->next ; 
        }
        return cur->val ; 
    }
    //在链表最前端添加结点
    void addAtHead(int val) {
        LinkedNode* newNode = new LinkedNode(val) ; //创建新结点并赋值val
        newNode->next = _dummyHead->next ;  //需要先将新结点指向头结点，若先将虚拟头结点指向新结点，将找不到头结点
        _dummyHead->next = newNode ; 
        _size++ ;       //链表结点数+1
    }
    //在链表最后面添加结点
    void addAtTail(int val) {
        LinkedNode* newNode = new LinkedNode(val) ; 
        LinkedNode* cur = _dummyHead ;
        while( cur->next != NULL ){
            cur = cur->next ; 
        }
        cur->next = newNode ; 
        _size++ ; 
    }
    //插入新结点到链表中下标为 index 的节点之前
    void addAtIndex(int index, int val) {
        if( index > _size) return ; 
        if( index < 0 )  index = 0 ;
        LinkedNode* newNode = new LinkedNode(val) ; 
        LinkedNode* cur = _dummyHead ;
        while( index-- ){
            cur = cur->next ;
        }
        newNode->next = cur->next ; 
        cur->next = newNode ;
        _size++  ;
    }
    //如果下标有效，则删除链表中下标为 index 的节点。
    void deleteAtIndex(int index) {
        if(index < 0 || index > _size - 1 ) return ; 
        LinkedNode* cur = _dummyHead ;
        while( index-- ){
            cur = cur->next ;
        }
        LinkedNode* tem = cur->next ; 
        cur->next = cur->next->next ; 
        delete tem ; 
        tem = NULL ; 
        --_size ;
    }

    //打印链表
    void printLinkedList(){
        LinkedNode* cur = _dummyHead ; 
        while( cur->next != NULL ){
            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);
 */

206. 反转链表

题目介绍：

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

示例 1:
在这里插入图片描述

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

示例 2:
在这里插入图片描述

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

示例 3:

输入：head = []
输出：[]

提示：
链表中节点的数目范围是 [0, 5000]
-5000 <= Node.val <= 5000

思路：

使用双指针，慢指针指向空，快指针指向头结点，然后循环转向即可，需注意先保存好下一个结点的地址，否则结点指向发生改变后无法找到下一个结点的地址。
具体代码如下：

/**
 * 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* reverseList(ListNode* head) {
        ListNode* cur = head ;  //创建临时结点遍历链表
        ListNode* tem ;     //保存cur的下一个结点
        ListNode* pre = NULL ; 
        while( cur ){
            tem = cur->next ; 
            cur->next = pre ; 
            pre = cur ;
            cur = tem ; 
        }

        return pre ; 
    }
};

24. 两两交换链表中的节点

题目介绍：

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

示例 1:
在这里插入图片描述

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

示例 2:

输入：head = []
输出：[]

示例 3:

输入：head = [1]
输出：[1]

提示：
链表中节点的数目在范围 [0, 100] 内
0 <= Node.val <= 100

思路：

每两个结点之间进行交换，需要注意的是：
提前保存本轮交换的第一个结点以及下一轮进行交换的第一个结点
交换时候的步骤问题
循环判断条件：后面的两个结点都存在时才可以交换
具体代码如下：

/**
 * 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) {
        ListNode* dummyHead = new ListNode(0) ;         //建立虚拟头结点
        dummyHead->next = head ;    
        ListNode* cur = dummyHead ;         //建立临时结点指向虚拟头结点，遍历链表
        while( cur->next != NULL && cur->next->next != NULL )   //当后面的两个结点都存在时才可以做交换
        {
            ListNode* temp1 = cur->next ;   //临时保存下一个结点
            ListNode* temp2 = cur->next->next->next ;   //临时保存下一次做交换时的第一个结点
            //开始交换
            cur->next = cur->next->next ; 
            cur->next->next = temp1 ; 
            cur = temp1 ;       //cur后移两位
            cur->next = temp2 ;  
        }
        ListNode* result = dummyHead->next ;    
        delete dummyHead ;
        return result ;
    }
};

19. 删除链表的倒数第 N 个结点

题目介绍：

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

示例 1:
在这里插入图片描述

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

示例 2:

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

示例 3:

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

提示：
链表中结点的数目为 sz
1 <= sz <= 30
0 <= Node.val <= 100
1 <= n <= sz

思路：

可以使用双指针思想，快慢指针初始时都指向虚拟头结点，先让快指针向后移动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) {
        ListNode* dummyHead = new ListNode(0) ; 
        dummyHead->next = head ; 
        ListNode* fast = dummyHead ;
        ListNode* slow = dummyHead ;
        //fast先向后移动n个结点
        while(n--){
            fast = fast->next ;
        }
        //两个指针同时向后移动，直至fast到达最后一个结点
        while( fast->next != NULL ){
            fast = fast->next ; 
            slow = slow->next ; 
        }
        //此时的慢指针就是需要删除的结点的前一个结点
        ListNode* temp = slow->next ; 
        slow->next = slow->next->next ;
        delete temp ;
        temp = NULL ; 

        ListNode* result = dummyHead->next ; 
        delete dummyHead ; 
        return result ; 
    }
};

160. 相交链表

题目介绍：

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。
图示两个链表在节点 c1 开始相交：在这里插入图片描述题目数据 保证 整个链式结构中不存在环。
注意，函数返回结果后，链表必须 保持其原始结构 。
自定义评测：
评测系统 的输入如下（你设计的程序 不适用 此输入）：
intersectVal - 相交的起始节点的值。如果不存在相交节点，这一值为 0
listA - 第一个链表
listB - 第二个链表
skipA - 在 listA 中（从头节点开始）跳到交叉节点的节点数
skipB - 在 listB 中（从头节点开始）跳到交叉节点的节点数
评测系统将根据这些输入创建链式数据结构，并将两个头节点 headA 和 headB 传递给你的程序。如果程序能够正确返回相交节点，那么你的解决方案将被 视作正确答案 。

示例 1:
在这里插入图片描述

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at '8'
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,6,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
— 请注意相交节点的值不为 1，因为在链表 A 和链表 B 之中值为 1 的节点 (A 中第二个节点和 B 中第三个节点) 是不同的节点。换句话说，它们在内存中指向两个不同的位置，而链表 A 和链表 B 中值为 8 的节点 (A 中第三个节点，B 中第四个节点) 在内存中指向相同的位置。

示例 2:
在这里插入图片描述

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

示例 3:
在这里插入图片描述

输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。
由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
这两个链表不相交，因此返回 null 。

提示：
listA 中节点数目为 m
listB 中节点数目为 n
1 <= m, n <= 3 * 104
1 <= Node.val <= 105
0 <= skipA <= m
0 <= skipB <= n
如果 listA 和 listB 没有交点，intersectVal 为 0
如果 listA 和 listB 有交点，intersectVal == listA[skipA] == listB[skipB]

思路：

1、获取两条链表的长度以及长度差
2、若两条链表有相交，那必然会存在一个结点相同且相交后的长度相同，故先长度更长的链表先将指针向后移动n个结点（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) {
        ListNode* curA = headA ;
        ListNode* curB = headB ;
        int lengthA = 0 , lengthB = 0 ;
        //获取A、B链表的长度
        while( curA ){
            curA = curA->next ; 
            lengthA++ ;
        }
        while( curB ){
            curB = curB->next ; 
            lengthB++ ;
        }
        //将curA 、curB重新指向头结点
        curA = headA ;
        curB = headB ;
        //保证A永远是更长的那个链表
        if(lengthA < lengthB){
            swap(lengthA ,lengthB) ;
            swap(curA,curB) ; 
        }
        //获取两个链表的长度差
        int gap =lengthA-lengthB ;
        //保证更长的链表的剩余长度与另一个链表的长度相同
        while( gap-- ){
            curA = curA->next ;
        }
        //判断两条链表是否存在相同的结点
        while( curA ){
            if(curA == curB)    return curA ;
            curA = curA->next ;
            curB = curB->next ; 
        }

        return NULL ;
    }
};

142. 环形链表 II

题目介绍：

给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。
不允许修改 链表。

示例 1:
在这里插入图片描述

输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2:
在这里插入图片描述

输入：head = [1,2], pos = 0
输出：返回索引为 0 的链表节点
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3:
在这里插入图片描述

输入：head = [1], pos = -1
输出：返回 null
解释：链表中没有环。

提示：
链表中节点的数目范围在范围 [0, 10^4] 内
-10^5 <= Node.val <= 10^5
pos 的值为 -1 或者链表中的一个有效索引

思路：

本题方法并不困难，主要还是数学思维，这题可以使用快慢指针，快指针每次移动两个结点，慢指针每次移动一个结点。
如果链表有环，那么快指针与慢指针一定会在环内相遇，且慢指针一定还是在环内走第一圈。
故在快慢指针相遇后，再创建另一个指针从头结点出发，新建指针与慢指针同时移动，每次只移动一个结点，最后两个指针相遇的点就是入环点。
具体代码如下：

/**
 * 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 )
        {
            if(fast->next == NULL) return NULL ;
            slow = slow->next ; 
            fast = fast->next->next ; 
            if( fast == slow ){
                //此时相遇了
                ListNode* ptr = head ; 
                while( ptr != slow ){
                    slow = slow->next ;
                    ptr = ptr->next ; 
                }
                return ptr ; 
            }
        }

        return NULL ; 
    }
};
Duang呀
关注
  • 43
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Qt基础练习，QGraphics制作可视化链表
08-25
在本文中，我们将深入探讨如何使用Qt框架中的QGraphics模块来创建一个可视化的链表。Qt是一个跨平台的应用程序开发框架，广泛应用于图形用户界面（GUI）和非GUI应用程序的开发。QGraphics模块提供了一组高级图形视图...
DataStructures:练习堆栈、队列和链表
07-01
例如，你可以创建一个名为`dataStructures.js`的模块，分别实现堆栈、队列和链表类，然后在其他项目中通过`require()`导入并使用。同时，由于Node.js是异步I/O驱动的，这些数据结构在处理异步操作的顺序和管理回调...
static链表模块练习
gcqTextCs的博客
09-22 271
list.hextern int insert(int val); extern int printf(); extern int new(); extern int del(); extern int destory(); list.c#include<stdlib.h> typedef struct node * Node; static Node head; struct node{
链表知识及编程练习总结
热门推荐
张彦峰的博客
10-24 1万+
了解链表结构，并在单链表或双链表中实现遍历、插入和删除以及分析在单链表或双链表中的各种操作的复杂度，同时附上相关面试考点的基本分类试题库（反转链表、链表中环的检测、链表中环的入口点、删除链表中倒数第K个节点、两个链表的第一个公共节点、链表的中间节点、合并两个有序链表、删除链表中的重复元素、排序链表、K 个一组翻转链表、旋转链表、分隔链表、奇偶链表、合并k个排序链表、链表相加、回文链表判定、回文链表重排、交换相邻节点、删除指定元素、反转链表指定部分、存在回文链表、链表最长递增子序列）
C语言链表详解
暴力扬
03-02 3556
什么是链表，如何通过结构体构成链表，单向链表的静态建立，动态建立，结点数据的输出、删除与插入
顺序表和链表2
lcc11223的博客
03-22 815
3、链表： 3.1 、链表的概念及结构 ： 概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 、 数据结构中： 在链表中，只需要知道第一个节点的位置，就可以通过指针把整个链表都进行访问，不存在扩容的代价，不存在空间的浪费，因为是按需索取空 间，在顺序表中的原地扩容时，一般也是直接扩容到原来大小的1.5或2倍，扩容时，如果后面的空间足够大，就会直接在原地进行扩容，也可能 会造成空间的浪费，除此之外，顺序表原地扩容时，.
python链表_python实现链表
weixin_39799825的博客
11-23 75
广告关闭腾讯云11.11云上盛惠 ，精选热门产品助力上云，云服务器首年88元起，买的越多返的越多，最高返5000元！遍历整个链表 cur = self._head if cur == none: return count = 0 while cur ! = none:print(cur.elem,end= ) cur = cur.next count += 1 return count defad...
LeetCode/NowCoder-链表经典算法OJ练习3
Become Mad的博客
05-21 1295
数据结构的学习离不开刷题，题刷的够多才能有题感，才能有把握，这个系列专门更新数据结构相关的习题、面试题，欢迎大家来学习~
实验四：用可重用的链表模块来实现命令行菜单小程序V2.5
飞奔的蜗牛
11-09 306
“软件工程（C编码实践篇）”实验报告 实验四：用可重用的链表模块来实现命令行菜单小程序V2.5 网易云课堂昵称：Arjen0130 《软件工程（C编码实践篇）》MOOC课程作业http://mooc.study.163.com/course/USTC-1000002006 GitHub仓库：https://github.com/Arjen0130/AdvancedSoftw
python中链表_python中的链表
weixin_39953673的博客
11-21 180
广告关闭腾讯云11.11云上盛惠 ，精选热门产品助力上云，云服务器首年88元起，买的越多返的越多，最高返5000元！在python中使用链接列表的最简单方法是什么？ 在方案中，链接列表具有一些很好的属性，例如固定顺序的连接，并且能够引用它们的不同部分...我正在开发一个项目，我操作了很多元素的排序列表，我需要能够快速删除任何这些元素。 由于我不需要任何索引，我认为双链表结构最好。 我找不到任何好的...
数据结构-链表2
qq_40844674的博客
03-24 294
part 4 其他链表 1 循环链表 1.1 概念 单向链表：表中最后一个结点的指针域指向空 循环链表：表中最后一个结点的指针域指向头结点或者首元结点 1.1.1 带头结点的循环链表整表创建源代码修改即可 1.1.2 只有头指针的循环链表创建 (1)算法步骤 （1）定义头指针 *l，尾结点指针p，以及新节点指针s （2）计数器j从1开始 （2）循环n次 第一步:申请新节点，给到s 第二步：设置数据域数据 第三步：...
链表在Scratch创作中的初步应用.pdf
03-01
4. 学生模仿创作，根据教师的指导和范例，设计自己的作品，如角色在思考“今天做什么”等问题，从而练习链表的获取、存储和输出数据。 5. 通过学生的作品展示，观察他们是否成功地应用了链表和相关的编程逻辑。 ...
基于C语言和链表结构的学生成绩管理系统，具有文件输出特性
08-04
在IT领域，尤其是在软件开发中，使用C语言和链表数据结构来构建系统是一种常见的实践。...对于初学者来说，这是一个很好的练习，可以提高编程技能；对于有经验的程序员，它可以作为快速开发小型数据库应用的一个起点。
C学生管理系统通用链表
04-26
`list.h`头文件则可能定义了链表相关的数据结构和函数声明，供其他模块调用。 `showview.c`文件负责显示信息，这可能是系统的核心交互部分，它实现了界面的展示和用户输入的处理。可能包含函数来打印链表中的数据，...
【Java--数据结构】二叉树
2301_80898480的博客
07-16 1059
如有错误，欢迎指出~
数据结构第32节 无锁编程
最新发布
hummhumm的专栏
07-17 836
在Java中，无锁编程是一种在多线程环境下避免使用传统锁机制（如关键字或）的技术。这种技术可以提高程序的并发性能，尤其是在高并发场景下，因为它减少了锁的竞争和上下文切换的开销。
常见排序算法总结
mydaily_的博客
07-16 827
大概是因为插入排序没预处理，极端情况可能让一个很小很右的数一直比比比比比，比到最开头，浪费比较次数。某种情况比计数排序好，因为数字，如果按照普通十进制理解，则只需准备10个不同数字的桶就好了！整体的quickSort函数swap后，再进行partition，划分三部分后，所以这种不基于比较的算法应用范围很局限，大部分情况下，不如之前的所有比较算法！前提得知道空间范围，比如人的年龄，正数[0-200]，否则内存爆炸！间隔分组，且分组间隔依次减半，每次分组后，每个组内排序都是插入排序。
【数据结构】栈和队列
奋斗的小羊的博客
07-12 1892
栈超超超详解

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值