数据结构C++单链表笔记

最新推荐文章于 2024-10-09 17:48:02 发布
最新推荐文章于 2024-10-09 17:48:02 发布
阅读量538 收藏 10
点赞数 15
文章标签： 数据结构 c++ 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63881564/article/details/135708660
版权

个人学习所记录笔记，便于复习查看，如有错误，请见谅。

一、单链表的初始化（以下默认均为带头结点的）

//在这个示例中，我们使用 struct 关键字定义了一个结构体 LNode，并添加了成员变量 data 和 next。
//然后，使用 using 关键字将 struct LNode* 定义为类型别名 LinkList。
//在 C++ 中不需要在结构体声明之前使用 typedef 关键字，而是可以直接使用 using 关键字来定义类型别名。

强调这是一个单链表一使用 LinkList
强调这是一个结点     -使用 LNode *

struct LNode {
    int 	data;
    struct LNode* next;
};
using LinkList = struct LNode*;

//带头节点的单链表
bool InitList(LinkList& L) {
    L = new LNode; // 分配一个头结点
    if (L == nullptr) {
        // 内存不足，分配失败
        return false;
    }
    L->next = nullptr; // 头结点之后暂时还没有节点
    return true;
}

//判断是否为空
bool IsEmpty(LinkList L) {
    return L->next == nullptr;
}

二、各种操作

1.按位查找

//按位查找
LNode* GetElem(LinkList L, int i) {
    if (i < 0) {
        // 位序小于1或链表为空，返回nullptr
        return nullptr;
    }
    LNode* p = L;  // p指向第一个节点
    int j = 0;  // 计数器，用于记录当前节点的位序，即当前p指向第几个节点

    while (p != nullptr && j < i) {
        p = p->next;
        j++;
    }
    if (p == nullptr || j > i) {
        // 未找到指定节点或位序超出链表长度，返回nullptr
        return nullptr;
    }
    return p;  // 返回找到的节点指针
}

2.后插与前插操作

//指定结点的后插操作
bool InsertNextNode(LNode* p, int e) {
    if (p == nullptr) {
        // 插入位置无效
        return false;
    }
    // 创建新节点
    LNode* newNode = new LNode;
    newNode->data = e;
    // 插入新节点
    newNode->next = p->next;
    p->next = newNode;
    return true;
}
//给定结点的前插操作
bool InsertPriorNode(LNode* p, int e) {
    if (p == nullptr) {
        // 插入位置无效
        return false;
    }
    // 创建新节点
    LNode* newNode = new LNode;
    newNode->data = e;
    // 插入新节点
    newNode->next = p->next;
    p->next = newNode;
    // 交换数据
    int tmp = p->data;
    p->data = newNode->data;
    newNode->data = tmp;
    return true;
}

3.按位序插入操作

有两种写法，一种是基于按位查找与后插结合的方法，既下面展示的

另一种为展开写，为相应位置注释掉的，两种方法均可实现

//按位序插入
bool ListInsert(LinkList& L, int i, int e) {
    if (i < 1) {
        // 位序小于1无效
        return false;
    }
    //使用了按位查找的方法
    LNode* p = GetElem(L, i-1);

    //int j = 0;  // 计数器，用于记录当前节点的位序,既当前p指向第几个结点
    //LNode* p = L; // p指向头节点

     寻找要插入位置的前一个节点i-1	
    //while (p != nullptr && j < i - 1) {
    //    p = p->next;
    //    j++;
    //}
    //调用了后插操作
    return InsertNextNode(p, e);

    //if (p == nullptr) {
    //    // 位序超过链表长度，或者链表为空
    //    return false;
    //}
     创建新节点
    //LNode* s = new LNode;
    //s->data = e;
     插入新节点
    //s->next = p->next;
    //p->next = s;
    这两句不能颠倒
    //return true;
}

4.按位序删除

部分代码也可以替换为引用按位查找方法

//按位序删除（带头结点的）
bool ListDelete(LinkList& L, int i, int& e) {
    if (i < 1) {
        // 位序小于1无效
        return false;
    }
    LNode* p = GetElem(L, i - 1);
    if (p == nullptr || p->next == nullptr) {
        // 未找到待删除节点或待删除节点是最后一个节点，删除失败
        return false;
    }
    LNode* q = p->next;  // 待删除节点
    e = q->data;  // 将待删除节点的值赋给e 
    p->next = q->next;  // 将待删除节点的下一个节点链接到前一个节点上
    delete q;  // 删除节点
    return true;  // 删除成功
}

5.删除指定结点

//删除指定结点
void Delete(LNode* p) {
    if (p == nullptr || p->next == nullptr) {
        // 要删除的节点为空或为尾节点，无法删除
        return ;
    }
    LNode* q = p->next;  // q指向要删除的节点
    p->data = q->data;  // 将后继节点的值赋给当前节点
    p->next = q->next;  // 修改当前节点的指针指向后继节点的后继节点
    delete q;  // 删除要删除的节点
}

6.打印链表和输出链表的长度

// 输出链表数据
void PrintList(LinkList L) {
    LNode* p = L->next;  // p指向第一个节点
    while (p != nullptr) {
        cout << p->data << " ";
        p = p->next;
    }
    cout << endl;
}

//求表的长度
int GetLength(LinkList L) {
    int count = 0;
    LNode* p = L->next; // p指向首节点
    while (p != nullptr) {
        count++;
        p = p->next;
    }
    return count;
}

7.按位查找

//按值查找,返回节点
LNode* LocateElem(LinkList L, int e) {
    LNode* p = L->next; // p指向首节点
    while (p != nullptr && p->data != e) {
        p = p->next;
    }
    return p;
}

8.按值查找

第一种返回的是指针地址，第二种可以返回数据在第几位，既i。

//按值查找，返回第几位
int LocateElem1(LinkList L, int e) {
    LNode* p = L->next; // p指向首节点
    int i = 1; // 初始化计数器
    while (p != nullptr && p->data != e) {
        p = p->next;
        i++;
    }
    if (p == nullptr) {
        return 0; // 未找到元素，返回0
    }
    else {
        return i; // 返回元素在链表中的位置
    }
}
//求表的长度
int GetLength(LinkList L) {
    int count = 0;
    LNode* p = L->next; // p指向首节点
    while (p != nullptr) {
        count++;
        p = p->next;
    }
    return count;
}

9.头插法与尾插法，在表头或者表尾插入数据

两种方法类似，核心为：初始化操作，后插操作

//尾插法
LinkList List_TailInsert(LinkList& L) {
    int x;
    L = new LNode; // 创建头节点
    LNode* s = L; // 初始化尾指针
    while (cin >> x) { // 循环输入元素值
        if (x == -1) { // 输入-1结束输入
            break;
        }
        LNode* p = new LNode; // 创建新节点
        p->data = x; // 赋值新节点数据
        s->next = p; // 将新节点插入到尾部
        s = p; // 更新尾指针
    }
    s->next = nullptr; // 尾节点的next指向nullptr
    return L;
}
//头插法
LinkList List_HeadInsert(LinkList& L) {
    int x;
    L = new LNode; // 创建头节点
    L->next = nullptr; // 初始化头节点的next指针为nullptr
    while (cin >> x) { // 循环输入元素值
        if (x == -1) { // 输入-1结束输入
            break;
        }
        LNode* p = new LNode; // 创建新节点
        p->data = x; // 赋值新节点数据
        p->next = L->next; // 将新节点插入到头部
        L->next = p; // 更新头节点的next指针
    }
    return L;
}

10.函数调用

int main() {
    LinkList L;   //声明一个指向单链表的指针

    //初始化一个空表
    if (InitList(L)) {
        cout << "初始化成功" << endl;
    }
    else {
        cout << "初始化失败" << endl;
    }

   //插入数据
    ListInsert(L, 1, 10);

    ListInsert(L, 2, 20);

    ListInsert(L, 3, 30);

    // 判断链表是否为空
    if (IsEmpty(L)) {
        cout << "链表为空" << endl;
    }
    else {
        cout << "链表非空" << endl;
    }

    // 输出链表中的数据
    PrintList(L);

    int e;
    // 调用ListDelete函数删除指定位置的节点
    if (ListDelete(L, 3, e)) {
        cout << "成功删除节点，被删除节点的值为：" << e << endl;
    }
    else {
        cout << "删除节点失败" << endl;
    }
    PrintList(L);

    //按位置查找
    LNode* result = GetElem(L, 1);
    if (result != nullptr) {
        cout << "找到了位序为3的节点，该节点的值为：" << result->data << endl;
    }
    else {
        cout << "未找到位序为3的节点" << endl;
    }
    //按值查找
// 按值查找元素,找到的是节点指针
    int target = 20;
    LNode* result1 = LocateElem(L, target);
    if (result1 != nullptr) {
        cout << "找到元素 " << target << "，节点的地址为：" << result1 << endl;
    }
    else {
        cout << "未找到元素 " << target << endl;
    }

    // 按值查找元素，返回i
    int target1 = 30;
    int result2 = LocateElem1(L, target1);
    if (result2 != 0) {
        cout << "找到元素 " << target1 << "，节点的位置为：" << result2 << endl;
    }
    else {
        cout << "未找到元素 " << target1 << endl;
    }
    // 获取链表的长度
    int length = GetLength(L);
    cout << "链表的长度为：" << length << endl;


    //尾插法代码实现
    //L = List_TailInsert(L);

    //PrintList(L); // 输出链表

    //头插法实现与尾插类似 
    return 0;
}

11.完整代码实现

#include<iostream>
#include<new>
using namespace std;

struct LNode {
    int 	data;
    struct LNode* next;
};
using LinkList = struct LNode*;

//带头节点的单链表
bool InitList(LinkList& L) {
    L = new LNode; // 分配一个头结点
    if (L == nullptr) {
        // 内存不足，分配失败
        return false;
    }
    L->next = nullptr; // 头结点之后暂时还没有节点
    return true;
}

//判断是否为空
bool IsEmpty(LinkList L) {
    return L->next == nullptr;
}
//按位查找
LNode* GetElem(LinkList L, int i) {
    if (i < 0) {
        // 位序小于1或链表为空，返回nullptr
        return nullptr;
    }
    LNode* p = L;  // p指向第一个节点
    int j = 0;  // 计数器，用于记录当前节点的位序，即当前p指向第几个节点

    while (p != nullptr && j < i) {
        p = p->next;
        j++;
    }
    if (p == nullptr || j > i) {
        // 未找到指定节点或位序超出链表长度，返回nullptr
        return nullptr;
    }
    return p;  // 返回找到的节点指针
}
//指定结点的后插操作
bool InsertNextNode(LNode* p, int e) {
    if (p == nullptr) {
        // 插入位置无效
        return false;
    }
    // 创建新节点
    LNode* newNode = new LNode;
    newNode->data = e;
    // 插入新节点
    newNode->next = p->next;
    p->next = newNode;
    return true;
}
//按位序插入
bool ListInsert(LinkList& L, int i, int e) {
    if (i < 1) {
        // 位序小于1无效
        return false;
    }
    //使用了按位查找的方法
    LNode* p = GetElem(L, i-1);

    //int j = 0;  // 计数器，用于记录当前节点的位序,既当前p指向第几个结点
    //LNode* p = L; // p指向头节点

     寻找要插入位置的前一个节点i-1	
    //while (p != nullptr && j < i - 1) {
    //    p = p->next;
    //    j++;
    //}
    //调用了后插操作
    return InsertNextNode(p, e);

    //if (p == nullptr) {
    //    // 位序超过链表长度，或者链表为空
    //    return false;
    //}
     创建新节点
    //LNode* s = new LNode;
    //s->data = e;
     插入新节点
    //s->next = p->next;
    //p->next = s;
    这两句不能颠倒
    //return true;
}


//给定结点的前插操作
bool InsertPriorNode(LNode* p, int e) {
    if (p == nullptr) {
        // 插入位置无效
        return false;
    }
    // 创建新节点
    LNode* newNode = new LNode;
    newNode->data = e;
    // 插入新节点
    newNode->next = p->next;
    p->next = newNode;
    // 交换数据
    int tmp = p->data;
    p->data = newNode->data;
    newNode->data = tmp;
    return true;
}
//按位序删除（带头结点的）
bool ListDelete(LinkList& L, int i, int& e) {
    if (i < 1) {
        // 位序小于1无效
        return false;
    }
    LNode* p = GetElem(L, i - 1);
    if (p == nullptr || p->next == nullptr) {
        // 未找到待删除节点或待删除节点是最后一个节点，删除失败
        return false;
    }
    LNode* q = p->next;  // 待删除节点
    e = q->data;  // 将待删除节点的值赋给e 
    p->next = q->next;  // 将待删除节点的下一个节点链接到前一个节点上
    delete q;  // 删除节点
    return true;  // 删除成功
}

//删除指定结点
void Delete(LNode* p) {
    if (p == nullptr || p->next == nullptr) {
        // 要删除的节点为空或为尾节点，无法删除
        return ;
    }
    LNode* q = p->next;  // q指向要删除的节点
    p->data = q->data;  // 将后继节点的值赋给当前节点
    p->next = q->next;  // 修改当前节点的指针指向后继节点的后继节点
    delete q;  // 删除要删除的节点
}
// 输出链表数据
void PrintList(LinkList L) {
    LNode* p = L->next;  // p指向第一个节点
    while (p != nullptr) {
        cout << p->data << " ";
        p = p->next;
    }
    cout << endl;
}
//按值查找,返回节点
LNode* LocateElem(LinkList L, int e) {
    LNode* p = L->next; // p指向首节点
    while (p != nullptr && p->data != e) {
        p = p->next;
    }
    return p;
}
//按值查找，返回第几位
int LocateElem1(LinkList L, int e) {
    LNode* p = L->next; // p指向首节点
    int i = 1; // 初始化计数器
    while (p != nullptr && p->data != e) {
        p = p->next;
        i++;
    }
    if (p == nullptr) {
        return 0; // 未找到元素，返回0
    }
    else {
        return i; // 返回元素在链表中的位置
    }
}
//求表的长度
int GetLength(LinkList L) {
    int count = 0;
    LNode* p = L->next; // p指向首节点
    while (p != nullptr) {
        count++;
        p = p->next;
    }
    return count;
}
//尾插法
LinkList List_TailInsert(LinkList& L) {
    int x;
    L = new LNode; // 创建头节点
    LNode* s = L; // 初始化尾指针
    while (cin >> x) { // 循环输入元素值
        if (x == -1) { // 输入-1结束输入
            break;
        }
        LNode* p = new LNode; // 创建新节点
        p->data = x; // 赋值新节点数据
        s->next = p; // 将新节点插入到尾部
        s = p; // 更新尾指针
    }
    s->next = nullptr; // 尾节点的next指向nullptr
    return L;
}
//头插法
LinkList List_HeadInsert(LinkList& L) {
    int x;
    L = new LNode; // 创建头节点
    L->next = nullptr; // 初始化头节点的next指针为nullptr
    while (cin >> x) { // 循环输入元素值
        if (x == -1) { // 输入-1结束输入
            break;
        }
        LNode* p = new LNode; // 创建新节点
        p->data = x; // 赋值新节点数据
        p->next = L->next; // 将新节点插入到头部
        L->next = p; // 更新头节点的next指针
    }
    return L;
}



int main() {
    LinkList L;   //声明一个指向单链表的指针

    //初始化一个空表
    if (InitList(L)) {
        cout << "初始化成功" << endl;
    }
    else {
        cout << "初始化失败" << endl;
    }

   //插入数据
    ListInsert(L, 1, 10);

    ListInsert(L, 2, 20);

    ListInsert(L, 3, 30);

    // 判断链表是否为空
    if (IsEmpty(L)) {
        cout << "链表为空" << endl;
    }
    else {
        cout << "链表非空" << endl;
    }

    // 输出链表中的数据
    PrintList(L);

    int e;
    // 调用ListDelete函数删除指定位置的节点
    if (ListDelete(L, 3, e)) {
        cout << "成功删除节点，被删除节点的值为：" << e << endl;
    }
    else {
        cout << "删除节点失败" << endl;
    }
    PrintList(L);

    //按位置查找
    LNode* result = GetElem(L, 1);
    if (result != nullptr) {
        cout << "找到了位序为3的节点，该节点的值为：" << result->data << endl;
    }
    else {
        cout << "未找到位序为3的节点" << endl;
    }
    //按值查找
// 按值查找元素,找到的是节点指针
    int target = 20;
    LNode* result1 = LocateElem(L, target);
    if (result1 != nullptr) {
        cout << "找到元素 " << target << "，节点的地址为：" << result1 << endl;
    }
    else {
        cout << "未找到元素 " << target << endl;
    }

    // 按值查找元素，返回i
    int target1 = 30;
    int result2 = LocateElem1(L, target1);
    if (result2 != 0) {
        cout << "找到元素 " << target1 << "，节点的位置为：" << result2 << endl;
    }
    else {
        cout << "未找到元素 " << target1 << endl;
    }
    // 获取链表的长度
    int length = GetLength(L);
    cout << "链表的长度为：" << length << endl;


    //尾插法代码实现
    //L = List_TailInsert(L);

    //PrintList(L); // 输出链表

    //头插法实现与尾插类似 
    return 0;
}

三、特点
优点：不要求大片连续空间，改变容量方便
缺点：不可随机存放，要耗费一定空间存放指针

四、时间复杂度（简写版）

按位插入：
最好:1
最坏:n
平均:n
后插：1
前插：1 
按位序删除
最坏：n
最好：1
平均：n
删除指定结点：1
按位查找：n
按值查找：n
尾插法：n
头插法：n

瑞香华
关注
数据结构线性表的链式存储结构（单链表）的表示及其基本操作
iCode
10-31 2632
文章目录头文件 宏定义 部分变量初始化一个空的链表 头文件 宏定义 部分变量 #include <stdio.h> #include <stdlib.h> #define OVERFLOW -2 #define ERROR 0 #define OK 1 typedef int Status; typedef int Elemtype; typedef struct LNode{ Elemtype data; struct LNode * next; }LNode,* Link
数据结构C++复习笔记
Pz1o的博客
05-13 1158
数据结构复习(c++) 线性表 1.线性表 线性表是一个有限序列。 线性表基于数组存储的表示叫做顺序表。常用数组作为表。 线性表基于指针的存储表示叫做链表。通常有单链表、双链表、循环链表等。 2.顺序表 0x01顺序表的定义和特点 假设顺序表A的起始存储位置为Loc(1),第i个表项的存储位置为Loc(i)则有： Loc(i)=Loc(1)+(i-1)*sizeof(T) 其中，Loc(1)为第一个表项的存储位置，即数组中第0个元素的位置。 0x02顺序表的类定义及操作 顺序表存储分为静态存储和动态存储。
C++ 数据结构算法 学习笔记(3)-链表
2201_75704074的博客
04-07 528
链表是线性表的链式存储方式，逻辑上相邻的数据在计算机内的存储位置不必须相邻，那么 怎么表示逻辑上的相邻关系呢？可以给每个元素附加一个指针域，指向下一个元素的存储位 置。如图所示：从图中可以看出,每个结点包含两个域：数据域和指针域，指针域存储下一个结点的地址， 因此指针指向的类型也是结点类型。
C++ 数据结构 单链表
qq_47168663的博客
09-22 403
C++，数据结构，单链表，线性表
数据结构算法—利用单链表计算等于给定值的节点个数
weixin_44780193的博客
12-02 2146
这个算法比较简单，我第一次发CSDN博客，就以这个开个头吧，后续也发一些数据结构的相关算法问题，作为一个小系列。 首先要定义单链表节点结构体。 typedef int ElemType；//提前定义结构体中ElemType的类型，在这里定义是为了后续方便更换数据类型 typedef struct Lnode｛ ElemType data； struct Lnode *next； ｝Lnode，*LinkList； 第二步开始此算法函数 int sum_number（LinkList *head，int X
程序计数器
中国华的博客
05-18 541
Program Counter Register 程序计数器（寄存器） 作用，是记住下一条jvm指令的执行地址 多个线程发生切换时，需要知道它的下一步要执行的指令，就用到了程序计数器，程序计数器是保存到寄存器上的 特点 是线程私有的 不会存在内存溢出 程序计数器仅仅只是一个运行指示器，它所需要存储的内容仅仅就是下一个需要待执行的命令的地址，无论代码有多少，最坏情况下死循环也不会让这块内存区域超限，因为程序计算器所维护的就是下一条待执行的命令的地址，所以不存在OutOfMemoryError ...
数据结构学习笔记-单链表
02-16
在所有数据结构中，链表是一种基础且重要的类型，尤其是单链表。本学习笔记将聚焦于单链表的概念、操作以及在VS2022环境下如何实现。 单链表是一种线性数据结构，其元素（节点）不是在内存中连续存储的，而是通过...
C++学习笔记-数据结构-单链表的实现
qq_19813681的博客
04-20 243
这是学习C++的数据结构的第一个笔记，留着自己今后忘了的时候再看看吧 #include <iostream> using namespace std; // 定义一个打印回调指针，由使用者实现 typedef void(*PRINTLINKLIST)(void*); // 链表节点 typedef struct LINKNODE { void* data; //指向...
数据结构学习笔记--带头结点的单链表的多种初始化及销毁方法（c/c++实现）
weixin_58526281的博客
08-08 3735
本知识点主要需要注意的是函数所传入参数的指针取值与取地址的区别，加深对c语言中指针的理解。
数据结构笔记（C++实现）
qq_36028321的博客
05-13 743
数据结构笔记（大话数据结构）**序**1、数据结构绪论基本术语2、算法2.1、算法的特性2.2、算法的设计要求 序 这是我的第一篇在网络上记载的笔记，实是记录在学习过程中的一些心得体会。毕竟逐渐的发现学习的过程中没有记录，即使当时认真学过，一段时间之后就会变成过眼云烟。本科学了几年机械，从无感到热爱再到这个专业成为别人口中的笑柄。回头想想，其实错不在某个专业学什么，也不在这个专业下的学生，只是风向不同而已。在此之前，已经学习过吴恩达的ml和黑马的c++，虽然课是听完了，但也就大致摸索到个概念而已。并不是说这
数据结构（1）：线性表（下）
kodoshinichi的博客
06-23 296
一.线性表的链式表示 （一）.单链表（*） 1.单链表的定义 单链表：线性表的链式存储；使用一组任意的存储单元来存储线性表中的数据元素，使用指向后继的指针表示元素之间的链式关系。 相关术语：数据域——存放相关元素/指针域——存放后继节点的地址 节点结构与程序定义 data next typedef struct LNode{ ElemType data;//数据域 struct LNode *next;//指针域 }LNode, *LinkList;
线性结构——顺序表与链表，循环链表和双向链表
weixin_56631477的博客
12-04 829
顺序表 顺序存储是指在内存中用地址连续的一块存储空间顺序存放线性表的各元素 -元素顺序和地址顺序相同（下标能直接反应元素间的关系）元素的物理位置相邻 -由一维数组实现（但一维数组不一定是顺序存储结构） 顺序存储结构类型定义
leetcodec++题库_Leetcode刷题笔记（C++）
weixin_32187075的博客
02-01 355
#includeusing namespacestd;typedefintelemType;templateclasslinkList {private:struct Node //结点类型{elemType data;//结点数据域Node* next; //结点指针域Node(const elemType value, Node* p =NU...
c语言单链表交换节点排序,单链表排序交换节点算法
weixin_30750685的博客
05-21 1088
单链表交换节点排序，包括选择法、比较法、排序法。用C实现代码如下：#include#include#include#define TRUE 1#define FALSE 0#define ERROR 0#define OVERFLOW 0#define OK 1typedef int Status;typedef int ElemType;struct LNode{ElemType data;st...
【算法理解】——计数排序
鸡蛋的专栏
05-11 578
前言    大家好，相隔许久，甚是想念。已经有9个月左右没有写博客了，因为之前的【算法理解】模块的编写风格都比较接近，也比较花时间。有博友发邮件跟我反馈了一下，这种带入数据式的讲解，需要比较大的精力和耐心细看才能看懂，不是很合适。     所以本篇算法理解，本人将用不同的方式对该算法进行讲解。如果不合适，希望大家踊跃的批评反馈。    其实选择该算法进行讲解，是因为该算法比较特殊：
c++如何实现对硬盘的操作_C/C++编程笔记：如何使用C++实现单链表？单链表基本运算实现...
weixin_39984963的博客
11-21 178
接上节：C/C++编程笔记：如何使用C++实现单链表？单链表第一部分。单链表上的基本运算实现(四) 求表长由与我们的代码中已经定义过一个叫做 curLength 的变量用来记录我们的表长所以我们可以直接返回，我们在定义中已经实现了，也就是这句： int size()const {return curLength;}//返回单链表的当前实际长度但是如果我们没有这样一个变量，我们想要实现这样的功能又是...
【数据结构】双向链表（Doubly Linked List）
2301_77727857的博客
10-05 539
双向链表（Doubly Linked List）是一种链式数据结构，它的每个节点都包含三个部分：数据、指向前一个节点的指针（prev），以及指向下一个节点的指针（next与单向链表不同，双向链表允许从任意节点向前或向后遍历，提供了更灵活的操作方式。
查找与排序-插入排序
wlq_567的博客
10-02 584
排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。是一种简单直观的排序算法，其基本思想是将未排序的元素逐个插入到已排序的部分中，直到所有元素都被插入到合适的位置为止。假设我们有以下待排序的数组：[5, 3, 8, 6, 2]最终，数组变为有序状态：[2, 3, 5, 6, 8]
Java：数据结构-ArrayList和顺序表（2）
最新发布
blamep的博客
10-09 398
创建一个空的ArrayList，指定容量为initialCapacity。
C++数据结构与算法入门笔记：逻辑、存储与实现
本文档是一份关于数据结构与算法学习的笔记，特别关注了C++语言的应用。首先，它强调了数据结构的基础概念，包括数据结构的定义（结构定义和结构操作），逻辑结构（如存储结构和抽象数据类型），以及数据的基本元素...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值