单链表的相关操作（定义，初始化，插入，删除，查找，求表长）

定义

1.定义一个单链表

typedef struct LNode {
	ElemType data;
	struct LNode* next;
}LNode, * LinkList;

初始化

2.1.不带头节点的单链表

bool InitList(LinkList& L) {
	L = NULL;	//空表，防止脏数据
	return true;
}
bool Empty(LinkList L) {	//判断单链表是否为空
	return(L == NULL);
}

2.2.带头结点的单链表

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;
}

插入

3.1.按位序插入（带头结点）

//在第i个位置插入元素e
bool ListInsert(LinkList& L, int i, ElemType e) {
	if (i < 1)
		return false;
	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;
	//LNode* s = (LNode*)malloc(sizeof(LNode));
	//s->data = e;
	//s->next = p->next;
	//p->next = s;	//将结点s连到p之后
	//return true;	//插入成功
	return InsertNextNode(p, e);
}

如果i=1（插在表头） 最好时间复杂度：O(1)
如果i=3（插在表中）
如果i=5（插在表尾） 最坏时间复杂度：O(n)
如果i=6（i>length）
平均时间复杂度O(n)

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

bool ListInsert(LinkList& L, int i, ElemType 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;
	}
	LNode* p;	//指针p指向当前扫描到的结点
	int j = 1;	//当前p指向的是第几个结点
	p = L;	//L指向头结点，头结点是第0个结点（不存数据）
	while (p != NULL && j < i - 1) {	//循环找到第i-1个结点
		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;	//将结点s连到p之后
	return true;	//插入成功
}

3.3.指定结点的后插操作

//后插：在p结点之后插入元素e
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保存数据元素e
	s->next = p->next;
	p->next = s;	//将结点s连接到p之后
	return true;
}

3.4.指定结点的前插操作

//前插：在p结点之前插入元素e
bool InsertPriorNode(LNode* p, ElemType 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)

删除

4.1.按位序删除（带头结点）

bool ListDelete(LinkList& L, int i, ElemType e) {
	if (i < 1)
		return false;
	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;
	if (p->next == NULL)	//第i-1个结点之后已无其他结点
		return false;
	LNode* q = p->next;	//令q指向被删除结点
	e = q->data;	//用e返回元素的值
	p->next = q->next;	//将*q结点从链中断开
	free(q);	//释放结点的存储空间
	return true;	//删除成功
}

4.2.指定结点的删除

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

时间复杂度为O(1)
如果p是最后一个结点，只能从表头开始依次寻找p的前驱，时间复杂度为O(n)

---------以下都基于【带头结点】的情况---------

查找

5.1.按位查找

LNode* GetElem(LinkList L, int i) {
	if (i < 1)
		return NULL;
	LNode* p;	//指针p指向当前扫描到的结点
	int j = 0;	//当前p指向的是第几个结点
	p = L;	//L指向头结点，头结点是第0个结点（不存数据）
	while (p != NULL && j < i) {	//循环找到第i个结点
		p = p->next;
		j++;
	}
	return p; 
}

平均时间复杂度为O(n)

5.2.按值查找

LNode* LocateElem(LinkList L, ElemType e) {
	LNode* p = L->next;
	//从第1个结点开始查找数据域为e的结点
	while (p != NULL && p->data != e)
		p = p->next;
	return p;	//找到后返回该结点指针，否则返回NULL
	}
	return p;
}

平均时间复杂度为O(n)

求表长

int Length(LinkList L) {
	int len = 0;
	LNode* p = L;
	while (p->next != NULL) {
		p = p->next;
		len++;
	}
	return len;
}

平均时间复杂度为O(n)

测试主函数

void test() {
	LinkList(L);	//声明一个指向单链表的指针
	InitList(L);	//初始化
	......
}