==ListInsert(&L, i, e): ==在表L中的第i个位置上插入指定元素e = 找到第i-1个结点(前驱结点)，将新结点插入其后；其中头结点可以看作第0个结点，故i=1时也适用。
typedef struct LNode{ ElemType data; struct LNode *next;
}LNode, *LinkList;
//在第i个位置插入元素e（带头结点）
bool ListInsert(LinkList &L, int i, ElemType e){
//判断i的合法性, i是位序号(从1开始) if(i<1)
LNode *p; int j=0;
p = L;
//循环找到第i-1个结点
while(p!=NULL && j<i-1){ p = p->next;
j++;
}
if (p==NULL)
return false;
//在第i-1个结点后插入新结点
LNode *s = (LNode *)malloc(sizeof(LNode)); //申请一个结点s->data = e;
s->next = p->next;
p->next = s;?????????????????? //将结点s连到p后,后两步千万不能颠倒qwq
return true;
}
平均时间复杂度：O(n)
==ListInsert(&L, i, e): ==在表L中的第i个位置上插入指定元素e = 找到第i-1个结点(前驱结点)，将新结点插入其后; 因为不带头结点，所以不存在“第0个”结点，因此！i=1 时，需要特殊处理——插入(删除)第1个元素时，需要更改头指针L;
typedef struct LNode{ ElemType data; struct LNode *next;
}LNode, *LinkList;
bool ListInsert(LinkList &L, int i, ElemType e){
if(i<1)
return false;
//插入到第1个位置时的操作有所不同！ if(i==1){
LNode *s = (LNode *)malloc(size of(LNode)); s->data =e;
s->next =L;
L=s;?????????? //头指针指向新结点return true;
}
//i>1的情况与带头结点一样！唯一区别是j的初始值为1 LNode *p;? //指针p指向当前扫描到的结点int j=1;??? //当前p指向的是第几个结点
p = L;?????????? //L指向头结点，头结点是第0个结点（不存数据）
//循环找到第i-1个结点
while(p!=NULL && j<i-1){ p = p->next;
j++;
}
if (p==NULL)
return false;
//在第i-1个结点后插入新结点
LNode *s = (LNode *)malloc(sizeof(LNode)); //申请一个结点s->data = e;
s->next = p->next;
p->next = s; return true;
}
==InsertNextNode(LNode *p, ElemType e):== 给定一个结点p，在其之后插入元素e; 根据单链表的链接指针只能往后查找，故给定一个结点p，那么p之后的结点我们都可知，但是p结点之前的结点无法得 知;
typedef struct LNode{ ElemType data; struct LNode *next;
}LNode, *LinkList;
bool InsertNextNode(LNode *p, ElemType e){ if(p==NULL){
return false;
}
LNode *s = (LNode *)malloc(sizeof(LNode));
//某些情况下分配失败，比如内存不足if(s==NULL)
return false; s->data = e;
s->next = p->next;
p->next = s;
return true;}
//有了后插操作，那么在第i个位置上插入指定元素e的代码可以改成：
bool ListInsert(LinkList &L, int i, ElemType e){ if(i<1)
return False;
LNode *p;
int j=0;
p = L;
//循环找到第i-1个结点
while(p!=NULL && j<i-1){ p = p->next;
j++;
}
return InsertNextNode(p, e)
}
思想：设待插入结点是s，将s插入到p的前面。我们仍然可以将s插入到*p的后面。然后将p->data与s-
>data交换，这样既能满足了逻辑关系，又能是的时间复杂度为O(1)
//前插操作：在p结点之前插入元素e
bool InsertPriorNode(LNode *p, ElenType 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连到p之后s->data = p->data; //将p中元素复制到s p->data = e; //p中元素覆盖为e
return true；
}? //时间复杂度为O(1)
==ListDelete(&L, i, &e):== 删除操作，删除表L中第i个位置的元素，并用e返回删除元素的值;头结点视为
“第0个”结点；
思路：找到第i-1个结点，将其指针指向第i+1个结点，并释放第i个结点；
typedef struct LNode{
ElemType data;
struct LNode *next;
}LNode, *LinkList;
bool ListDelete(LinkList &L, int i, ElenType &e){
if(i<1)
return false;
LNode *p;
int j=0; p = L;
//循环找到第i-1个结点
while(p!=NULL && j<i-1){ p = p->next;
j++;
}
if(p==NULL)
return false;
if(p->next == NULL) //第i-1个结点之后已无其他结点
return false;
LNode *q = p->next; e = q->data;
p->next = q->next;
free(q)
return true;
}
时间复杂度分析：
最坏，平均时间复杂度：O(n)
最好时间复杂度：删除第一个结点 O(1)
bool DeleteNode(LNode *p){ if(p==NULL)
return false;
LNode *q = p->next;?????? //令q指向*p的后继结点
p->data = p->next->data; //让p和后继结点交换数据域p->next = q->next;?? //将*q结点从链中“断开” free(q);
return true;
} //时间复杂度 = O(1)
1. 链表的动态性质：链表结构可以在运行时动态地插入和删除节点，这是它与数组最大的不同之处。链表不需要预分配固定的存储空间，可以根据需要动态分配。
2. 头结点的便捷性：使用头结点可以简化插入和删除操作，因为无论在链表的任何位置进行这些操作，都有一个统一的节点来参考，即头结点。
3. 指针的重要性：链表的操作很大程度上依赖于指针，正确地移动和更新指针是确保链表结构正确性和稳定性的关键。
4. 复杂度的理解：虽然链表允许O(1)时间复杂度的元素插入和删除（在某些条件下），但按位序操作通常需要O(n)的时间复杂度，因为可能需要遍历整个链表以找到正确的位置。
5. 内存管理：在C中使用链表时，必须小心处理内存的分配和释放。每次创建新节点时，都需要使用`malloc`分配内存，并在删除节点时使用`free`释放内存，以避免内存泄漏。
6. 边界条件的处理：在链表的操作中，需要特别注意边界条件，例如插入或删除第一个元素时，可能需要特殊处理，比如更新头指针。
7. 错误处理：适当的错误处理是链表操作中不可忽视的部分。例如，当内存分配失败时，需要返回错误信息，并避免程序崩溃。
8. 算法优化：有时候，通过一些巧妙的方法可以优化链表的操作，比如前插操作可以通过交换数据来避免复杂的节点断开和连接，这样可以减少一些不必要的指针操作。