【数据结构】从0开始数据结构学习-线性表

最新推荐文章于 2024-11-03 22:57:39 发布
最新推荐文章于 2024-11-03 22:57:39 发布
阅读量58 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 学习 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baiboDG/article/details/128815449
版权

本节为线性表内容，回到总目录：点击此处

本部分目录

线性表

特点： 同一性（线性表由同类数据元素组成）
有穷性 （有限个元素组成）
有序性 （相邻元素之间存在着序偶关系< a i , a i + 1 a_i,a_{i+1} ai​,ai+1​>

抽象数据类型定义：

ADT LinearList {
数据元素：D={}
关系：S = }

基本操作：

  1. InitList(L) 操作前提：L为未初始化线性表
    操作结果：将L初始化为空表

  2. DestoryList(L) 操作前提：线性表L已存在
    操作结果：将L销毁

  3. ClearList(L) 操作前提：线性表L已存在
    操作结果：将表L置为空表

}ADT LinearList

线性表的顺序储存

–>用一组地址连续的存储单元一次储存线性表中的各个元素，使得线性表中在逻辑结构上相邻的数据元素储存在相邻的物理储存单元中。
–>采用顺序存储结构的线性表通常称为顺序表

#define maxsize = ;
typedef struct
{
    ElemType elem[maxsize]; 
    int last;  //记录线性表最后一个元素在数组elem[]中的位置(下标)，空表置为-1。
}SeqList;
顺序存储结构线性表的基本运算

  1. 查找
    按序号查找：线性表L中第i个数据元素，其结果为L.elem[i-1]或L->elem[i-1]
    按内容查找：要求查找线性表L中与给定值e相等的数据元素，其结果为线性表L中找到与e相等的元素，则返回其序号，若未找到，则返回一个“空序号”，-1

    int Locate (SeqList L, ElemType e)
{
    i = 0;
    while ((i <= L.last) && (L.elem[i] != e)) i++;
    if (i <= L.last)
        return (i);
    else
        return (-1);
}

  2. 插入
    在线性表的第i个位置插入一个元素e

    int InsList (SeqList *L, int i, ElemType e)
{
    int k;
    if ((i < 1) || (i > L -> last+2)) //检查插入位置是否满足要求 // 0 <= i - 1 <= L->last+1;
    {
        return error;
    }
    if (L -> last >= maxsize-1) //检查表是否已满
    {
        return error;
    }
    for (k = L -> last; k >= i-1; k--)
    {
        L -> elem[k+1] = L -> elem[k];
    }
    L - > elem[i - 1] = e;
    L - > last ++;
    return (OK);
}

    //执行循环的次数 n - i + 1; 时间复杂度与i有关
    //顺序标插入算法平均需移动一半结点 n/2

  3. 删除
    将表的第i个元素删除

    int DelList(SeqList *L, int i, ElemType *e)
{
    int k;
    if ((i < 1) || (i > L->last+1))
    {
        return error; //检查删除位置
    }
    *e = L->elem[i-1];
    for (k = i; i <= L->last; k++)
    {
        L->elem[k-1] = L -> elem[k];
    }
    L -> last --;
    return(OK);
}

    //循环执行次数 n - i —与i的取值有关 平均 (n -1) /2

  4. 合并
    将两个顺序表LA和LB合并，其元素均为非递减的有序排列，合并成LC

    void Merge(SeqList *LA; SeqList *LB; SeqList *LC)
{
    i = 0;
    j = 0;
    k = 0;
    while (i <= LA -> Last && j <= LB -> last)
    {
        if (LA -> elem[i] <= LB -> elem[j])
            LC -> elem[k] = LA -> elem [i]; i++; k++;
        else
            LC -> elem[k] = LB -> elem[j]; j++; k++;
    }
    while (i <= LA->last)
    {
        LC -> elem[k] = LB -> elem[j]; i++; k++;
    }
    while (j <= LB->last)
    {
        LC -> elem[k] = LB -> elem[j]; j++; k++;
    }
    LC -> last = LA -> last + LB -> last;
}

    优点：·无需为表示结点间的逻辑关系而增加额外的存储空间；
    · 可方便地随机存取表中的任一元素

    缺点：·插入或删除运算不方便
    ·存储分配需要预先进行静态分配，当表比较长时候，难以分配合适空间

单链表
注意事项（*名词解释）
概念·················解释
头指针1.头指针具有标识作用，故常用头指针冠以链表的名字，可类比数组
2.指向链表中第一个节点的存储位置，当存在头结点时指向头结点，否则指向首结点
3.勿论链表是否为空，头指针均不为空
4.只要不是循环链表一定存在头指针
头结点1.为了操作的统一与便利而设置的，位于首结点之前的结点，其数据域一般无意义
2.不是链表必须的
尾指针1.在单向循环链表中，通常只保存一个尾指针。因为尾指针的下一个节点就是头节点，方便在头尾进行操作
尾结点1.链表中最后一个结点 --||一般尾结点的指针指向为NULL

采用链式存储结构的线性表成为链表
动态链表、静态链表；单链表、循环链表、双链表。

结点(Node) — 数据域 | 指针域 (牺牲空间效率换取时间效率)

typedef struct Node
{
    ElemType data;
    struct Node *next;
}Node,*LinkList;  
//定义结点。*LinkList为结构指针类型
建立单链表 (头插法与尾插法)

· 头插法建表
img

Linklist CreateFromHead()
{
    LinkList L; Node *s; int flag = 1;
    /*设置一个标志，初始值为1，当输入“$”时,flag为0,建表结束*/
    L = (Linklist) malloc(sizeof(Node)); //为头结点分配存储空间
    L -> next = NULL;
    while(flag)
    {
        c = getchar();
        if (c != "$")
        {
            s = (Node *)malloc(sizeof(Node));
            s -> data = c;
            s -> next = L -> next;
            L -> next = s;
        }
        else flag = 0;
    }
}

·尾插法建表
img

Linklist CreateFromTail()
{
    Linklist L;
    Node *r, *s;
    int flag = 1;
    L = (Node *)malloc(sizeof(Node));
    L -> next = NULL;
    r = L;
    while (flag)
    {
        c = getchar();
        if (c != "$")
        {
            s = (Node *)malloc(sizeof(Node));
            s -> data = c;
         	r -> next = s;
            r = s;
        }
        else 
        {
            flag = 0;
            r -> next = NULL;
        }
    }
}
单链表的操作（查找、长度、删除、合并、插入、差集）

·单链表的查找

  1. 按序号查找

    //在带头结点的单链表L中查找第i个结点，若找到(1<=i<=n),则返回该结点储存的位置，否则返回NULL。
Node* Get(Linklist L, int i)
{
    Node *p;
    p = L;
    j = 0;
    while ((p -> next != NULL) && (j < i))
    {
        p = p -> next;
        j ++;
    }
    if (i == j) return p;
    else return NULL;
}

  2. 按值查找

    Node* Locate(Linklist L, ElemType key)
{
    Node *p;
    p = L -> next;
    while (p != NULL)
    {
        if(p -> data != key)
            p = p -> next;
        else
            break;
    }
    return p;
}

·求单链表的长度

int ListLength(Linklist L)
{
    Node *p;
    p = L -> next;
    j = 0;
    while (p != NULL)
    {
        p = p -> next;
        j++;
    }
    return j;
}

·单链表的插入操作 (需要预留指针pre 用来指示当前位置)

img

void InsList(Linklist L, int i, ElemType e)
{
    /*在带头结点的单链表L中第i个结点之前插入值为e的新结点*/
    Node *pre, *s;
    pre = L;
    int k = 0;
    while (pre != NULL && k < i - 1)
    {
        pre = pre -> next;
        k = k + 1;
    }
    if (k != i - 1)
    {
        cout << "插入位置不合理";
        return error;
    }
    s = (Node *)malloc(sizeof(Node));
    s -> data = e;
    s -> next = pre -> next;
    pre -> next = s;
}

·单链表的删除

单链表的删除应注意！！
删除算法中的循环条件(pre -> next != NULL && k < i -1)与前插算法中的循环条件(pre != NULL && k < i -1)不同，因为前插时的插入位置有m+1个[可以在指针末尾插入添加]，而删除操作的合法位置只有m个，若使用和前插算法相同的循环条件，则会出现指针指空的情况。

img

void DelList(Linklist L, int i, ElemType *e)
{
    /*在带头节点的单链表L中删除第i个元素，并保存其值到变量*e中*/
    Node *p, *r;
    p = L;
    int k = 0;
    while (p -> next != NULL && k < i - 1)
    {
        p = p -> next;
        k = k + 1;
    }
    if (k != i - 1)
    {
        return error;
    }
    r = p -> next;
    p -> next = p -> next -> next;
    *e = r -> data;
    free(r);
}

·求两个集合的差
A - B -----> LC 求差集

void Difference(Linklist LA, Linklist LB)
{
    Node *pre,*p,*r,*q;
    pre = LA;
    p = LA -> next;
    while (p != NULL)
    {
        q = LB -> next;
        while(q != NULL && q -> data != p -> data) q = q -> next;
        if (q != NULL)
        {
            r = p;
            pre -> next = p -> next;
            p = p -> next;
            free(r);
        }
        else
        {
            pre = p;
            p = p -> next;
        }
    }
}
//方法二：
void Diff(LinkList &A,LinkList &B)
{
	LinkList pc = A;
    Node *pa = A -> next, *pb = B -> next;
	while(pa && pb)
	{
		if(pa -> data == pb -> data)
		{
			pa = pa -> next;
			pb = pb -> next;
		}
		else if( pa-> data > pb -> data)
		{
			pb = pb -> next;
		} 
		else if( pa -> data < pb -> data)
		{
			pc -> next = pa;
			pa = pa -> next;
			pc = pc -> next;
		}
		if(!pb) pc -> next = pa;
	}
	return;
}

·合并两个有序的单链表

Linklist MergeLinklist(Linklist LA, Linklist LB)
{
    Node *pa, *pb;
    Linklist LC;
    pa = LA -> next;
    pb = LB -> next;
    LC = LA;
    LC -> next = NULL;
    r = LC; //r的初始值为LC 且 始终指向LC的表尾
    //两个表中均未处理完，选择比较小的值结点插入到新表LC中
    while (pa != NULL && pb != NULL)
    {
        if (pa -> data <= pb -> data)
        {
            r -> next = pa;
            r = pa;
            pa = pa -> next;
        }
        else 
        {
            r -> next = pb;
            r = pb;
            pb = pb -> next;
        }
    }
    if(pa) //若LA未完，则将表LA中后续元素链到新表LC表尾
    {
        r -> next = pa;
    }
    else //否则则处理LB
    {
        r -> next = pb;
    }
    free(LB);
    return(LC);
}
循环链表
单循环链表（初始化与建立、循环单链表的合并）

表中最后一个结点的指针指向第一个结点或表头结点

·循环单链表的初始化和建立循环单链表

InitCLinkList(Linklist *CL)
{
	*CL = (Linklist)malloc(sizeof(NOde));
	(*CL) - > next = *CL;
}
//初始化
void CreateCLinklist(Linklist CL)
{
    Node *r, *s;
    char c;
    r = CL;
    c = getchar();
    while (c != "$")
    {
        s = (Node *)malloc(sizeof(Node));
        s -> data = c;
        r -> next = s;
        r = s;
        c = getchar();
    }
    r -> next = CL; //让最后一个结点的next链域指向头结点 //与单向链表的区别
}

·循环单链表的合并
重在理解！！！尾插法||头插法！！

//将两个带有头结点的循环单链表LA、LB合并未一个循环单链表，其头指针为LA。
Linklist merge_1(Linklist LA, Linklist LB)
{
    //将两个采用头指针的循环单链表进行首尾相连
    Node *p, *q;
    p = LA;
    q = LB;
    //找表尾
    while (p -> next != NULL) p = p -> next;
    while (q -> next != NULL) q = q -> next;
    q -> next = LA;
    p -> next = LB -> next;
    free(LB);
    return (LA);
}
--使用尾指针直接指向链表尾部--
--好处：带尾指针的循环链表，直接指向链表的尾部，并且rare->next即为循环链表的头指针--
Linklist merge_2(Linklist RA, Linklist RB) //带尾插法的循环链表的合并
{
    // RA RB 分别表示的是指向A,B链表最后一个元素的指针
    //此算法将两个采用尾指针的循环链表首尾连接起来
    Node *p;
    p = RA -> next; //保存RA的头结点地址
    RA -> next = RB -> next -> next;  //链表RB的开始结点链到RA的终端结点之后
    free(RB -> next); //释放链表RB的头结点
    RB -> next = p;  //链表RA的头结点链到RB的终端结点之后
    rerurn RB;  //返回新循环链表的尾指针
}
双向链表

双向链表的组成：(一般也由头指针head唯一确定)
每一个结点均有：
数据域 (data)
左链域(back) 指向前驱结点
右链域(next) 指向后继

双向链表的结构定义：
typedef struct Dnode
{
    ElemType data;
    struct DNode *prior, *next;
}DNode, *DoubleList;

p == p -> back -> next == p -> next -> back
img

双向链表的操作

· 插入操作：

int DlinkIns(DoubleList L, int i, ElemType e)
{
    DNode *s, *p;
    ...  //检查插入位置是否合理
    ...  //然后定位到第i个结点，并让指针p指向它
    s = (DNode *)malloc(sizeof(DNode));
    if(s)
    {
        s -> data = e;
        s -> prior = p -> prior;
        p -> prior -> next = s;  //断开
        s -> next = p;  //加线
        p -> prior = s;  //加线
        return true;
    }
    else
        return false;
}

·删除操作

int DlinkDel(DoubleList L, int i, ElemType *e)
{
    DNode *p;
    ... //检查删除位置是否合理
    ... //定位到第i个结点，并让指针p指向它
    *e = p -> data;
    p -> prior -> next = p -> next;
    p -> next -> prior = p -> prior;
    free(p);
    return true;
}
*静态链表
链表的排序算法

·选择排序

void sort02(Linklist &L) //选择排序
{
    Node *r,*p;
    p = L -> next;
    while (p -> next != NULL) //一重循环
    {
        r = p -> next;
        while (r != NULL) //二重循环
        {
            if (p -> data > r -> data)
            {
                int t = p -> data;
                p -> data = r -> data;
                r -> data = t;
            }
            r = r -> next;
        }
        p = p -> next;
    }
}

·冒泡排序

void Bubble_sort(Linklist &L) //冒泡排序
{
    Node *cur,*tail;
    tail = L -> next;
    cur = L -> next;
    while (tail != NULL) //找到尾节点
    {
        tail = tail -> next;
    }
    while (cur != tail) //双层循环，冒泡排序
    {
        while(cur -> next != tail)
        {
            if(cur -> data > cur -> next -> data)
            {
                int t = cur-> data;
                cur -> data = cur -> next -> data;
                cur-> next -> data = t;
            }
            cur = cur -> next;
        }
        tail = cur;
        cur = L -> next;
    }
}

·选择排序

线性表的应用~一元多项式
一元多项式的存储

· 一元多项式的顺序存储表示
[适合非零项较多] 只存储该一元多项式各项的系数
[适合非零项较少] 存储非零项，存储非零项系数和非零项指数这两项

· 一元多项式的链式存储表示

struct Polynode
{
    int coef;
    int exp;
    Polynode * next;
}Polynode, *Polylist;

建立（输入多项式的系数和指数，用尾插法建立一元多项式的链表。以输入系数0为结束标志，并约定建立链表时总是按指数从低到高排列)

img

Polylist polycreate()
{
    Polynode *head, *rear, *s;
    int c, e;
    rear = head = (Polynode *)malloc(sizeof(Polynode));
    /*建立多项式的头结点，rear始终指向单链表的尾部*/
    scanf("%d,%d",&c,&e); //多项式系数和指数项
    while(c != 0)
    {
        s = (Polynode *)malloc (sizeof(Polynode));
        s -> coef = c;
        s -> exp = e;
        rear -> next =s; //尾插法
        rear = s;
        scanf("%d,%d",&c,&e); //多项式系数和指数项
    }
    rear -> next = NULL;
    return(head);
}
两个一元多项式相加

img

算法实现：（多种情况需要分类讨论）

vpid polyadd(Polylist polya, Polylist polyb)
{
    //和多项式存放在多项式polya中，并姜多项式polyb删除
    Polynode *p, *q, *tail, *temp;
    int sum;
    p = polya -> next;
    q = polyb -> next;
    tail = polya; //tail指向和多项式的尾结点
    while (p != NULL && q != NULL)
    {
        if (p -> exp < q -> exp)
        {
            tail -> next = p;
            tail = p;
            p = p -> next;
        }
        else if (p -> exp == q -> exp)
        {
            sum = p -> coef + q -> coef; //如果指数相等，则将系数相加
            if (sum != 0)
            {
                p -> coef = sum;
                tail -> next = p;
                tail = tail -> next;
                p = p -> next;
                q = q -> next;
            }
            else //若系数和为0，则删除结点p、q，将指针指向下一个结点
            {
                temp = p -> next;
                free (p);
                p = temp;
                temp = q -> next;
                free (q);
                q = temp;
            }
        }
        else  //将q结点加入到和多项式中
        {
            tail -> next = q;
            tail = q;
            q = q -> next;
        }
    }
    if (p != NULL)
    {
        tail -> next = p; //若多项式A中还有剩余，则将剩余的结点都加入到和多项式中
    }
    else
    {
        tail -> next = q; //否则将B中的结点加入到和多项式中
    }
}
◾线性表 总结与反思
空间

顺序表的存储空间是静态分配的，在程序执行之前必须明确规定它的存储规模，如果线性表的长度变化较大，则存储规模难以预先确定。
线性表的存储空间是动态分配的，只要空间尚有空余，就不会产生溢出。

存储密度，结点数据本身所占的存储量和整个结点结构所占的存储量之比，存储密度越大，存储空间的利用率越高，顺序表的存储密度为1，而链表的存储密度小于1。

时间

顺序表由向量实现，是一种随机存取结构，对表中任一结点都可以在O(1)时间内直接地存取，而链表中的结点则需要从头指针起顺着链查找才能取得。—>便于查找

链表如果要进行插入删除操作，都只需要修改指针。对于频繁需要插入删除操作的线性表，则宜采用链表作为存储结构。但若表的插入或删除操作主要发生在表的首尾两端，则宜采用带尾指针的单循环链表。

Jasaxion
关注
专栏目录
算法与数据结构 --- 线性表 --- 顺序表示和实现
qq_51947882的博客
09-13 1237
list是线性表的英文名字，Elemset1. initialization 初始化2.销毁线性表的本质是将线性表从内存中删除3.置为空表的意思是将线性表中的元素全都删除1.数据元素判断函数的返回值类型是bool类型，当函数返回一个 true 时表示函数满足，返回一个false 时表示函数不满足2.这个函数会将我们传进来的 e 作为左参数，同时将 线性表中的每个元素依次作为右参数，左右参数进行比较，右参数依次变换，直到返回true为止，若比完了最后一个元素后仍无true则结束。
2.C-数据结构-线性表-线性表源码
09-07
2.C-数据结构-线性表-线性表源码
数据结构：线性表(List)【详解】
UniqueUnit的博客
02-18 12万+
线性表 一、线性表的定义 线性表（List）：零个或多个数据元素的有限序列。 线性表的数据集合为{a1,a2,…,an}，假设每个元素的类型均为DataType。其中，除第一个元素a1外，每一个元素有且只有一个直接前驱元素，除了最后一个元素an外，每一个元素有且只有一个直接后继元素。数据元素之间的关系是一对一的关系。 在较复杂的线性表中，一个数据元素可以由若干个数据项组成。在这种情况下，常把数据元素称为记录，含有大量记录的线性表又称为文件 二、线性表的顺序标识和实现 概念：用一组地址连续的存储单元依次存储
从头开始嵌入式编程学习-数据结构-线性表-顺序线性表
reviewand的博客
04-01 1530
所以，在顺序存储结构的线性表中插入或者删除一个数据元素，平均约移动一半的元素，则算法ListInsert，和ListDelete的时间复杂度为。定义一个动态分配顺序存储结构（因为线性表是一个灵活的数据结构，可以根据需要来增长，首先，对动态线性表进行初始化操作，构造一个空的线性表(初始化线性表)List。一般的，我们可以假设线性表的任何位置上插入或删除的概率都是相等的,即。常用的线性结构有：线性表，栈，队列，循环队列，数组。线性表：线性表中的数据元素可以是各种各样的，2.2.3 顺序线性表元素的插入。
数据结构——学习笔记——入门必看【建议收藏】
热门推荐
刘鑫磊
02-09 43万+
（2）静态查找表&动态查找表的区别用法【顺序查找-线性查找-折半查找-二分查找-有序表查找-插值查找-斐波那契查找-索引顺序表查找-分块查找】单独使用顺序存储结构（即数组）无法很好地实现树的存储概念，不过如果充分利用顺序存储和链式存储结构的特点，则完全可以实现对数的存储结构的表示。深度为 2，则至多只有 3 个结点：根结点，根结点的左子树，根结点的右子树···指的是这样一个数列：1、1、2、3、5、8、13、21、……（3）四中常见的多路查找树【2-3 树$2-3-4 树$B 树$B+ 树】的区别用法。
数据结构-线性表-思维导图+小结
学习记录
11-12 2467
数据结构-线性表-思维导图+习题小结
数据结构-线性表-顺序存储
zc_huiyanruju的博客
01-02 1865
数据结构-线性表-顺序存储
数据结构-----线性表
m0_64904378的博客
01-14 1502
线性表是具有相同数据类型的数据元素的一个有限序列。该序列所含的数据元素的个数是线性表的长度，一般使用 n 来表示。当 n=0 的时候，该线性表为空表。需要注意的是，线性表中的元素位置是使用下标来标注，生活中说的元素第 i 个元素，一般在线性表的下标中的 i-1 的位置，线性表中的元素下标是从 0 开始，而我们所说的数据位序是从1开始。从线性表的定义可以得到以下特性：1.有穷性：一个线性表中的元素个数是有限的。2.一致性： 一个线性表中的元素的性质相同。（即元素中的数据类型相同）3.序列性。
【数据结构】详细剖析线性表
蒙奇D索大的博客
12-31 1752
【数据结构】第二章——线性表（9） 总结了线性表的基本知识点，并对循序表与链表进行了比较
数据结构-线性表的链式表示
pyc68的博客
06-25 1206
本篇文章主要介绍线性表的链式表示
数据结构 - 线性表（C语言版）
weixin_41733225的博客
07-11 2320
主要讲述顺序表和单链表的基础操作
数据结构--线性表--思维导图.pdf
08-29
数据结构--线性表--思维导图.pdf 该资源主要讲解了数据结构中的线性表，包括线性表的定义、基本操作、顺序表和链表的存储方式、操作效率比较等。 线性表的定义： 线性表是一种逻辑结构，表示元素之间一对一相邻的...
数据结构学习--线性表及其应用--顺序表
06-25
线性表是数据结构的基础，它是由n（n>=0）个相同类型元素构成的有限序列。线性表按照存储方式可以分为顺序表和链表。顺序表是将线性表中的元素顺序地存储在一块连续的内存空间里，通常采用数组作为其底层实现。这种...
数据结构学习--线性表及其应用--链表
06-25
线性表是一种基础的数据结构，它是由n（n>=0）个相同类型元素构成的有限序列。在计算机科学中，线性表可以采用顺序存储结构或链式存储结构来实现。本篇主要讨论的是链式存储结构的线性表，也就是链表。 链表是一种...
数据结构实验报告-线性表-两个有序线性表的归并算法
04-10
本次实验的主题是“数据结构实验报告-线性表-两个有序线性表的归并算法”。实验的主要目的是让学生掌握两个有序线性表的归并算法。具体来说，实验要求学生通过键盘输入数据来建立两个有序线性表，并最终将这两个有序...
数据结构，问题 F: 括弧匹配检验
nick_912912的博客
11-02 291
假设表达式中允许包含两种括号：圆括号和方括号，其嵌套的顺序随意，如（［ ］（））或［（［ ］［ ］）］等为正确的匹配，［（ ]）或（［ ］（ ）或 ( ( ) ) ）均为错误的匹配。输入一个只包含圆括号和方括号的字符串，判断字符串中的括号是否匹配，匹配就输出 “OK” ，不匹配就输出“Wrong”。匹配就输出 “OK” ，不匹配就输出“Wrong”。现在的问题是，要求检验一个给定表达式中的括弧是否正确匹配？输入仅一行字符（字符个数小于255）输入一个字符串：［（［］［］）］，输出：OK。
python数据类型-8-数据结构-Queue (队列)
Lookontime的博客
10-30 323
在python数据类型系列文章中已经介绍了 python的各种数据类型，队列（Queue）是一种非常重要的数据结构，但并不是python的数据类型，队列遵循先进先出（FIFO）的原则，即先插入的元素先被移除，主要的用途是为了支持线程安全和高效的队列操作而设计的！
数据结构(8.7_1)——外部排序
最新发布
m0_65240792的博客
11-03 102
输出缓冲区1空了用归并段1的下一块元素补上 ..... 顺序的两个归并段方法一样..... 由于文件总块数无法改变，所以只能对归并趟数进行改变 注意：k不能无限增大、若k太大了也会增加内部归并所需时间在缓冲区内直接排序
代码随想录：从中后/中前遍历序列构造二叉树
qq_74924951的博客
10-30 317
两种遍历生成二叉树
数据结构-线性表详解
线性表是数据结构中最基础也是最常用的一种类型，它由n个数据元素构成的有限序列，这里的n可以为0，表示空表。线性表的每一个元素都有一个唯一的前驱和后继，除了首元素没有前驱，尾元素没有后继。 线性表的类型...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值