按位序插入（带头结点）

bool InitList(LinkList& L) {
	L = (LNode*)malloc(sizeof(LNode));//分配一个头结点
	if (L == NULL) {
		return false;//内存不足，分配失败
	}
	L->next = NULL;//头结点之后暂时还没有节点
	return true;
}

 首先我们现在链表初始化函数中为链表分配一个头结点

bool ListInsert(LinkList& L, int i, int e) {//在第i个位置插入元素e(带头结点)
	if (i < 1) {
		return false;
	}
	else {
		LNode* p;//指针p指向当前扫描到的结点
		int j = 0;//当前p指向的是第几个结点
		p = L;//L指向头结点，头结点是第0个结点(不存数据)
		while (p != NULL && j < i - 1) {//循环找到第i-1个结点
			p = p->next;
			j++;
		}
		if (p == NULL) {//i值不合法
			return false;
		}
		else {
			LNode* s = (LNode*)malloc(sizeof(LNode));
			s->data = e;
			s->next = p->next;
			p->next = s;//将结点s连到p之后
			return true;//插入成功
		}
	}
}

这段代码定义了一个名为 ListInsert 的函数，其目的是在带有头结点的单链表的第 i 个位置插入一个元素 e。函数的返回类型是 bool，表示插入操作是否成功。下面是函数的详细分析：

1. 函数参数：

   • LinkList& L：这是一个引用参数，表示链表的类型（可能是结构体指针类型），L 是链表的头指针，指向头结点。
   • int i：要插入元素的位置索引。由于链表带有头结点，位置索引从1开始。
   • int e：要插入的元素的值。

2. 函数开始：

   • 首先，检查 i 的值是否小于1。如果是，返回 false，因为位置索引不应该小于1。

3. 初始化变量：

   • 定义一个 LNode* p 指针，用于遍历链表。
   • 定义一个 int j 变量，用于记录当前 p 指向的是第几个结点。

4. 遍历链表：

   • 将 p 初始化为 L，即头结点。
   • 使用 while 循环遍历链表，直到 p 为 NULL 或者 j 等于 i - 1。
   • 在循环中，p 移动到下一个结点，j 增加1。

5. 检查位置合法性：

   • 如果循环结束后 p 为 NULL，说明 i 的值不合法（超过了链表的长度），返回 false。

6. 插入新结点：

   • 如果 p 不为 NULL，则分配一个新的结点 s。
   • 将 s 的 data 成员设置为 e。
   • 将 s 的 next 成员指向 p 的下一个结点。
   • 将 p 的 next 成员设置为 s，这样 s 结点就被插入到了 p 结点之后。

7. 返回结果：

   • 插入操作成功，返回 true。

这个函数的关键点是它处理了链表的插入操作，并且考虑了链表带有头结点的情况。头结点是一个不存储数据的特殊结点，它简化了链表操作，特别是插入和删除操作，因为头结点确保了链表至少有一个结点，不会出现空链表的情况。

按位序插入（不带头结点）

bool InitList(LinkList& L) {
	bool InitList(LinkList& L) {
    L = NULL; // 将头指针设置为 NULL，表示链表为空
    return true; // 初始化成功
}

我们在初始化函数中只将头指针指向NULL，不设置任何结点

bool ListInsert(LinkList& L, int i, int e) {
	if (i < 1) {
		return false;
	}
	if(i==1) {//插入第1个结点的操作与其他结点操作不同
		LNode* s = (LNode*)malloc(sizeof(LNode));
		s->data = e;
		s->next = L;
		L = s;//头指针指向新结点
		return true;
	}else{
		LNode* p;//指针p指向当前扫描到的结点
		int j = 1;//当前p指向的是第几个结点
		p = L;//L指向第1个结点(注意：不是头结点)
		while (p != NULL && j < i - 1) {//循环找到第i-1个结点
			p = p->next;
			j++;
		}
		if (p == NULL) {//i值不合法
			return false;
		}
		else {
			LNode* s = (LNode*)malloc(sizeof(LNode));
			s->data = e;
			s->next = p->next;
			p->next = s;//将结点s连到p之后
			return true;//插入成功
		}
	}
}

相比于带头结点的按位序插入，不带头结点的操作则需要对第1个结点进行特殊处理，插入、删除第1个元素时，需要更改头指针L，所以带头结点写代码比不带头结点写代码更加方便！

指定结点的后插操作

bool InsertNextNode(LNode* p, int e) {//后插操作:在p结点之后插入元素e
	if (p == NULL) {
		return false;
	}
	else {
		LNode* s = (LNode*)malloc(sizeof(LNode));
		if (s == NULL) {//内存分配失败
			return false;
		}
		else
		{
			s->data = e;//用结点s保存数据元素e
			s->next = p->next;//结点s指向p的下一个结点
			p->next = s;//将结点s连到p之后
			return true;
		}
	}
}

图解：

该段函数可以直接替代ListInsert中的结点插入，部分并且时间复杂度只有O(1) 。

指定结点的前插操作

bool InsertPriorNode(LNode *p,int e){//前插操作:在p点之前插入元素e
	if (p == NULL) {
		return false;
	}
	else {
		LNode* s = (LNode*)malloc(sizeof(LNode));
		if(s==NULL){//内存分配失败
			return false;
		}
		else {
			s->next = p->next;
			p->next = s;//将新结点s连到p之后
			s->data = p->data;//将p中元素复制到s中
			p->data = e;//p中元素覆盖为e
			return true;
		}
	}
}

这段函数我们创建了一个新的结点s，将其指向p的原先后驱结点，然后再将p中的data数据元素复制到s中，再将所需要插入的数据元素e复制到p的data数据中，形成了一个偷天换日的效果，并且时间复杂度只有O(1) 。

按位序删除（带头结点）

bool ListDelete(LinkList& L, int i, int& e) {
	if (i < 1) {
		return false;
	}
	else {
		LNode * p;//指针p指向当前扫描到的结点
		int j = 0;//当前p指向的是第几个结点
		p = L;//L指向头结点，头结点是第0个结点(不存数据)
		while (p != NULL && j < i - 1) {//循环找到第i-1个结点
			p = p->next;
			j++;
		}
		if (p == NULL) {//i值不合法
			return false;
		}
		else {
			if (p->next == NULL) {//第i-1个结点之后已无其他结点
				return false;
			}
			else {
				LNode* q = p->next;//令q指向被删除结点
				e = q->data;//用e返回元素的值
				p->next = q->next;//将*q结点从链中"断开"
				free(q);//释放结点的存储空间
				return true;//删除成功
			}
		}
	}
}

由于”断开“这一部分对我来说比较抽象，所以特意引用了图解 

该算法的最坏时间复杂度和平均时间复杂度为O(n),最好时间复杂度为O(1)

指定结点的删除

bool DeleteNode(LNode* p) {//删除指定结点
	if (p == NULL) {
		return false;
	}
	else {
		LNode* q = p->next;//令q指向*p的后继结点
		p->data = p->next->data;//和后继结点交换数据域
		p->next = q->next;//将*q结点从链中"断开"
		free(q);//释放后继结点的存储空间
		return true;
	}
}

该函数的本质其实是将q指向的p的后驱结点，然后将q的data数据复制到p结点的data数据中，然后再将q结点从链中断开，再释放q，就等于把p删除了，实际上类似于将p的后驱结点数据前移覆盖p结界的数据，再将p的后驱结点删除，形成了偷天换日的效果，但该方法有概率会遇到指向空指针的情况，比如p是最后一个结点，该方法的时间复杂度为O(1)

总结：