探索数据结构之精髓：单链表解密

最新推荐文章于 2024-07-14 01:31:01 发布
置顶 最新推荐文章于 2024-07-14 01:31:01 发布
阅读量7.2w 收藏 7
点赞数 7
分类专栏： 数据结构算法之路 文章标签： 数据结构 算法 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63325890/article/details/130175880
版权

文章目录

1. 前言

上一篇文章说过顺序表（线性表的顺序存储）的最大缺点是，在插入和删除操作可能会移动大量元素，去保证元素之间的内存不能有空隙，而这，会导致程序的执行效率变低。

那么如何弥补这个缺点呢？这就涉及到了今天的内容：采用线性表的链式存储来保存数据元素。

线性表的链式存储也非常基础和常用，它不需要使用连续的内存空间。从名字可以得知，所谓链式存储，是通过“链（指针）”建立元素之间的关系，保证元素之间像一条线一样按顺序排列。这样，在插入和删除元素的时候，就不需要为了保证内存空间的连续性，去进行数据元素的大量迁移，只需要修改指向元素的指针即可。

用链式存储实现的线性表叫做链表，链表比顺序表稍复杂一些。它可以具体分为单链表、双链表、循环链表、静态链表这四种。今天先讲解单链表。

2. 单链表的特点

顺序表与单链表保存数据元素的区别如下：

在这里插入图片描述

可以看到，左侧顺序表中存储的元素在内存中紧密相连。其中，每个存储数据元素的内存空间被称为一个节点。

而右侧单链表中存储的元素在内存中并不需要紧密相连。在单链表中，每个节点不但用于存放一个数据元素（数据域），还要额外存放一个用于指向后继节点的指针也称后继指针（指针域），最后一个节点的指针域指向 nullptr。

单链表数据存储描述图如下：

在这里插入图片描述

在书写单链表相关代码时，有时为了更方便更统一的对链表进行操作，会在单链表的第一个节点之前再增设一个和其他节点类型相同的节点，称为头结点（也称哨兵节点）。

头结点的数据域可以不存储任何信息，也可以存储比如单链表长度等额外信息。头结点的指针域指向第一个节点。注意，头结点始终位于任何其他节点之前，就算我们需要向链表的首部插入节点，那插入的节点也要位于头结点之后。

带头结点的单链表数据存储描述图如下：

在这里插入图片描述

那不带头结点的单链表，和带头结点的单链表有什么不同呢？我们来对比一下。

初始化时：不带头结点的单链表（有时也称不带头链表）在初始化时不创建任何节点，而带头结点的单链表（有时也称带头链表）在初始化时要把头结点创建出来（可以把该头结点看成是第 0 个节点）。

实际元素数据的位置：带头结点的单链表中的头节点不存放实际元素数据。头节点之后的下一个节点才开始存放数据。

代码操作：不带头结点的单链表在编写基本操作代码（比如插入、删除等）时更繁琐，往往需要对第一个或者最后一个数据节点进行单独的处理。

在书写单链表的基本操作代码时，多数情况下，我们都会使用带头结点的代码实现方式。

3. 单链表的基础操作

了解整体框架之后，下面我们就来看一看单链表的具体实现代码，包括基本框架、插入、删除、获取以及其它的一些常用操作。

🍑 接口总览

单链表是由一个个的节点组成，所以，我们首先要定义出单个节点。

//单链表中每个节点的定义
template<class T> //T代表数据元素的类型
struct Node
{
	T _data;    //数据域，存放数据元素
	Node<T>* _next;  //指针域，指向下一个同类型（和本节点类型相同）节点
};

然后把单链表相关的类的基本框架实现出来。

//单链表的定义
template<class T>
class LinkList
{
public:
    //构造函数
    LinkList();      

    //析构函数
    ~LinkList();     
public:
    //在第i个位置插入指定元素e
    bool ListInsert(int i, const T& e);  

    //优化插入操作
    bool ListInsert2(int i, const T& e);
    void InsertNode(Node<T>* cur, const T& e);

    //删除第i个位置的元素
    bool ListDelete(int i);  

    //优化删除操作
    bool ListDelete2(int i);
    void DeleteNode(Node<T>* pdel);

    //获得第i个位置的元素值
    bool GetElem(int i, T& e);      

    //按元素值查找其在单链表中第一次出现的位置
    int  LocateElem(const T& e);         

    //输出单链表中的所有元素
    void DispList();    

    //获取单链表的长度
    int  ListLength();    

    //判断单链表是否为空
    bool Empty();    

    //翻转单链表
    void ReverseList();                  

private:
    Node<T>* _head; //头指针（指向链表第一个节点的指针, 如果链表有头结点则指向头结点）
    int _length; //单链表当前长度（当前有几个元素）
};

🍑 初始化操作

通过构造函数对单链表进行初始化

代码如下：

//通过构造函数对单链表进行初始化
template <class T>
LinkList<T>::LinkList()
{
    _head = new Node<T>; //先创建一个头结点
    _head->_next = nullptr;
    _length = 0;  //头结点不计入单链表的长度
}

在上面的 LinkList 类模板的构造函数中，通过 new 创建了一个头结点。

在 main 主函数中，加入如下代码创建一个单链表对象。

LinkList<int> sl;

🍑 插入操作

如果我们想在单链表的第 i 个位置插入指定的元素（也可以称为插入指定的节点），那么只需要找到单链表中的第 i-1 个节点并将新节点插入该节点之后即可。

这里要注意，单链表中的位置编号从 1 开始，对于带头节点的单链表，我们不计算这个头节点的。

单看上面这段话有些绕，我们看一下把元素 a5 插入到单链表第 2 个位置前后对比图：

在这里插入图片描述

代码如下：

template<class T>
bool LinkList<T>::ListInsert(int i, const T& e)
{
    //判断插入位置i是否合法，i的合法值应该是1到length+1之间
    if (i < 1 || i >(_length + 1)) {
        cout << "元素" << e << "插入的位置" << i << "不合法，合法的位置是1到" << _length + 1 << "之间" << endl;
        return false; //插入失败
    }

    Node<T>* cur = _head;

    //整个for循环用于找到第i-1个节点
    for (int j = 0; j < (i - 1); ++j) //j从0开始，表示cur刚开始指向的是第0个节点（也就是头结点）
    { 
        cur = cur->_next;
    }

    //当循环结束以后, cur指向插入位置的前一个位置
    Node<T>* node = new Node<T>; //new一个新节点
    node->_data = e;
    node->_next = cur->_next; //让新节点链上后续链表，因为cur->_next指向后续的链表节点 
    cur->_next = node; //让当前位置链上新节点，因为node指向新节点

    cout << "成功在位置为" << i << "处插入元素" << e << endl;  
    _length++; //实际表长+1  

    return true; //插入成功
}

上面的代码中，新节点的创建以及修改新老节点的指向，那么这些行对应的节点指向示意图要怎么画呢？

其实很简单，如下图所示：

在这里插入图片描述

我们可以给出一组数据测试一下：

在这里插入图片描述

🍅 优化操作

我们分析一下插入操作的时间复杂度。这里只需要关注 for 循环的执行次数与问题规模 n 的关系，问题规模 n 在这里指的是单链表当前长度 _length。

  • 如果将元素插入到单链表的开头（位置 1），则 for 循环一次都不会执行，这是最好情况时间复杂度 O(1)。
  • 如果将元素插入到单链表的末尾，并且假设单链表中已经有其他元素（非空），则 for 循环会循环 n-1 次，这是最坏情况时间复杂度 O(n)。
  • 平均情况时间复杂度其实在顺序表中已经做过很详细的分析，这里很类似，平均情况时间复杂度为 O(n)，时间开销主要源于插入位置的寻找。

另外，在实际的应用中，往往也会涉及到向某个已知节点之前插入一个新节点的情况。传统的做法是必须要利用头指针 _head 从前向后找到该已知节点的前趋节点。

在上面的图中，要将 a5 插入到 a2 之前必须要先从前向后找到 a1 节点，算法的平均情况时间复杂度为 O(n)。

那有没有什么更好的方法呢？

  • 将新节点 a5 插入到 a2 节点之后（a2 节点是已知的无需查找）。
  • 将 a2 和 a5 两个节点的数据域中的元素值互换。

如下图所示：

在这里插入图片描述

最终也可以达到将 a5 插入到 a2 之前的效果，而且这样修改后的算法时间复杂度为 O(1)。

代码如下：

//在节点cur之前插入新节点，新节点数据域元素值为e
template<typename T>
void LinkList<T>::InsertNode(Node<T>* cur, const T& e)
{
    Node<T>* newNode = new Node<T>; //new一个新节点
    newNode->_next = cur->_next; //让新节点链上cur后面的链表
    cur->_next = newNode; //让cur链上新节点

    T tmp = cur->_data; //先保存cur节点中的数据
    cur->_data = e; //再把cur节点中的数据修改为e
    newNode->_data = tmp; //最后再把新节点中的数据修改为cur事先保存好的数据
    
    _length++; //实际表长+1  
}

//查找插入位置的节点
template<class T>
bool LinkList<T>::ListInsert2(int i, const T& e)
{
    //判断插入位置i是否合法，i的合法值应该是1到length+1之间
    if (i < 1 || i >(_length + 1)) {
        cout << "元素" << e << "插入的位置" << i << "不合法，合法的位置是1到" << _length + 1 << "之间" << endl;
        return false; //插入失败
    }

    Node<T>* cur = _head;

    //整个for循环用于找到第i个节点
    for (int j = 0; j < i; ++j) //j从0开始，表示cur刚开始指向的是第0个节点（也就是头结点）
    {
        cur = cur->_next;
    }

    //当循环结束以后, cur指向插入位置
    InsertNode(cur, e);
    return true; //插入成功
}

我们可以给出一组数据测试一下：

在这里插入图片描述

注意，上面这种方法必须提前知道插入位置节点的地址，所以重新写了一个 Insert 函数用来查找 i 位置的节点。

最后，如果需要频繁的向单链表的末尾插入新节点，从算法执行所耗费时间的角度去看，每次用 for 循环从前向后寻找插入位置的做法并不好。

我们可以考虑引入一个表尾指针，这个指针在单链表为空时，会指向头结点，在单链表非空时，要注意始终保持其指向最后一个节点。

这样，通过表尾指针在单链表的末尾插入新节点就会变得非常容易了。

🍑 删除操作

关于删除操作，如果想删除单链表的第 i 个位置的元素，那只需要找到单链表中的第 i-1 个节点，并将其指针域指向第 i+1 个节点，同时释放第 i 个节点所占的内存，就可以了。

代码如下：

//删除第i个位置的元素
template<class T>
bool LinkList<T>::ListDelete(int i)
{
    if (_length < 1)
    {
        cout << "当前单链表为空，不能删除任何数据!" << endl;
        return false;
    }
    if (i < 1 || i > _length)
    {
        cout << "删除的位置" << i << "不合法，合法的位置是1到" << _length << "之间" << endl;
        return false;
    }

    Node<T>* cur = _head; //cur指向头节点

    //整个for循环用于找到第i-1个节点
    for (int j = 0; j < (i - 1); ++j) //j从0开始，表示cur刚开始指向的是第0个节点（头结点）
    {
        cur = cur->_next; //cur会找到当前要删除的位置所代表的节点的前一个节点的位置，比如要删除第2个位置的节点，cur会指向第1个位置(节点)
    }

    Node<T>* delNode = cur->_next; //delNode指向待删除的节点
    cur->_next = delNode->_next; //先让第i-1个节点的next指针指向第i+1个节点
    cout << "成功删除位置为" << i << "的元素，该元素的值为" << delNode->_data << endl;
    _length--;  //删除节点以后，让实际表长-1
    delete delNode; //释放节点
    return true; //删除成功
}

我们可以给出一组数据测试一下：

在这里插入图片描述

🍅 优化操作

我们分析一下删除操作的时间复杂度。

  • 如果删除单链表开头位置的节点，那么 for 循环一次都不会执行，这是最好情况时间复杂度 O(1)。
  • 如果删除单链表末尾位置的节点，并且假设单链表中已经有其他元素（非空），则 for 循环会循环 n-1 次，这是最坏情况时间复杂度 O(n)。
  • 平均情况时间复杂度在顺序表中也做过很详细的分析，这里很类似，平均情况时间复杂度为 O(n)，时间开销主要源于删除位置的寻找。

在实际的应用中，往往我们也会涉及到删除某个指定节点的情况。传统的做法是必须要利用头指针 _head 从前向后找到这个被删除节点的前趋节点。比如要将 a2 删除，就要先从前向后找到 a1 节点，算法的平均情况时间复杂度为 O(n)。

想一想，怎么才能优化这个操作呢？

  • 将 a2 后继节点 a3 中数据拷贝到 a2 节点的数据域中。
  • 将 a2 节点的指针域指向 a3 的后继节点 a4。
  • 释放 a3 节点所占用的内存。

我们看一下这个流程的思路：

在这里插入图片描述

这样修改后的算法时间复杂度就是 O(1) 了。

代码如下：

//删除cur所指向的节点
template<class T>
void LinkList<T>::DeleteNode(Node<T>* cur)
{
    //比如：a1 -> a2 -> a3 -> a4, 现在要删除a2节点
    Node<T>* pNode = cur->_next;
    cur->_data = cur->_next->_data; //将a2后继节点a3中数据拷贝到a2节点的数据域中
    cur->_next = cur->_next->_next; //让a2节点的指针域指向a3的后继节点a4
    delete pNode; //释放a3节点所占用的内存。
    _length--; //长度-1
}

//删除第i个位置的元素
template<class T>
bool LinkList<T>::ListDelete2(int i)
{
    if (_length < 1)
    {
        cout << "当前单链表为空，不能删除任何数据" << endl;
        return false;
    }
    if (i < 1 || i > _length)
    {
        cout << "删除的位置" << i << "不合法，合法的位置是1到" << _length << "之间" << endl;
        return false;
    }

    Node<T>* cur = _head; //cur指向头节点

    //整个for循环用于找到第i个节点
    for (int j = 0; j < i; ++j) //j从0开始，表示cur刚开始指向的是第0个节点（头结点）
    {
        cur = cur->_next; 
    }

    //循环结束, cur找到当前要删除的位置所代表的节点
    DeleteNode(cur);
    
    return true; //删除成功
}

我们可以给出一组数据测试一下：

在这里插入图片描述

注意，上面这种方法必须提前知道删除位置节点的地址，所以重新写了一个 Delete 函数用来查找删除 i 位置的节点地址。

但要注意，如果要删除的节点正好是单链表的最后一个节点，那就没法用上述快捷高效的方式来编写代码了（代码会报错）。我们还是必须用传统做法，利用头指针找到该将被删除节点的前趋节点，来删除某个指定节点。

🍑 获取元素

在元素获取操作这里，通常分为两种情况：按位置获取和按元素值获取。

🍅 按置查找

首先是按位置获取单链表中的元素值。

代码如下：

//获得第i个位置的元素值
template<class T>
bool LinkList<T>::GetElem(int i, T& e)
{
    if (_length < 1)
    {
        cout << "当前单链表为空，不能获取任何数据" << endl;
        return false;
    }

    if (i < 1 || i > _length)
    {
        cout << "获取元素的位置" << i << "不合法，合法的位置是1到" << _length << "之间" << endl;
        return false;
    }

    Node<T>* cur = _head;
    for (int j = 0; j < i; ++j)
    {
        cur = cur->_next;
    }
    e = cur->_data;
    cout << "成功获取位置为" << i << "的元素，该元素的值为" << e << endl;
    return true;
}

我们可以给出一组数据测试一下：

在这里插入图片描述

显然，按位置获取单链表元素操作的平均情况时间复杂度为 O(n)。

🍅 按值查找

按元素值查找其在单链表中第一次出现的位置

代码如下：

//按元素值查找其在单链表中第一次出现的位置
template<class T>
int LinkList<T>::LocateElem(const T& e)
{
    Node<T>* cur = _head; //从头节点的下一个开始依次查找
    for (int i = 1; i <= _length; ++i)
    {
        if (cur->_next->_data == e)
        {
            cout << "值为" << e << "的元素在单链表中第一次出现的位置为" << i << endl;
            return i;
        }
        cur = cur->_next;
    }
    cout << "值为" << e << "的元素在单链表中没有找到" << endl;
    return -1;  //返回-1表示查找失败
}

我们可以给出一组数据测试一下：

在这里插入图片描述

按元素值查找其在单链表中第一次出现位置操作的平均情况时间复杂度，依旧为 O(n)。

🍑 打印操作

输出单链表中的所有元素

代码如下：

//输出单链表中的所有元素，时间复杂度为O(n)
template<class T>
void LinkList<T>::DispList()
{
    Node<T>* cur = _head->_next;
    while (cur != nullptr) //循环遍历整个链表, 直到为空
    {
        cout << cur->_data << " ";
        cur = cur->_next;
    }
    cout << endl;
}

我们可以给出一组数据测试一下：

在这里插入图片描述

🍑 获取长度

获取单链表的长度

代码如下：

//获取单链表的长度，时间复杂度为O(1)
template<class T>
int LinkList<T>::ListLength()
{
    return _length; //直接返回长度即可
}

我们可以给出一组数据测试一下：

在这里插入图片描述

🍑 判空操作

判断单链表是否为空

代码如下：

//判断单链表是否为空，时间复杂度为O(1)
template<class T>
bool LinkList<T>::Empty()
{
    if (_head->_next == nullptr) //单链表为空（如果是不带头结点的单链表则用if(_head == nullptr）来判断是否为空）
    {
        return true;
    }
    return false;
}

我们可以给出一组数据测试一下：

在这里插入图片描述

🍑 翻转链表

所谓翻转单链表，就是把单链表中节点的排列顺序反过来。

比如原来节点的排列顺序为 a1、a2、a3、a4，那么翻转后节点的排列顺序就是 a4、a3、a2、a1。

这里要注意的是，并不是针对节点数据域中的数据进行翻转，而是针对整个节点进行翻转（比如原来位于单链表尾部的节点经过翻转后排到了单链表的头部）。

先来思考一下解决思路。

  • 把头节点和第一个节点分到一起作为第一部分。
  • 把剩余的节点分成一部分。
  • 每次从剩余的节点中的最前面拿出一个节点插入到第一部分单链表的首部。

下图展示了翻转单链表的步骤，先将头结点和 a1 分到一起作为第一部分，将 a2、a3、a4 分到一起作为第二部分，然后摘取第二部分的首部节点 a2 插到第一部分的 a1 之前，再摘取第二部分的首部节点 a3 插入到第一部分的 a2 之前……最终就可以实现整个单链表的翻转。

在这里插入图片描述

代码如下：

//翻转单链表，时间复杂度为O(n)
template<class T>
void LinkList<T>::ReverseList()
{
    if (_length <= 1)
    {
        //如果顺序表中没有元素或者只有一个元素，那么就不用做任何操作
        return;
    }

    //至少有两个节点才会走到这里
    Node<T>* latterCur = _head->_next->_next;  //指向从第二个节点开始的后续节点
    _head->_next->_next = nullptr;  //第一个节点的指针域先置空

    Node<T>* ptmp;
    while (latterCur != nullptr)
    {
        //比如a1、a2、a3、a4共4个节点，第一次执行该循环时的指向看下面代码中的注释
        ptmp = latterCur;  //ptmp代表a2
        latterCur = latterCur->_next; //现在latterCur指向a3

        ptmp->_next = _head->_next;  //a2指向a1
        _head->_next = ptmp; //头结点指向a2 
    }
}

我们可以给出一组数据测试一下：

在这里插入图片描述

🍑 释放操作

最后，说一下对单链表的释放操作，我们不但要释放单链表中带有数据的节点，也要释放头结点。

析构函数代码如下：

//通过析构函数对单链表进行资源释放，时间复杂度为O(n)
template<class T>
LinkList<T>::~LinkList()
{
    Node<T>* curNode = _head->_next;
    Node<T>* ptmp;
    while (curNode != nullptr) //该循环负责释放数据节点
    {
        ptmp = curNode;
        curNode = curNode->_next;

        delete ptmp;
    }
    delete _head; //释放头结点
    _head = nullptr; //把头节点置为空
    _length = 0; //链表长度置为0
}

4. 总结

单链表特点如下：

  • 并不需要大片的连续存储空间来存放数据元素，扩容很方便。
  • 插入和删除节点非常方便，平均情况时间复杂度为 O(n)。当然，如果不考虑需要预先查找到插入和删除位置只单纯考虑插入和删除动作本身，那么时间复杂度仅为 O(1)。不管怎么说，与数组相比，链表更适合插入、删除操作频繁的场景。
  • 存放后继指针要额外消耗存储空间，体现了利用空间换时间来提高算法效率的编程思想。但对于内存紧张的硬件设备，就要考虑单链表是否适合使用了。
  • 因为内存空间不连续，无法实现随机访问链表中的元素。要查找某个位置节点中的元素只能从链表的第一个节点开始沿着指针链逐个元素找下去，平均情况时间复杂度为 O(n)。

单链表的操作代码相比于数组更加复杂，实现也更加容易出错，因此写代码时除了要有清晰的逻辑思维之外，写完以后对代码进行测试也是非常重要和必要的——尤其是对边界情况的测试。在这里给出一些代码书写和测试的建议。

  • 单链表是后面学习的其他链表的基础，因此应该通过多画图的方式理清代码逻辑，边看图边写自己认为正确的逻辑代码。
  • 当链表为空的时候，测试代码能否正常工作。
  • 当链表只有一个数据节点时，测试代码能否正常工作。
  • 分别测试在处理链表中第一个和最后一个节点时代码能否正常工作。
  • 发现程序执行异常并百思不得其解时，通过设置断点对代码进行调试，逐行跟踪并观察代码的执行情况就是必须的解决问题的手段。
Albert Edison
关注
  • 7
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
数据结构-集合-HashMap
饮啖茶食个包
11-10 346
数据结构-集合-HashMap 文章目录数据结构-集合-HashMap一、理论（一）Hashing（二）HashMap1、基本概念2、数据结构3、工作原理（1）Java7（2）java84、查询时间复杂度5、hash冲突问题6、死锁问题二、实践：Java7的HashMap源码分析（一）包路径（二）导入包（三）接口和实现类（四）成员变量（五）构造函数：HashMap初始化1、无参数构造方法2、一个参...
java初级程序员面试精髓...
无求所谓
10-19 707
V5
282.软件体系结构的风格与模式
weixin_30752699的博客
09-12 964
　　建筑模式　　Christopher Alexander, The Timeless Way of Building, p247, 1979　　每个模式是一个由三部分组成的规则，表达了特定环境、问题和解(solution)之间的关系。　　作为现实世界的一个成分，每个模式表达了下列三者之间的一种关系：特定环境，在该环境中反复出现的力(forces)的系统，以及协调这些力的某种空间排...
编程新手导论
热门推荐
wangluozhangleilei的专栏
06-07 3万+
第二部分 导论，这一部分主要是关于编程的导论， (要懂得一点思想具备一点常识)《设计，编码，，与软工》（编程与思想）这一章解释了三种思想，原语，抽象，组合，，和软件开发的二个重要过程，，软件工程的相关概念，是编程入门的关键 (要懂得一点领域内的数学)《数学与算法》（编程与数学）计算机整个就是架构在数学上的，跟计算机平台实现，算法设计，，架构密切相关，，真正要深入编程，，，对数学的学习是必须的，
编程新手导论（转载）
szu030606的专栏
01-22 1万+
第二部分 导论，这一部分主要是关于编程的导论， (要懂得一点思想具备一点常识)《设计，编码，，与软工》（编程与思想）这一章解释了三种思想，原语，抽象，组合，，和软件开发的二个重要过程，，软件工程的相关概念，是编程入门的关键 (要懂得一点领域内的数学)《数学与算法》（编程与数学）计算机整个就是架构在数学上的，跟计算机平台实现，算法设计，，架构密切相关，，真正要深入编程，，，对数学的学习是必须的，
前端算法渣的救赎之路
weixin_48726650的博客
07-02 1753
前言 首先这是一份面向面试的算法题，题目主要选自leetcode中hot 100 | 腾讯精选50题 | 精选Top面试题 | 剑指offer | 面试中遇到的一些算法题,全文118题，基本涵盖了前端面试中的算法题分类。因为个人能力有限，所以题目几乎是easy | mid，并且搬运了一些优秀的题解均在参考文献中。如果对你有帮助的话点个????和收藏吧❤️ 目录 dp 贪心 二分 回溯 排序 并查集 拓扑排序 位运算 双指针 矩阵 二叉树 哈希表 栈和队列 链表 字符串 dp 思想 感觉很像时高中数列的思
【艾琪出品】《计算机应用基础》【试题汇总2】
加油
09-01 1万+
自备留用 《Java语言程序设计》20春期末考核 1. 接口体中不应包含( )。 A 常量定义 B 常量赋值 C 方法实现 D 方法声明 2. 以下( )不是Java的关键字。 A FALSE B const C this D void 3. 以下关于继承的叙述正确的是（）。 A 在Java中类只允许单一继承 B 在Java中一个类只能实现一个接口 C 在Java中一个类不能同时继承一个类和实现一个接口 D 在Java中接口只允许单一继承 4. 编译并且执行以下代码,会出现什么情况...
C++开发工程师基础面试题
UE引擎开发工程师
12-06 1193
C++开发工程师基础面试题C++基础1、C和C++的区别2、C++中指针和引用的区别3、结构体struct和共同体union（联合）的区别结构体为什么要内存对齐呢？结构体内存对齐规则如何让结构体按照指定的对齐参数进行对齐？4、#define和const的区别5、重载overload，覆盖override，重写overwrite，这三者之间的区别6、new、delete、malloc、free之间的关系7、delete和delete[]的区别8、STL库用过吗？常见的STL容器有哪些？算法用过几个？9、con
附加整理2
m0_38054145的博客
04-24 2028
MySQL主从复制与读写分离原理 主从复制可以实现读写分离 mysql优化的常用方法 索引的优化 只要列中含有NULL值，就最好不要在此例设置索引，复合索引如果有NULL值，此列在使用时也不会使用索引 尽量使用短索引，如果可以，应该制定一个前缀长度 对于经常在where子句使用的列，最好设置索引，这样会加快查找速度 对于有多个列where或者order by子句的，应该建立复合索引 ...
数据结构实验报告-文本串加密与解密程序.docx
08-27
数据结构实验报告-文本串加密与解密程序.docx
Python程序设计：AES数据解密.pptx
06-12
**AES数据解密** 在信息安全领域，AES（Advanced Encryption Standard）是一种广泛应用的对称加密算法，它是基于Rijndael算法被美国联邦政府采纳为标准的。AES的主要特点是其高效性和安全性，它在数据保护、网络...
JAVA版数据结构与算法(JAVA语言版解密)
05-19
《JAVA版数据结构与算法(JAVA语言版解密)》是一部深入探讨计算机科学核心领域——数据结构与算法的专著，特别针对Java编程语言进行了详细解读。数据结构是计算机存储、组织数据的方式，而算法则是解决问题或执行任务...
数据结构与算法(JAVA语言版解密)
05-28
数据结构与算法(JAVA语言版解密),对数据结构与算法及Java感兴趣的朋友可以下载
哈夫曼编码实现对文件的加密解密
12-03
综上所述，哈夫曼编码在文件加密解密中的实现涉及到了数据结构、二叉树、编码原理等多个IT领域的知识点，通过理解并实践该项目，可以深入掌握这些概念，并为将来在实际问题中应用哈夫曼编码打下坚实基础。
数据结构（初阶3.单链表）
最新发布
2401_83968713的博客
07-14 501
一、单链表1.1概念与结构1.2结点1.3链表的性质1.4链表的打印二、实现单链表SList.hSList.c申请新节点尾插头插尾删头删在指定位置之前插入数据在指定位置之后插入数据删除指定位置结点删除指定位置之后的结点销毁结点test.c。
数据结构【顺序表】
qq_67578580的博客
07-12 1209
我们需要创建一个seqlist.h头文件，seqlist.c文件存放函数，还有一个.c的测试文件。
数据结构之顺序表
m0_73634434的博客
07-10 430
线性表(List)由零个或多个数据组成的有限数列，线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表，链表，栈，队列，字符串。
数据结构和算法（0-1）----递归
yanminghe66666的博客
07-09 619
递归算法，爬楼梯等解法
哈夫曼树编码实验报告.docx
06-01
同时，通过对文件进行加密和解密的实验，我对数据结构和算法的应用有了更深入的理解，也对双亲孩子表示法有了更深入的认识。这些知识和技能的掌握对我的专业学习和未来的工作都具有非常重要的意义。通过不断地实践和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Albert Edison

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值