单链表的插入与删除

 王道2022-2.2.6

#include<stdio.h>
#include<stdlib.h>
//对应插入的前插与后插两种方法,删除也有头指针遍历法与偷天换日法
//前插与后插区别主要问题出在: p的前驱结点是否为神秘区域  (是否给出头结点)
//前插与后插区别主要表现在于: 平均时间复杂度O(1)与O(n)
//前插与后插区别主要手法比较: 前后正常连接与在正常连接基础上进行数据交换,造成真的进行了前插的假象 (实际新结点是后插的)
typedef int ElemType;
typedef struct LNode {
	ElemType data;
	struct LNode* next;
}LNode, * LinkList;

//不带头结点的单链表 空表初始化
bool InitList(LinkList& L) {
	L = NULL;
	return true;
}

//判断链表是否为空
bool Empty(LinkList L) {
	return (L == NULL);
}

//带头结点的单链表 空表初始化
bool InitList(LinkList& L) {
	L = (LNode*)malloc(sizeof(LNode));
	if (L == NULL) {    //内存不足,分配失败
		return false;
	}
	L->next = NULL;
	return true;
}

//判断链表是否为空
bool Empty(LinkList L) {
	if (L->next == NULL) {
		return true;
	}
	else
		return false;
}

//返回单链表指定位置结点
LNode* GetElem(LinkList L, int i) {
	int j = 1;
	LNode* p = L->next;
	if (i == 0) {
		return L;
	}
	if (i < 0) {
		return NULL;
	}
	while (j < i && p != NULL) {
		p = p->next;
		j++;
	}
	return p;
}

//单链表插入

//按位序插入

//后插:
//在第i个位置插入元素e(带头结点): 最坏时间复杂度O(n)  平均时间复杂度O(n)
bool ListInsert(LinkList& L, int i, ElemType e) {
	if (i < 1) {   //头结点及其前面序号不可被插入
		return false;
	}
	LNode* p;
	int j = 0;  //头结点是第0个结点,不储存数据
	p = L;
	while (j < i - 1 && p != NULL) {
		j++;
		p = p->next;
	}
	if (p == NULL) {  //i值不合法
		return false;
	}
	LNode* s = (LNode*)malloc(sizeof(LNode));
	//一般来说,malloc分配内存,不会出现分配为NULL的情况
	//故这里使用s->data,不会出现NULL->data的情况
	s->data = e;
	//下面两行顺序不能颠倒
	s->next = p->next;
	p->next = s;
	return true;
}

//在第i个位置插入元素e(不带头结点): 最坏时间复杂度O(n)  平均时间复杂度O(n)
bool ListInsert(LinkList L, int i, ElemType 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;
	int j = 1;
	while (j < i - 1 && p != NULL) {
		p = p->next;
		j++;
	}
	if (p == NULL) {  //i值不合法
		return false;
	}
	LNode* s = (LNode*)malloc(sizeof(LNode));
	s->data = e;
	s->next = p->next;
	p->next = s;
	return true;
}

//前插:
//时间复杂度为O(n)的前插
//已知头结点,从头结点开始遍历至目标位置的结点
//时间复杂度为O(1)的前插
//给定条件:已知目标位置的结点p,在结点p前插入元素e
bool InsertPriorNode(LNode* p, ElemType e) {
	if (p == NULL) {
		return false;
	}
	LNode* s = (LNode*)malloc(sizeof(LNode));
	if (s == NULL) {   //内存分配失败
		return false;
	}
	//核心为接下来的两行:注意,本题目标是时间复杂度为O(1)的前插,
	//同时,本题条件将造成,p的前驱结点未知,故p的位置不可以改变,
	//解决方法:让p的值转移到p结点新的后继结点s(p的后继可知,故将p的后继赋值给s的后继) 即命令: s->next=p->next;
	//同时,将p与s连接 即命令: p->next=s;
	//此时,新结点s完全替代了结点p,结点p的值已被安全转移,其值可以转换成目标值,即e
	//这样不会干涉到p的前驱,也在链表内添加了新结点
	s->next = p->next; 
	p->next = s;          //本行与上一行命令,构建了新结点s的前驱和后继
	s->data = p->data;
	p->data = e;
	//总结:如果函数前驱难以提取,还需要使用前插法,可以使用结点数据域信息交换
}

//王道书:在p结点前插入结点s(不是元素e)
bool InsertPriorNode(LNode* p, LNode* s) {
	if (p == NULL || s == NULL) {
		return false;
	}
	s->next = p->next;
	p->next = s;
	//接下来交换数据域
	ElemType temp = p->data;
	p->data = s->data;
	s->data = temp;
	return true;
}

//按位序删除(带头结点):最好时间复杂度O(1) 最坏时间复杂度O(n) 平均时间复杂度O(n)

//删除第i个位置的元素,并用e返回删除元素的值
bool ListDelete(LinkList& L, int i, ElemType& e) {
	if (i < 1) {
		return false;
	}
	LNode* p;
	int j = 0;
	p = L;
	while (j < i - 1 || p != NULL) {
		p = p->next;
		j++;
	}
	//不可以直接写成:p->next = (p->next)->next;
	//因为需要free掉所删除结点的空间,故需要用将该位置数据赋值给一个结点
	LNode* q = p->next;
	e = q->data;  //在下一行链表重新链接前,将目标位置数据域数据提出给e
	p->next = q->next; //即p->next = (p->next)->next;
	free(q);
	return true;
}

//偷天换日法删除目标结点 (类似结点前插) 平均时间复杂度为O(1)
bool ListDelete(LNode* p) {
	if (p == NULL) {
		return false;
	}
	//偷天换日核心: 即p的前驱不知,故删除其后,无法将p的前驱与其后继连接,转而删除p的后继q,同时将p与q的数据域交换,用p的位置储存q的数据
	//综上所述,此时p的数据从链表消失,并且此时链表少了一个结点
	LNode* q = p->next;
	p->next = q->next;
	p->data = q->data;
	free(q);
	return true;
}

void test() {
	LinkList L;   //声明一个指向单链表的指针
	InitList(L);   //初始化一个空表(分为带头指针与不带头指针两种)
}

int main() {
	test();
}