数据结构：顺序表和单链表的实现

线性表是一种最基本、最常用的数据结构，它可以存储具有线性关系的数据元素。在线性表中，数据元素之间存在前驱和后继关系，每个元素有一个前驱元素和一个后继元素。线性表的主要操作包括插入、删除和查找等。

线性表有两种常见的数据结构实现方式：顺序表和单链表。

基础概念

顺序表

顺序表是一种基于数组实现的线性表数据结构。在顺序表中，数据元素按照其在内存中的物理地址顺序存储，可以直接访问任何一个元素。

顺序表具有以下特点：
存储空间固定：在创建顺序表时需要指定其大小，因此存储空间是固定的。
随机访问：可以快速访问任何一个元素，时间复杂度为O(1)。
插入和删除操作效率较低：在插入或删除元素时，需要移动后续的元素，因此时间复杂度为O(n)。

单链表

单链表是一种基于链表实现的线性表数据结构。在单链表中，每个元素存储了一个指向下一个元素的指针，所有元素通过这些指针连接在一起。

单链表具有以下特点：
存储空间动态：单链表中的元素可以根据需要动态添加或删除，不需要预先指定存储空间的大小。
插入和删除操作效率较高：在插入或删除元素时，只需要修改指向该元素的指针，因此时间复杂度为O(1)。
查找操作效率较低：在查找某个元素时，需要遍历整个链表，时间复杂度为O(n)。

代码实现

顺序表

函数的解释：

1. void InitList(SeqList &l): 初始化序列。将序列的长度初始化为0，表示序列为空。
2. int Length(SeqList l): 返回序列的长度。即返回序列中当前元素的个数。
3. int LocateElem(SeqList l, int e): 查找元素的位置。在序列中查找元素e，如果找到，返回该元素在序列中的位置（从1开始计数），如果未找到，则返回0。
4. int GetElem(SeqList l, int i): 获取指定位置的元素。返回序列中第i个位置的元素的值。
5. bool Insert(SeqList &l, int i, int e): 在指定位置插入元素。将元素e插入到序列的第i个位置，如果插入成功，返回true，否则返回false。
6. bool Delete(SeqList &l, int i, int &e): 删除指定位置的元素。删除序列中第i个位置的元素，被删除的元素的值将通过引用参数e返回。如果删除成功，返回true，否则返回false。
7. void Print(SeqList l): 打印序列。将序列中的所有元素依次打印输出。
8. bool Empty(SeqList l): 判断序列是否为空。如果序列中有元素，则返回false，否则返回true。

#include <iostream>
#include <cstdlib>
#define MaxSize 10

typedef struct
{
    int data[MaxSize]; // 存储序列元素的数组
    int length;        // 序列长度
} SeqList;

void InitList(SeqList &l)
{ // 初始化序列
    l.length = 0;
}

int Length(SeqList l)
{ // 返回序列长度
    return l.length;
}

int LocateElem(SeqList l, int e)
{ // 查找元素位置
    for (int i = 0; i < l.length; i++)
    {
        if (l.data[i] == e)
        {
            return i + 1; // 返回元素位置，从1开始计数
        }
    }
    return 0; // 没有找到元素，返回0
}

int GetElem(SeqList l, int i)
{ // 获取指定位置的元素
    return l.data[i - 1];
}

bool Insert(SeqList &l, int i, int e)
{ // 在指定位置插入元素
    if (l.length >= MaxSize || i < 1 || i > l.length + 1)
    {
        return false; // 插入失败，返回false
    }
    for (int idx = l.length; idx >= i; idx--)
    {
        l.data[idx] = l.data[idx - 1]; // 将指定位置后的元素向后移动一位
    }
    l.data[i - 1] = e; // 在指定位置插入新元素
    l.length++;        // 序列长度加1
    return true;       // 插入成功，返回true
}

bool Delete(SeqList &l, int i, int &e)
{ // 删除指定位置的元素
    if (l.length < 1 || i < 1 || i > l.length)
    {
        return false; // 删除失败，返回false
    }
    for (int idx = i; idx < l.length; idx++)
    {
        l.data[idx - 1] = l.data[idx]; // 将指定位置后的元素向前移动一位
    }
    l.length--;               // 序列长度减1
    e = l.data[l.length - 1]; // 将删除的元素赋值给e
    return true;              // 删除成功，返回true
}

void Print(SeqList l)
{ // 打印序列
    for (int i = 0; i < l.length; i++)
    {
        std::cout << l.data[i] << " ";
    }
}

bool Empty(SeqList l)
{ // 判断序列是否为空
    return l.length > 0;
}

int main()
{
    SeqList list;
    InitList(list);     // 初始化序列
    Insert(list, 1, 1); // 在第一个位置插入1
    Insert(list, 2, 2); // 在第二个位置插入2
    Insert(list, 3, 3); // 在第三个位置插入3
    Insert(list, 4, 4); // 在第四个位置插入4
    Insert(list, 5, 5); // 在第五个位置插入5
    int d;
    Delete(list, 3, d);                      // 删除第三个位置的元素，并将删除的元素赋值给d
    Print(list);                             // 打印序列
    std::cout << std::endl;                  // 换行
    std::cout << GetElem(list, 3) << " ";    // 获取第三个位置的元素并打印
    std::cout << LocateElem(list, 4) << " "; // 查找元素4的位置并打印
    return 0;
}

单链表

代码中的函数解释：

1. void InitList(LinkList &l)：初始化链表，创建一个头节点，并将链表指针 l 指向头节点。
2. int Length(LinkList l)：计算链表长度，通过遍历链表计数节点数量，并返回计数结果。
3. int LocateElem(LinkList l, int e)：查找元素位置，遍历链表，当找到目标元素时返回该元素在链表中的位置。
4. Node *GetElem(LinkList l, int i)：获取指定位置的元素，通过遍历链表，将指针指向目标位置的节点并返回该节点的指针。
5. bool Insert(LinkList l, int i, int e)：插入元素，在链表的指定位置插入一个新的节点，并返回操作是否成功。
6. bool Delete(LinkList l, int i, int &e)：删除元素，删除链表中指定位置的节点，并返回操作是否成功。同时通过引用参数 e 返回被删除节点的值。
7. void Print(LinkList l)：打印链表，遍历链表并输出每个节点的值。
8. bool Empty(LinkList l)：判断链表是否为空，检查链表的头节点的下一个节点是否为空。
9. void Destroy(LinkList &l)：销毁链表，释放链表所占用的内存空间。

#include <iostream>
#include <cstdlib>
#define MaxSize 10

typedef struct Node
{
    int data;
    Node *next;
} Node, *LinkList;

// 初始化一个空的链表
void InitList(LinkList &l)
{
    l = new Node;      // 创建一个新的节点作为头节点
    l->next = nullptr; // 将头节点的下一个指针初始化为nullptr
    l->data = 0;       // 头节点的数据设置为0（您可以根据需要修改此值）
}

// 计算链表中元素的个数（长度）
int Length(LinkList l)
{
    int cnt = 0;
    LinkList p = l;
    while (p != nullptr)
    {
        p = p->next;
        cnt++;
    }
    return cnt;
}

// 查找链表中某个元素的位置（索引）
int LocateElem(LinkList l, int e)
{
    int cnt = 0;
    LinkList p = l;
    while (p)
    {
        cnt++;
        if (p->data == e)
        {
            return cnt; // 如果找到元素，返回其位置（索引）
        }
        p = p->next;
    }
    return 0; // 如果找不到元素，返回0
}

// 获取链表中指定位置的元素节点
Node *GetElem(LinkList l, int i)
{
    int cnt = 0;
    LinkList p = l;
    while (cnt++ < i)
    {
        p = p->next;
    }
    return p;
}

// 在链表的指定位置插入一个新元素
bool Insert(LinkList l, int i, int e)
{
    if (i < 1 || i > Length(l) + 1)
    {
        return false; // 如果位置不合法，插入失败
    }
    Node *p = GetElem(l, i - 1);
    Node *node = new Node();
    node->next = p->next;
    node->data = e;
    p->next = node;
    return true; // 插入成功
}

// 删除链表中指定位置的元素节点
bool Delete(LinkList l, int i, int &e)
{
    if (Length(l) < 1 || i < 1 || i > Length(l))
    {
        return false; // 如果链表为空或位置不合法，删除失败
    }
    Node *p = GetElem(l, i - 1);
    e = p->next->data;
    p->next = p->next->next;

    return true; // 删除成功
}

// 打印链表中的元素
void Print(LinkList l)
{
    for (int i = 1; i < Length(l); i++)
    {
        std::cout << GetElem(l, i)->data << " ";
    }
}

// 判断链表是否为空
bool Empty(LinkList l)
{
    return l->next == nullptr;
}

// 销毁链表，释放内存
void Destroy(LinkList &l)
{
    delete l;
}

int main()
{
    LinkList list;
    InitList(list);
    Insert(list, 1, 1);
    Insert(list, 2, 2);
    Insert(list, 3, 3);
    Insert(list, 4, 4);
    Insert(list, 5, 5);
    Print(list);
    int d;
    Delete(list, 2, d);
    Print(list);
    Destroy(list);
}