// 定义两个宏，分别表示函数执行成功和失败的状态
#define OK 1
#define ERROR 0

// 定义一个新的类型名Status，它实际上就是int类型
typedef int Status;

// 函数声明：从顺序表L中获取第i个位置的元素，并将其赋值给变量e
// SqList L:顺序表结构体
// int i:表示获取元素的位置，也就是索引
// ElemType *e:这是一个指针，用于存放获取到的元素。
Status GetElem(SqList L, int i, ElemType *e) {
    // 检查i是否在合法范围内，即i大于0且小于等于顺序表的长度
    if (i < 1 || i > L.length) {
        // 如果i不合法，返回错误状态ERROR
        return ERROR;
    }
    // 如果i合法，将第i个位置的元素赋值给e指向的变量
    // 注意：由于数组索引是从0开始的，所以第i个元素实际上是L.data[i-1]
    *e = L.data[i - 1];
    // 返回成功状态OK
    return OK;
}

// 函数声明，用于在顺序表L中第i个位置插入元素e，并返回操作状态
Status ListInsert(SqList *L, int i, ElemType e) {
    int k;

    // 检查顺序表是否已满，如果已满，返回错误状态
    if (L->length == MAXSIZE) return ERROR;

    // 检查插入位置i是否合法，如果不合法（小于1或大于顺序表长度+1），返回错误状态
    if (i < 1 || i > L->length + 1) return ERROR;

    // 如果插入位置不在表尾
    if (i <= L->length) {
        // 从最后一个元素开始，直到要插入的位置，将每个元素向后移动一位
        for (k = L->length - 1; k >= i - 1; k--) {
            // 将元素向后移动
            L->data[k + 1] = L->data[k];
        }
    }

    // 将新元素e插入到位置i-1（因为数组索引从0开始）
    L->data[i - 1] = e;

    // 顺序表长度增加1
    L->length++;

    // 插入成功，返回成功状态
    return OK;
}

// 函数声明，从顺序表L中删除第i个位置的元素，并通过e返回该元素的值，函数返回操作状态
Status ListDelete(SqList *L, int i, ElemType *e){
    int k;

    // 检查顺序表是否为空，如果为空，返回错误状态
    if(L->length == 0) return ERROR; 

    // 检查删除位置i是否正确，即i是否在1到L->length的范围内，如果不正确，返回错误状态
    if(i < 1 || i > L->length) return ERROR; 

    // 将要删除的元素赋值给*e，即通过指针e返回被删除元素的值
    *e = L->data[i-1];

    // 如果删除的位置不是最后一个元素，则需要将后续元素前移
    if(i < L->length){
        for(k = i; k < L->length; k++){
            // 将位置k的元素前移到位置k-1
            L->data[k-1] = L->data[k];
        }
    }

    // 顺序表的长度减1，因为已经删除了一个元素
    L->length--;

    // 如果删除操作成功，返回OK
    return OK;
}

// 定义链表节点结构体
typedef struct None {
    int data;             // 数据域
    struct None *next;    // 指向下一个节点的指针
} Node;                   // 使用 Node 作为别名

typedef struct None *Link;  // 定义指向 Node 的指针类型 Link

static GetElem(LinkList L, int i, ElemType *e)
{
    int j;  //声明结点p
    p = L->next; //让p指向链表L的第一个结点
    j = 1; //j为计数器
    while (p && j < i)  //p不为空或计算器j还没有等于i时，循环继续
    {
        p = p->next;  //让p指向下一个结点
        j++;
    }
    if (!p || j > i)
    {
        return ERROR;  //第i个不存在
    }
    *e = p->data;  //读取第i个元素的数据
    return OK;
}
// ||：一个为真，则都为真 &&：要两个都为真

static GetElem(LinkList L, int i, ElemType *e)
{
    int j;
    LinkList p = L->next;  // 假设 L 是头结点，p 指向第一个数据结点
    j = 1;                 // 初始化计数器，从第 1 个结点开始
    while (p && j < i)      // 遍历链表，直到找到第 i 个结点
    {
        p = p->next;
        j++;
    }
    if (!p || j > i)       // 如果链表为空或者 j 超过了 i，返回错误
    {
        return ERROR;
    }
  
    // 插入新结点
    LinkList s = (LinkList)malloc(sizeof(Node));  // 为新结点分配内存
    s->data = e;      
    s->next = p->next;       // 将p的后继结点赋值给s的后继
    p->next = s;             // 将s赋值给p的后继

    return OK;
}

static GetElem(LinkList L, int i, ElemType *e)
{
    int j;
    p = L->next;  // 初始化 p 指针，指向链表的第一个节点
    j = 1;        // 从第 1 个节点开始计数
    while (p && j < i)  // 遍历链表，找到第 i 个节点的前一个节点
    {
        p = p->next;
        j++;
    }
    if (!p || j > i)  // 如果链表长度不足 i，或者 j 超过 i，返回错误
    {
        return ERROR;
    }
    q = p->next;  // 找到要删除的节点 q（即第 i 个节点）
    p->next = q->next;  // 让 p 的后继指针跳过 q，指向 q 的后继节点
    *e = q->data;  // 将要删除的节点 q 的数据保存到 e 中
    free(q);  // 释放被删除节点 q 所占的内存
    return OK;  // 返回成功
}

static GetElem(LinkList L, int i, ElemType *e)
{
    LinkList p;               // 定义一个指针 p 用于遍历链表
    int i;                    // 定义计数器 i（注意：与外部函数参数 i 冲突）
    srand(time(0));           // 初始化随机数种子，确保每次运行时生成不同的随机数
  
    *L = (LinkList)malloc(sizeof(LNode));  // 为头节点分配内存
    (*L)->next = NULL;        // 将头节点的后继指针设为 NULL，表示链表初始化为空
  
    for (i = 0; i < n; i++)   // 循环生成 n 个节点
    {
        p = (LinkList)malloc(sizeof(LNode));  // 为新节点 p 分配内存
        p->data = rand() % 100 + 1;           // 生成 1 到 100 之间的随机数，并赋给 p->data
        p->next = (*L)->next;   // 将当前链表的第一个节点赋值为 p 的后继
        (*L)->next = p;         // 将 p 插入到头节点之后
    }
}

P = rearA -> next;          //保存A表的头结点，1点
rearA -> next = rearB -> next -> next;  //将本是指向B表的第一个结点（不是头结点）

q = rearB -> next;   
rearB -> next = p;          //赋值给rearA->next,2点
free(q);                    //释放q   

typedef struct DulNode
{
        ElemType data;
        struct DuLNode *prior;     //直接前驱指针
        struct DuLNone *next;      //直接后继指针
}DulNode,*DuLinkList;