【数据结构】线性表

已于 2024-10-03 09:48:23 修改
阅读量309 收藏
点赞数 1
分类专栏： 数据结构与算法 408 文章标签： 数据结构 c++
于 2024-10-02 23:32:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_76119663/article/details/142686907
版权

静态分配顺序表

// 静态分配顺序表
// 1. 顺序存储类型
#define MaxSize 50
typedef struct
{
    // Elemtype data[MaxSize];
    int data[MaxSize];
    int length;
} SqList;

// 2. 初始化
void InitList(SqList &L)
{
    L.length = 0;
}

// 3. 插入元素
// bool ListINert(SqList &L, int i, Elemtype e)
bool ListInsert(SqList &L, int i, int 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;
    L.length++;
    return true;
}

// 4. 删除
// bool ListDelete(SqList &L, int i ,Elemtype &e)
bool ListDelete(SqList &L, int i, int &e)
{
    if (i < 1 || i > L.length)
        return false;
    e = L.data[i - 1];
    for (int j = i; j <= L.length; j++)
    {
        L.data[j - 1] = L.data[j];
    }
    L.length--;
    return true;
}

// 5. 按位查找
int GetElem(SqList L, int i)
{
    return L.data[i - 1];
}

// 5. 按值查找
// int LocateElem(SqList &L, Elemtype &e)
int LocateElem(SqList &L, int &e)
{
    for (int i = 0; i < L.length; i++)
    {
        if (L.data[i] == e)
            return i + 1;
    }
    return 0;
}

动态分配顺序表

// 动态分配顺序表
// 1. 顺序存储类型

#define InitSize 50
typedef struct
{
    // Elemtype *data;
    int *data;
    int MaxSize, length;
} SqList;

// 2. 初始化
void InitList(SqList &L)
{
    // L.data = (Elemtype *)malloc(sizeof(Elemtype) * InitSize);
    L.data = (int *)malloc(sizeof(int) * InitSize);
    L.length = 0;
    L.MaxSize = InitSize;
}

// 3. 插入元素
// bool ListINert(SqList &L, int i, Elemtype e)
bool ListInsert(SqList &L, int i, int 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;
    L.length++;
    return true;
}

// 4. 删除
// bool ListDelete(SqList &L, int i ,Elemtype &e)
bool ListDelete(SqList &L, int i, int &e)
{
    if (i < 1 || i > L.length)
        return false;
    e = L.data[i - 1];
    for (int j = i; j <= L.length; j++)
    {
        L.data[j - 1] = L.data[j];
    }
    L.length--;
    return true;
}

// 5. 按位查找
int GetElem(SqList L, int i)
{
    return L.data[i - 1];
}

// 5. 按值查找
// int LocateElem(SqList &L, Elemtype &e)
int LocateElem(SqList &L, int &e)
{
    for (int i = 0; i < L.length; i++)
    {
        if (L.data[i] == e)
            return i + 1;
    }
    return 0;
}

带头结点的单链表

typedef struct LNode
{
    // ElemType data;
    int data;
    struct LNode *next;
} LNode, *LinkList;

// 1.单链表的初始化
// （有头结点）
bool InitList(LinkList &L)
{
    L = (LNode *)malloc(sizeof(LNode));
    if (L == NULL)
        return false;
    L->next = NULL;
    return true;
}
// 没有头结点
bool InitList(LinkList &L)
{
    L = NULL;
    return true;
}

// 2.尾插法建立单链表
LinkList List_TailInsert(LinkList &L)
{
    int x;
    // 创建头结点
    L = (LinkList)malloc(sizeof(LNode));
    // r为尾结点，s为每次创建的新结点
    LNode *s, *r = L;
    scanf("%d", &x);
    while (x != 9999)
    {
        s = (LNode *)malloc(sizeof(LNode));
        s->data = x;
        r->next = s;
        r = s;
        scanf("%d", &x);
    }
    // 尾结点置为空
    r->next = NULL;
    return L;
}

// 3.头插法创建单链表
LinkList List_HeadInsert(LinkList &L)
{
    int x;
    LNode *s;
    L = (LinkList)malloc(sizeof(LNode));
    L->next = NULL;
    scanf("%d", &x);
    while (x != 9999)
    {
        s = (LNode *)malloc(sizeof(LNode));
        s->data = x;
        s->next = L->next;
        L->next = s;
        scanf("%d", &x);
    }
    return L;
}

// 4.插入节点
// p = GetElem(L, i - 1);
// s->next = p->next;
// p->next = s;

// 5.在第i个位置后插入节点操作（带头结点）
// bool ListInsert(LinkList &L, int i, ElemType e)
bool ListInsert(LinkList &L, int i, int e)
{
    if (i < 1)
        return false;
    // p指向当前扫描到的节点
    LNode *p;
    int j = 0;
    p = L;
    while (p != NULL && j < i - 1)
    {
        p = p->next;
        j++;
    }
    if (p == NULL)
        return false;
    LNode *s = (LNode *)malloc(sizeof(LNode));
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}

// 6.在第i个位置后插入节点操作（不带头结点)
bool ListInsert(LinkList &L, int i, int e)
{
    if (i < 1)
        return false;
    if (i == 1)
    {
        LNode *s = (LNode *)malloc(sizeof(LNode));
        s->data = e;
        s->next = L;
        // 头指针指向新节点
        L = s;
        return true;
    }
    LNode *p;
    p = L;
    // 注意j的取值
    int j = 1;
    while (p != NULL && j < i - 1)
    {
        p = p->next;
        j++;
    }
    if (p == NULL)
        return false;
    LNode *s = (LNode *)malloc(sizeof(LNode));
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}

// 7.在第i个位置之前插入节点操作
bool InsertPriorNode(LNode *p, int e)
{
    if (p == NULL)
        return false;
    LNode *s = (LNode *)malloc(sizeof(LNode));
    if (s == NULL)
        return false;
    s->next = p->next;
    p->next = s;
    s->data = p->data;
    p->data = e;
    return true;
}

// 8.在第i个位置删除节点操作（带头结点）
bool ListDelete(LinkList &L, int i, int e)
{
    if (i < 1)
        return false;
    LNode *p;
    int j = 0;
    p = L;
    while (p != NULL && j < i - 1)
    {
        p = p->next;
        j++;
    }
    if (p == NULL)
        return false;
    if (p->next == NULL)
        return false;
    LNode *q = p->next;
    e = q->data;
    p->next = p->next->next;
    free(q);
    return true;
}

// 9.删除指定节点
bool DeleteNode(LNode *p)
{
    if (p == NULL)
        return false;
    LNode *q = p->next;
    p->next = q->next;
    free(q);
    return true;
}

// 10.按序号查找节点值
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 != NULL && j < i)
    {
        p = p->next;
        j++;
    }
    return p;
}
// 另外一个版本
// LNode *GetElem(LinkList L, int i)
// {
//     if (i < 1)
//         return NULL;
//     int j = 0;
//     LNode *p = L;
//     while (p != NULL && j < i)
//     {
//         p = p->next;
//         j++;
//     }
//     return p;
// }

// 11.按值查找表节点
LNode *LocateElem(LinkList L, int e)
{
    LNode *p = L;
    if (p == NULL)
        return false;
    while (p != NULL && p->date != e)
    {
        p = p->next;
    }
    return p;
}

// 12.求表长（不含头结点）
int Length(LinkList L)
{
    int len = 0;
    LNode *p = L;
    while (p->next != NULL)
    {
        p = p->next;
        len++;
    }
    return len;
}

双链表

// 有两个指针，一个prior，一个next
typedef struct DNode
{
    int data;
    struct DNode *prior, *next;
} DNode, *DLinkList;

// 1.初始化双链表
bool InitDLinkList(DLinkList &L)
{
    L = (DNode *)malloc(sizeof(DNode));
    if (L == NULL)
        return false;
    // 头结点的prior永远指向NULL，头结点之后暂时还没有节点
    L->prior = NULL;
    L->next = NULL;
    return true;
}

// 2.双链表中插入操作
bool InsertNextDNode(DNode *p, DNode *s)
{
    if (p == NULL || s == NULL)
        return false;
    s->next = p->next;
    // 如果p节点有后继结点
    // 如果是循环双链表，这个if判断可以省略
    if (p->next != NULL)
        p->next->prior = s;
    s->prior = p;
    p->next = s;
    return true;
}

// 3.循环双链表中删除操作
bool DeleteNextNode(DNode *p, DNode *s)
{
    if (p == NULL)
        return false;
    DNode *q = p->next;
    if (q == NULL)
        return false;
    p->next = q->next;
    if (q->next != NULL)
        q->next->prior = p;
    return true;
}
Shadow10260530
关注
专栏目录
数据结构线性表
04-08
线性表是最基本、最简单、也是最常用的一种数据结构。线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的（注意，这句话只适用大部分线性表，而不是全部。
c语言数据结构线性表创建删除插入
06-30
本主题聚焦于C语言中的数据结构——线性表，这是数据结构的基础概念之一，适用于初学者学习。线性表是一种逻辑上一维、元素之间具有线性关系的数据结构。下面将详细阐述线性表的创建、删除和插入操作。 1. **线性表...
数据结构线性表基本操作
热门推荐
lizhi20210729的博客
11-20 1万+
数据结构线性表基本操作基本内容线性表的顺序表示和实现线性表的顺序存储表示顺序表中基本操作的实现 基本内容 因为第一次数据结构阶段考写代码又想规范写又写不出规范的可读性强的代码，让我第一次意识到自己应该在这方面下一些功夫。这篇文章是记录自己把书上写的算法打到电脑上遇到的问题。 线性表的顺序表示和实现 线性表的顺序存储表示 将书中代码复刻如下： #define MAXSIZE 100//顺序表可能达到的最大长度 typedef struct { ElemType *elem;//储存空间的基地址
数据结构 线性表
qq_52847866的博客
06-14 1553
其中，数组实现的线性表具有随机访问的优势，可以通过索引直接访问元素，而链表实现的线性表具有动态插入和删除的优势。哈希表：哈希表是一种基于数组的线性表，通过哈希函数将关键字映射到数组的索引位置，用于高效地查找、插入和删除元素。链表：链表是一种链式存储的线性表，适用于频繁插入和删除元素的场景。这些只是线性表在各个领域中的一些应用示例，实际上线性表作为一种基础数据结构，几乎在所有计算机科学和软件开发的领域中都有广泛的应用。，并实现了初始化、获取长度、判断是否为空、获取元素、插入元素、删除元素和输出线性表的函数。
C语言数据结构线性表
qq_55391702的博客
01-17 928
线性表线性表的类型定义 线性表的类型定义 线性表是常用且最简单的一种数据结构。简言之一个线性表是n个数据元素的有限序列。至于每个数据元素的具体含义，在不同的情况下各不相同，它可以是一个数一个符号也可以是一页书，甚至是其他更复杂的信息。 ...
数据结构——线性表
odoaobo的博客
08-31 1927
线性表的顺序储存又称顺序表概念：用一组地址连续的存储单元依次存储线性表中的数据元素的线性表。特点：表中的元素逻辑顺序和物理顺序相同。1. 静态顺序表：使用定长数组存储元素。//定长数组//有效数据个数}SeqList2. 动态顺序表：使用动态开辟的数组存储。//指向开辟空间的数组int size;//有效数据的个数//容量空间的大小}SL;线性表的链式存储又称单链表，它是指通过一组任意的存储单元来存储线性表中的数据元素。链表的节点处理存储元素自身的信息外，还需要存放一个后继的指针。
数据结构 线性表 插入 删除
mmmm0303的博客
04-22 1万+
数据结构线性表的插入，删除 任务描述 本关任务：实现 step1/Seqlist.cpp 中的SL_InsAt、SL_DelAt和SL_DelValue三个操作函数，以实现线性表中数据的插入、删除与查找等功能。 相关知识) 线性表是最基本、最简单、也是最常用的一种数据结构。线性表结构中，数据元素之间通过一对一首尾相接的方式连接起来。具体实现时，线性表可以采用不同的存储策略。下面给出了一种基于顺序存...
数据结构线性表元素的删除
qq_46153158的博客
09-24 2833
线性表的创建，元素的删除 #include<stdio.h> #define MAXSIZE 100 typedef int ElemType; /*定义线性表*/ typedef struct { ElemType list[MAXSIZE];//顺序表元素 int last; //顺序表当前长度 }SeqList; /*创建空表*/ void InitList(SeqList *L) { L->last=-1; } /*输入递增有序顺序表*/ void Pu
数据结构：线性表
y_h_k_666的博客
03-28 2835
线性表是基本的数据结构之一，是一组元素的抽象。 线性表包含顺序表和链接表（简称链表），顺序表在C语言中一般使用数组去实现，链表使用结构体去实现。在Python中，list对象是采用顺序表实现的。 1. 顺序表 顺序表是将表中的元素顺序的存储在连续的内存里。 优点： 查询速度快，时间复杂度为O(1) 缺点： 插入元素速度慢，时间复杂度为O(n) 表中元素个数需要提前定义 2. 链表 链表：通过链接各个结点实现的技术就叫做链表。链表中的结点分为指针域和数据域，具体见下图。结点中的data用来存放数据
【数据结构线性表练习题】
爱喝阔落的猫的博客
07-18 1023
代码】【数据结构线性表练习题】
数据结构线性表的定义、初始化和创建
qq_48471248的博客
07-29 2014
SqList//该语句表示这是一个顺序表。intlength;//顺序表的当前长度。intdata[MaxSize];//设置为用数组存放元素。//初始化一个顺序表。
数据结构线性表的C语言代码
06-27
适合学习数据结构的同学
数据结构 线性表PPT学习教案.pptx
10-05
数据结构中的线性表是一种基础且重要的数据组织形式，它由一个有序的元素序列组成，这些元素可以是任何数据类型。线性表的抽象数据类型（ADT）定义了对这种数据结构的操作集，包括创建、销毁、检查是否为空、获取...
数据结构（二叉树）
最新发布
2301_80475151的博客
10-04 982
数据结构的二叉树、顺序结构的树和链式结构的树的实现
【笔记】数据结构12
m0_52024881的博客
09-29 582
看到的社区的一个知识总结，这里记录一下。
数据结构之树（3）
2301_76246515的博客
09-29 391
重要！树->二叉树由于孩子兄弟链式存储和二叉树链式存储本质相同，故树可转换为二叉树。森林->二叉树森林：m棵互不相交的树的集合森林->树 树->二叉树森林中各个树的根节点之间视为兄弟关系。
栈数据结构:定义，基本操作与应用
m0_66847953的博客
10-03 865
栈（Stack）是一种特殊的线性数据结构，其插入和删除操作都只允许在表的一端进行。这一端被称为栈顶（top），另一端则被称为栈底（bottom）。栈遵循后进先出（Last In First Out，LIFO）的规则，即最后存入的元素将被最先取出。顺序栈采用一个数组存放栈中的元素。如果需要用到两个类型相同的栈，这时若为它们各自开辟一个数组空间,极有可能出现这样的情况：第一个栈已满,再进栈就溢出了，而另一个栈还有很多空闲的存储空间。解决这个问题的方法是。
Java.数据结构.TreeSet
TJKFYY的博客
10-03 221
TreeSet是Java集合框架中的一部分，是基于TreeMap实现的。TreeSet保证了集合中的元素按照自然顺序或者通过提供的Comparator进行排序。：TreeSet会根据元素的自然顺序进行排序，确保集合中的元素总是处于有序状态，和TreeMap一样，我们同样可以通过重写Comparator方法来进行排序。：TreeSet中的元素是唯一的，不能重复。如果有两个元素相等，则后插入的元素不会出现在集合中。：TreeSet基于TreeMap实现，其时间复杂度为O(log n)。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值