24 线性表

最新推荐文章于 2024-05-22 18:47:12 发布
最新推荐文章于 2024-05-22 18:47:12 发布
阅读量53 收藏
点赞数
分类专栏： # C语言 文章标签： 链表 数据结构 算法 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62213357/article/details/128871835
版权

顺序表

单链表

特点

有限、数据类型都相同、顺序性

定义

#define MaxSize 50 //定义线性表的长度
typedef struct{
    ElemType data[MaxSize];//顺序表的元素
    int len;//顺序表的当前长度
}SqList;//顺序表的类型定义
typedef struct LNode{   //单链表结点类型
    ElemType data;//数据域
    struct LNode *next;//指针域
}LNode,*LinkList;

优点

可以随机存取（根据表头元素地址和元素序号）表中任意一个元素。

存储密度高，每个结点只存储数据元素。

插入和删除操作不需要移动元素，只需要修改指针。

不需要大量的连续存储空间。

缺点

插入和删除操作需要移动大量元素。

线性表变化较大时，难以确定存储空间的容量。

存储分配需要一整段连续的存储空间，不够灵活。

单链表附加指针域，也存在浪费存储空间的缺点。

查找操作时需要从表头开始遍历，依次查找，不能随机存取。

插入操作

最好情况：在表尾插入元素，不需要移动元素，时间复杂度为O(1)。

最坏情况：在表头插入元素，所有元素依次后移，时间复杂度为O(n)。

平均情况：在插入位置概率均等的情况下，平均移动元素的次数为n/2，时间复杂度为O(n)。

代码

//判断插入位置i是否合法（满足1≤i≤len+1）
//判断存储空间是否已满（即插入x后是否会超出数组长度）
for(int j=L.len;j>=i;j--) //将最后一个元素到第i个元素依次后移一位
L.data[j]=L.data[j-1];
L.data[i-1]=x; //空出的位置i处放入x
L.len++; //线性表长度加1
//创建新结点代码：
q=(LNode*)malloc(sizeof(LNode))
q->data=x;
//(a) (b)操作的代码：
q->next=p->next;
p->next=q;
//(c)操作的代码：
p->next=q;
q->next=NULL;
//请分别用头插法和尾插法创建一个单链表

删除操作

最好情况：删除表尾元素，不需要移动元素，时间复杂度为O(1)。

最坏情况：删除表头元素，之后的所有元素依次前移，时间复杂度为O(n)。

平均情况：在删除位置概率均等的情况下，平均移动元素的次数为(n-1)/2，时间复杂度为O(n)。

代码

//判断删除位置i是否合法（满足1≤i≤len）
e=L.data[i-1]; //将被删除的元素赋值给e
for(int j=i;j<L.len;j++) //将删除位置后的元素依次前移
L.data[j-1]=L.data[j];
L.len--; //线性表长度减1
//(a)(b) (c)操作的代码：
p=GetElem(L,i-1);//查找删除位置的前驱节点
q=p->next;
p->next=q->next;
free(q);

动态分配

#define InitSize 100 //表长度的初始定义
typedef struct{
ElemType *data; //指示动态分配数组的指针
int MaxSize,length; //数组的最大容量和当前个数
}SeqList; //动态分配数组顺序表的类型定义
//C的初始动态分配语句为：
L.data=(ElemType*)malloc(sizeof(ElemType)*InitSize);
//C++的初始动态分配语句为：
L.data=new ElemType[InitSize];
//按序号查找结点值的算法如下：
LNode *p=L->next;
int j=1;
while(p&&j<i){
p=p->next;
j++;
}
return p;
//按值查找结点的算法如下：
LNode *p=L->next;
while(p!=NULL&&p->data!=e){
p=p->next;
}
return p;

【例】顺序表的初始化及插入操作实践

#include <stdio.h>
#define MaxSize 50

typedef int ElemType;

//静态分配
typedef struct{
    ElemType data[MaxSize];
    int length;//当前顺序表中有多少个元素
}SqList;

//动态分配
#define InitSize 100
typedef struct{
    ElemType *data;
    int capacity;//动态数组的最大容量
    int length;
}SeqList;

//i 代表插入的位置，从 1 开始，e 要插入的元素
bool ListInsert(SqList &L,int i,ElemType e)
{
    if(i<1||i>L.length+1)//判断要插入的位置是否合法
        return false;
    if(L.length>=MaxSize)//超出空间了
        return false;
    for(int j=L.length;j>=i;j--)//移动顺序表中的元素
        L.data[j]=L.data[j-1];
    L.data[i-1]=e;//数组下标从零开始，插入第一个位置，访问的下标为 0
    L.length+=1;
    return true;
}

//打印顺序表元素
void PrintList(SqList L)
{
    for(int i=0;i<L.length;i++)
    {
        printf("%4d",L.data[i]);
    }
    printf("\n");
}

int main()
{
    SqList L;//顺序表的名称
    bool ret;//查看返回值，布尔型是 True,或者 False
    ElemType del;//要删除的元素
//首先手动在顺序表中赋值
    L.data[0]=1;
    L.data[1]=2;
    L.data[2]=3;
    L.length=3;//总计三个元素
    ret=ListInsert(L,2,60);
    if(ret)
    {
        printf("插入成功\n");
        PrintList(L);
    }else{
        printf("插入失败\n");
    }
    return 0;
}

【例】顺序表的删除及查询实战

#include <stdio.h>
#define MaxSize 50

typedef int ElemType;

//静态分配
typedef struct{
    ElemType data[MaxSize];
    int length;//当前顺序表中有多少个元素
}SqList;

//动态分配
#define InitSize 100
typedef struct{
    ElemType *data;
    int capacity;//动态数组的最大容量
    int length;
}SeqList;

//i 代表插入的位置，从 1 开始，e 要插入的元素
bool ListInsert(SqList &L,int i,ElemType e)
{
    if(i<1||i>L.length+1)//判断要插入的位置是否合法
        return false;
    if(L.length>=MaxSize)//超出空间了
        return false;
    for(int j=L.length;j>=i;j--)//移动顺序表中的元素
        L.data[j]=L.data[j-1];
    L.data[i-1]=e;//数组下标从零开始，插入第一个位置，访问的下标为 0
    L.length+=1;
    return true;
}

//删除使用元素 e 的引用的目的是拿出对应的值
bool ListDelete(SqList &L,int i,ElemType &e)
{
    if(i<1||i>L.length)//如果删除的位置是不合法
        return false;
    e=L.data[i-1];//获取顺序表中对应的元素，赋值给 e
    for(int j=i;j<L.length;j++)
        L.data[j-1]=L.data[j];
    L.length-=1;//删除一个元素，顺序表长度减 1
    return true;
}

//查找成功，返回位置，位置从 1 开始，查找失败，返回 0
int LocateElem(SqList L,ElemType e)
{
    int i;
    for(i=0;i<L.length;i++)
        if(L.data[i]==e)
            return i+1;//加 1 就是元素在顺序表中的位置
    return 0;
}

//打印顺序表元素
void PrintList(SqList L)
{
    for(int i=0;i<L.length;i++)
    {
        printf("%4d",L.data[i]);
    }
    printf("\n");
}

int main()
{
    SqList L;//顺序表的名称
    bool ret;//查看返回值，布尔型是 True,或者 False
    ElemType del;//要删除的元素

    //首先手动在顺序表中赋值
    L.data[0]=1;
    L.data[1]=2;
    L.data[2]=3;
    L.length=3;//总计三个元素
    ret=ListInsert(L,2,60);
    if(ret)
    {
        printf("插入成功\n");
        PrintList(L);
    }else{
        printf("插入失败\n");
    }
    
    ret=ListDelete(L,1,del);
    if(ret)
    {
        printf("删除成功\n");
        printf("删除元素值为 %d\n",del);
        PrintList(L);
    }else{
        printf("删除失败\n");
    }
    ret=LocateElem(L,60);
    if(ret)
    {
        printf("查找成功\n");
        printf("元素位置为 %d\n",ret);
    }else{
        printf("查找失败\n");
    }
    return 0;
}

【例】头插法新建链表实战

#include <stdio.h>
#include <stdlib.h>

typedef int ElemType;

typedef struct LNode {
    ElemType data;
    struct LNode* next;//指向下一个结点
}LNode, * LinkList;

//头插法新建链表
LinkList list_head_insert(LinkList& L)
{
    LNode* s; int x;
    L = (LinkList)malloc(sizeof(LNode));//带头结点的链表
    L->next = NULL;//L->data 里边没放东西
    scanf("%d", &x);//从标准输入读取数据
    //3 4 5 6 7 9999
    while (x != 9999) {
        s = (LNode*)malloc(sizeof(LNode));//申请一个新空间给 s，强制类型转换
        s->data = x;//把读取到的值，给新空间中的 data 成员
        s->next = L->next;//让新结点的 next 指针指向链表的第一个元素（第一个放我们数据的元素）
        L->next = s;//让 s 作为第一个元素
        scanf("%d", &x);//读取标准输入
    }
    return L;
}

//打印链表中每个结点的值
void print_list(LinkList L)
{
    L = L->next;
    while (L != NULL)//NULL 是为了代表一张空的藏宝图
    {
        printf("%3d", L->data);//打印当前结点数据
        L = L->next;//指向下一个结点
    }
    printf("\n");
}

int main()
{
    LinkList L;//链表头，是结构体指针类型
    list_head_insert(L);//输入数据可以为 3 4 5 6 7 9999,头插法新建链表
    print_list(L);//链表打印
    return 0;
}

【例】尾插法新建链表实战

尾插法的特点是始终让尾指针r指向链表的尾部。

#include <stdio.h>
#include <stdlib.h>

typedef int ElemType;

typedef struct LNode{
    ElemType data;
    struct LNode *next;//指向下一个结点
}LNode,*LinkList;

//头插法新建链表
LinkList list_head_insert(LinkList &L)
{
    LNode *s;int x;
    L=(LinkList)malloc(sizeof(LNode));//带头结点的链表
    L->next=NULL;//L->data 里边没放东西
    scanf("%d",&x);//从标准输入读取数据
    //3 4 5 6 7 9999
    while(x!=9999){
        s=(LNode*)malloc(sizeof(LNode));//申请一个新空间给 s，强制类型转换
        s->data=x;//把读取到的值，给新空间中的 data 成员
        s->next=L->next;//让新结点的 next 指针指向链表的第一个元素（第一个放我们数据的元素）
        L->next=s;//让 s 作为第一个元素
        scanf("%d",&x);//读取标准输入
    }
    return L;
}

//尾插法新建链表
LinkList list_tail_insert(LinkList &L)
{
    int x;
    L=(LinkList)malloc(sizeof(LNode));//带头节点的链表
    LNode* s, * r = L;//LinkList s,r=L;也可以，r 代表链表表尾结点，指向链表尾部
    //3 4 5 6 7 9999
    scanf("%d",&x);
    while(x!=9999){
        s=(LNode*)malloc(sizeof(LNode));
        s->data=x;
        r->next=s;//让尾部结点指向新结点
        r=s;//r 指向新的表尾结点
        scanf("%d",&x);
    }
    r->next=NULL;//尾结点的 next 指针赋值为 NULL
    return L;
}

//打印链表中每个结点的值
void print_list(LinkList L)
{
    L=L->next;
    while(L!=NULL)//NULL 是为了代表一张空的藏宝图
    {
        printf("%3d",L->data);//打印当前结点数据
        L=L->next;//指向下一个结点
    }
    printf("\n");
}

int main()
{
    LinkList L;//链表头，是结构体指针类型
    //list_head_insert(L);//输入数据可以为 3 4 5 6 7 9999,头插法新建链表
    list_tail_insert(L);//输入数据可以为 3 4 5 6 7 9999
    print_list(L);//链表打印
    return 0;
}

【例】按位置查找及按值查找实战

按位置查找要注意判断查找位置是否合法。

#include <stdio.h>
#include <stdlib.h>

typedef int ElemType;

typedef struct LNode{
    ElemType data;
    struct LNode *next;//指向下一个结点
}LNode,*LinkList;

//头插法新建链表
LinkList list_head_insert(LinkList &L)
{
    LNode *s;int x;
    L=(LinkList)malloc(sizeof(LNode));//带头结点的链表
    L->next=NULL;//L->data 里边没放东西
    scanf("%d",&x);//从标准输入读取数据
    //3 4 5 6 7 9999
    while(x!=9999){
        s=(LNode*)malloc(sizeof(LNode));//申请一个新空间给 s，强制类型转换
        s->data=x;//把读取到的值，给新空间中的 data 成员
        s->next=L->next;//让新结点的 next 指针指向链表的第一个元素（第一个放我们数据的元素）
        L->next=s;//让 s 作为第一个元素
        scanf("%d",&x);//读取标准输入
    }
    return L;
}

//尾插法新建链表
LinkList list_tail_insert(LinkList &L)
{
    int x;
    L=(LinkList)malloc(sizeof(LNode));//带头节点的链表
    LNode* s, * r = L;//LinkList s,r=L;也可以，r 代表链表表尾结点，指向链表尾部
    //3 4 5 6 7 9999
    scanf("%d",&x);
    
    while(x!=9999){
        s=(LNode*)malloc(sizeof(LNode));
        s->data=x;
        r->next=s;//让尾部结点指向新结点
        r=s;//r 指向新的表尾结点
        scanf("%d",&x);
    }
    r->next=NULL;//尾结点的 next 指针赋值为 NULL
    return L;
}

//按序号查找结点值，NULL 代表查找的结点不存在
LNode *GetElem(LinkList L,int i)
{
    int j=1;
    LNode *p=L->next;
    if(i==0)
    return L;
    if(i<1)
    return NULL;
    while(p&&j<i)
    {
        p=p->next;
        j++;
    }
    return p;
}

//按值查找，返回 NULL 代表没找到
LNode *LocateElem(LinkList L,ElemType e)
{
    LNode *p=L->next;
    while(p!=NULL&&p->data!=e)
    p=p->next;
    return p;
}

    //打印链表中每个结点的值
void print_list(LinkList L)
{
    L=L->next;
    while(L!=NULL)//NULL 是为了代表一张空的藏宝图
    {
        printf("%3d",L->data);//打印当前结点数据
        L=L->next;//指向下一个结点
    }
    printf("\n");
}

int main()
{
    LinkList L;//链表头，是结构体指针类型
    LinkList search;//用来存储拿到的某一个节点
    //list_head_insert(L);//输入数据可以为 3 4 5 6 7 9999,头插法新建链表
    list_tail_insert(L);//输入数据可以为 3 4 5 6 7 9999
    print_list(L);//链表打印
    search=GetElem(L,2);
    if(search!=NULL)
    {
        printf("Succeeded in searching by serial number\n");
        printf("%d\n",search->data);
    }
    search=LocateElem(L,6);//按值查询
    if(search!=NULL)
    {
        printf("Search by value succeeded\n");
        printf("%d\n",search->data);
    }
    return 0;
}

【例】往第i个位置插入元素实战

#include <stdio.h>
#include <stdlib.h>

typedef int ElemType;

typedef struct LNode{
    ElemType data;
    struct LNode *next;//指向下一个结点
}LNode,*LinkList;

//头插法新建链表
LinkList list_head_insert(LinkList &L)
{
    LNode *s;int x;
    L=(LinkList)malloc(sizeof(LNode));//带头结点的链表
    L->next=NULL;//L->data 里边没放东西
    scanf("%d",&x);//从标准输入读取数据
    //3 4 5 6 7 9999
    while(x!=9999){
        s=(LNode*)malloc(sizeof(LNode));//申请一个新空间给 s，强制类型转换
        s->data=x;//把读取到的值，给新空间中的 data 成员
        s->next=L->next;//让新结点的 next 指针指向链表的第一个元素（第一个放我们数据的元素）
        L->next=s;//让 s 作为第一个元素
        scanf("%d",&x);//读取标准输入
    }
    return L;
}

//尾插法新建链表
LinkList list_tail_insert(LinkList &L)
{
    int x;
    L=(LinkList)malloc(sizeof(LNode));//带头节点的链表
    LNode* s, * r = L;//LinkList s,r=L;也可以，r 代表链表表尾结点，指向链表尾部
    //3 4 5 6 7 9999
    scanf("%d",&x);
    while(x!=9999){
        s=(LNode*)malloc(sizeof(LNode));
        s->data=x;
        r->next=s;//让尾部结点指向新结点
        r=s;//r 指向新的表尾结点
        scanf("%d",&x);
    }
    r->next=NULL;//尾结点的 next 指针赋值为 NULL
    return L;
}

//按序号查找结点值
LNode *GetElem(LinkList L,int i)
{
    int j=1;
    LNode *p=L->next;
    if(i==0)
        return L;
    if(i<1)
        return NULL;
    while(p&&j<i)
    {
        p=p->next;
        j++;
    }
    return p;
}

//按值查找
LNode *LocateElem(LinkList L,ElemType e)
{
    LNode *p=L->next;
    while(p!=NULL&&p->data!=e)
        p=p->next;
    return p;
}

//新结点插入第 i 个位置
bool ListFrontInsert(LinkList L,int i,ElemType e)
{
    LinkList p=GetElem(L,i-1);
    if(NULL==p)
    {
        return false;
    }
    LinkList s=(LNode*)malloc(sizeof(LNode));//为新插入的结点申请空间
    s->data=e;
    s->next=p->next;
    p->next=s;
    return true;
}

//打印链表中每个结点的值
void print_list(LinkList L)
{
    L=L->next;
    while(L!=NULL)//NULL 是为了代表一张空的藏宝图
    {
        printf("%3d",L->data);//打印当前结点数据
        L=L->next;//指向下一个结点
    }
    printf("\n");
}

int main()
{
    LinkList L;//链表头，是结构体指针类型
    LinkList search;//用来存储拿到的某一个节点
    //list_head_insert(L);//输入数据可以为 3 4 5 6 7 9999,头插法新建链表
    list_tail_insert(L);//输入数据可以为 3 4 5 6 7 9999
    print_list(L);//链表打印
    //search=GetElem(L,2);
    //if(search!=NULL)
    //{
        // printf("按序号查找成功\n");
        // printf("%d\n",search->data);
    //}
    //search=LocateElem(L,6);//按值查询
    //if(search!=NULL)
    //{
        // printf("按值查找成功\n");
        // printf("%d\n",search->data);
    //}
    ListFrontInsert(L,2,99);//新结点插入第 i 个位置
    print_list(L);
    return 0;
}

【例】单链表的删除实战

#include <stdio.h>
#include <stdlib.h>

typedef int ElemType;

typedef struct LNode{
    ElemType data;
    struct LNode *next;//指向下一个结点
}LNode,*LinkList;

//头插法新建链表
LinkList list_head_insert(LinkList &L)
{
    LNode *s;int x;
    L=(LinkList)malloc(sizeof(LNode));//带头结点的链表
    L->next=NULL;//L->data 里边没放东西
    scanf("%d",&x);//从标准输入读取数据
    //3 4 5 6 7 9999
    while(x!=9999){
        s=(LNode*)malloc(sizeof(LNode));//申请一个新空间给 s，强制类型转换
        s->data=x;//把读取到的值，给新空间中的 data 成员
        s->next=L->next;//让新结点的 next 指针指向链表的第一个元素（第一个放我们数据的元素）
        L->next=s;//让 s 作为第一个元素
        scanf("%d",&x);//读取标准输入
    }
    return L;
}

//尾插法新建链表
LinkList list_tail_insert(LinkList &L)
{
    int x;
    L=(LinkList)malloc(sizeof(LNode));//带头节点的链表
    LNode* s, * r = L;//LinkList s,r=L;也可以，r 代表链表表尾结点，指向链表尾部
    //3 4 5 6 7 9999
    scanf("%d",&x);
    while(x!=9999){
        s=(LNode*)malloc(sizeof(LNode));
        s->data=x;
        r->next=s;//让尾部结点指向新结点
        r=s;//r 指向新的表尾结点
        scanf("%d",&x);
    }
    r->next=NULL;//尾结点的 next 指针赋值为 NULL
    return L;
}

//按序号查找结点值
LNode *GetElem(LinkList L,int i)
{
    int j=1;
    LNode *p=L->next;
    if(i==0)
        return L;
    if(i<1)
        return NULL;
    while(p&&j<i)
    {
        p=p->next;
        j++;
    }
    return p;
}

//按值查找
LNode *LocateElem(LinkList L,ElemType e)
{
    LNode *p=L->next;
    while(p!=NULL&&p->data!=e)
        p=p->next;
    return p;
}

//新结点插入第 i 个位置
bool ListFrontInsert(LinkList L,int i,ElemType e)
{
    LinkList p=GetElem(L,i-1);
    if(NULL==p)
    {
        return false;
    }
    LinkList s=(LNode*)malloc(sizeof(LNode));//为新插入的结点申请空间
    s->data=e;
    s->next=p->next;
    p->next=s;
    return true;
}

//删除第 i 个结点
bool ListDelete(LinkList L,int i)
{
    LinkList p=GetElem(L,i-1);
    if(NULL==p)
    {
        return false;
    }
    LinkList q;//用来存储要删除的结点地址
    q=p->next;
    p->next=q->next;//断链
    free(q);//释放对应结点的空间
    return true;
}

//打印链表中每个结点的值
void print_list(LinkList L)
{
    L=L->next;
    while(L!=NULL)//NULL 是为了代表一张空的藏宝图
    {
        printf("%3d",L->data);//打印当前结点数据
        L=L->next;//指向下一个结点
    }
    printf("\n");
}

int main()
{
    LinkList L;//链表头，是结构体指针类型
    //LinkList search;//用来存储拿到的某一个节点
    //list_head_insert(L);//输入数据可以为 3 4 5 6 7 9999,头插法新建链表
    list_tail_insert(L);//输入数据可以为 3 4 5 6 7 9999
    print_list(L);//链表打印
    //search=GetElem(L,2);
    //if(search!=NULL)
    //{
        // printf("按序号查找成功\n");
        // printf("%d\n",search->data);
    //}
    //search=LocateElem(L,6);//按值查询
    //if(search!=NULL)
    //{
        // printf("按值查找成功\n");
        // printf("%d\n",search->data);
    //}
    //ListFrontInsert(L,2,99);//新结点插入第 i 个位置
    //print_list(L);
    ListDelete(L,4);//删除第 4 个结点
    print_list(L);
    return 0;
}

orientation750
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线性表之顺序表合并.cpp
03-30
两个不同长度的线性表的合并，在合并过程中，两个线性表中共有的元素会自动删掉，合并后的线性表没有排序，如需排序，请看我之前发的线性表之顺序表实验
栈的实现
hjffly的技术积累
07-22 386
顺序实现：#define InitSize 100#define Increment 10#define NUM 5typedef int ElemType;typedef struct{ ElemType *base; ElemType *top; int size;}SqSt
顺序表的基本操作（C语言）
steve的专栏
04-25 1932
 #define List_Init_Size 100  //线性表初始分配量#define ListIncreament 10   //分配增量#include#includetypedef struct SqList{ int *elem;  //线性表中的元素 int Length;   //线性表的当前长度 int Listsize; //线性表的初始存储容量}SqList;//定义线性表
线性表的相关操作
qq_57355321的博客
10-16 859
实验1 实验题目 （1）设计一个有序顺序表类，即表中的数据元素按数据元素值递增有序。实现以下函 数： （a）把给定值 e 插入有序表中。 （b）删除值为 e 的所有数据元素。 （c）合并两个有序表，得到一个新的有序表。 （d）从有序顺序表中删除其值在给定值 s 与 t 之间（ s＜t）的所有元素，如果 s≥t 或 顺序表为空，则显示出错信息，并退出运行。 （2）针对带头结点的单链表，试编写下列函数： （a）定位函数：在单链表中寻找给定值的结点。若找到，则返回该结点的地址（返回位序即可..
线性表的初始化和插入操作
balong0331的博客
07-09 1162
抽象数据的定义 //矩形ADT的定义 //抽象类型的定义 ADT Rectangle{ length;//数据对象，非负实数，矩形的长 width:// 非负实数，矩形的宽 init(&R,length,width);//将矩形的 R的长和宽分别初始化为lengthh和width area...
线性表
编程爱好者的博客
05-21 114
1、定义： n个结点离散分配 彼此通过指针相连，每个结点只有一个前驱结点/后续结点 首结点没有前驱结点，尾节点无后续结点 2、专业术语： 头结点：不存储有效数据（加头节点目的主要是方便链表操作） 头指针：指向头节点的指针变量（存放头节点的地址） 首结点 尾结点 尾指针：指向尾节点的指针 3、确定一个单链表需要几个参数： 1、头指针 通过头指针可以推算出链表的其它所有信息 4、一个结点如何生...
小甲鱼数据结构和算法 学习笔记03--19-10-24线性表【16课线性表例题】
影扶疏
10-24 128
1、快速查找位置长度单链表的中间节点【单链表】 2、约瑟夫问题【单循环链表】 每逢3删掉
java 线性表_线性表的Java实现
weixin_42635064的博客
02-15 698
一、概念对于常用的数据结构，可分为线性结构和非线性结构，线性结构主要是线性表，非线性结构主要是数和图。当n>0时，表可表示为：(a0,a1,a2,a3,…an)1、 线性表的特征：1、存在唯一的被称作”第一个”的数据元素2、存在唯一的一个称作”最后一个的”数据元素”3、除第一个之外，集合中的每个数据元素均只有一个前驱4、除最后一个之外，集合中每个元素均只有一个后继2、线性表的基本操作1、初始...
@线性表
dc_989898的博客
10-14 154
线性表：简称表，是n（n≥0）个具有相同类型的数 据元素的有限序列。 线性表的长度：线性表中数据元素的个数。 空表：长度等于零的线性表，记为：L=(&nbsp; )。 非空表记为：L＝（a1, a2 , …, ai-1, ai,…, an) 其中，ai（1≤i≤n）称为数据元素； 下角标i 表示该元素在线性表中的位置或序号。 线性表的特性 1.&nbsp;&nbsp;&nbsp;&nbsp;&nb...
java线性表 示例_线性表结构的Java实现
weixin_29075633的博客
02-13 192
一、线性表的抽象数据类型表述线性表的结构简单，长度允许动态增长或搜索；可以对线性表中的任何数据元素进行访问和查找；允许进行数据的插入和删除操作；求线性表中的指定数据的前驱和后继；合并线性表以及拆分线性表中。Java JDK中有ArrayList和LinkedList两个类很好的实现了顺序存储和链式存储。因此学习数据结构的最好方式是去研究JDK源码。这里的代码个人作为练习，为了便于理解，很多地方处理...
线性表的操作
库阿茶
04-09 345
#include<iostream> #include<stdlib.h> using namespace std; typedef int ElemType; struct List{ ElemType *list; int size; int MaxSize; }; void InitList (List &L) { L.MaxSize = 1...
线性表的基础训练 链表
11-21
其中，文件中每行数据格式为“学号,姓名,年龄”，比如“SA10225048,[yyw1] 张三,24”。 （提示：采用顺序表结构时，顺序表中每个表元素包含三类信息：学号，姓名，和年龄；采用单链表结构时，单链表中每个结点的...
线性表的基础训练 顺序表
11-21
其中，文件中每行数据格式为“学号,姓名,年龄”，比如“SA10225048,[yyw1] 张三,24”。 （提示：采用顺序表结构时，顺序表中每个表元素包含三类信息：学号，姓名，和年龄；采用单链表结构时，单链表中每个结点的...
两个有序链表的合并
03-14
将两个有序的链表合并成一个链表，合并后的链表仍然是有序的，依次输出合并后的链表的元素值，并求出第奇数位置元素之和
data-structure:基本数据结构的定义及相关操作，如线性表（包括栈、队列）、树、图等
05-09
基本数据结构的定义及相关操作，如线性表（包括栈、队列）、树、图等 说明：数据结构详细实现和讲解在我的博客中可查看： 参考博客中《数据结构之XX》系列文章 【2020-12-24 更新】： 由于很多人反映之前的代码运行...
Java—选择排序
qq_56725871的博客
05-22 255
它的基本思想是从待排序的数据中选择最小（或最大）的元素，放到已排序序列的末尾（或开头），然后再从剩余未排序的元素中选择最小（或最大）的元素，放到已排序序列的末尾（或开头），以此类推，直到全部元素排序完成。选择排序的时间复杂度为O(n^2)，其中n为待排序数组的长度。尽管选择排序的时间复杂度较高，但它简单易懂，适用于小规模数据的排序。对于大规模数据，更高效的排序算法如快速排序和归并排序更为常用。以上代码通过遍历整个数组，找到剩余未排序部分的最小值，并将其与当前位置的元素交换，重复这个过程直到数组排序完成。
刷题篇--数据结构--链表
hyldzbg的博客
05-18 450
如果我们有一个链表是1-->2-->3-->4-->5这样的，那我们反转后就是5-->4-->3-->2-->1这样的，那么要如果对链表操作呢？我们可以发现在反转后的链表里1-->2,变成2-->1那么我们就顺着这个思路，直接将下一个节点插到头节点前不就好了！！看起来好像不是很难，但是实现起来却很简单😉👌，嘿嘿！(^0^)我们可以再思考一下，将一个节点插到头节点前不就是头插嘛对不对，所以我们可以直接利用头插的方法来解决问题。
数据结构：二叉树---堆
Auroral_0218的博客
05-18 657
二叉树是一种特殊的树结构，其中每个节点最多有两个子节点。堆是一个完全二叉树：除了最后一层外，其他层节点个数都是满的，最后一层的节点都集中在左侧。堆中每个节点的值大于等于（或小于等于）其子节点的值，这个性质被称为堆序性。堆是一种特殊的数据结构，用于存储和管理一组元素。它的主要作用包括：1. 优先级队列：堆可以将元素按照一定的优先级进行排序，使得可以快速访问和操作优先级最高的元素。这在诸如调度算法、事件处理等场景中非常有用。2. 堆排序：堆排序是一种高效的排序算法，它利用堆的性质将元素快速排序。
二叉树——基础知识详解
最新发布
2302_81016149的博客
05-22 1125
对于二叉树基础的理论知识，我们就学习到这里，虽然这些知识相对后面来说简单一点，但别忘记复习。有了这些预备知识才能够更好的理解后面知识。另外对于递归理解还不够的读者一定要去尽可能的去理解，对于二叉树的学习非常重要。今天的学习就结束了，有问题可在评论区交流，也可私信。我们下篇见！完！
线性表 insert
12-22
线性表的插入操作是指在线性表的指定位置插入一个元素。根据引用中的定义，线性表的顺序存储是通过一段地址连续的存储单元依次存储线性表的元素，所以在插入元素时需要将插入位置之后的元素依次后移，为新元素腾出...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值