单链表（带头结点）——建立、查找、插入、删除、销毁等操作的代码实现（王道版）

参考王道《2023年数据结构考研复习指导》

#include <iostream>

#define MaxSize 20

typedef int ElemType;

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

bool InitList(LinkList& L);
bool List_HeadInsert(LinkList& L);
bool List_TailInsert(LinkList& L);
LNode* GetElem(LinkList L, int i);
LNode* LocateElem(LinkList L, ElemType e);
bool ListInsert(LinkList& L, int i, ElemType e);
bool InsertNextNode(LNode* p, ElemType e);
bool InsertPriorNode(LNode*& p, ElemType e);
bool DeleteNode(LNode* p);
int Length(LinkList L);
void PrintList(LinkList L);
void DestroyList(LinkList& L);

int main() {
	LinkList L;
	List_TailInsert(L);
	PrintList(L);

	ListInsert(L, 1, 800);
	PrintList(L);

	std::cout << GetElem(L, 1)->data << std::endl;

	LNode* p = LocateElem(L, 3);
	InsertNextNode(p, 500);
	InsertPriorNode(p, 404);
	PrintList(L);

	DeleteNode(p);
	PrintList(L);

	std::cout << Length(L) << std::endl;

	DestroyList(L);

	if (L == NULL)
		std::cout << "LinkList is Destroyed" << std::endl;

	system("pause");
	return 0;
}

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

// 头插法建立单链表
bool List_HeadInsert(LinkList& L) {
	if (!InitList(L)) {			// 初始化单链表
		return false;
	}

	ElemType x;
	std::cin >> x;
	while (x != 9999) {
		/*
		LNode* s = (LNode*)malloc(sizeof(LNode));
		if (s == NULL)		// 内存分配失败
			return false;
		s->data = x;
		s->next = L->next;
		L->next = s;
		*/

		if (!InsertNextNode(L, x))	// 在头结点后面插入元素e
			return false;

		std::cin >> x;
	}
	return true;
}

// 尾插法建立单链表
bool List_TailInsert(LinkList& L) {
	if (!InitList(L)) {			// 初始化单链表
		return false;
	}

	LNode* r = L;		// r为表尾指针
	ElemType x;
	std::cin >> x;
	while (x != 9999) {
		/*
		LNode* s = (LNode*)malloc(sizeof(LNode));
		if (s == NULL)		// 内存分配失败
			return false;
		s->data = x;
		r->next = s;
		r = s;
		*/

		if (!InsertNextNode(r, x))	// 在尾指针后面插入元素e
			return false;
		r = r->next;

		std::cin >> x;
	}

	r->next = NULL;
	return true;
}

// 按位查找，返回第i个结点
LNode* GetElem(LinkList L, int i) {
	if (i < 0) {		// i的值不合法(头结点是第0个元素)
		return NULL;
	}

	LNode* p = L;
	int j = 0;		// 当前p指向第几个结点
	while (p != NULL && j < i) {	// 循环找到第i个结点
		p = p->next;
		++j;
	}
	return p;
}

// 按值查找，返回第一个数据为e的结点
LNode* LocateElem(LinkList L, ElemType e) {
	LNode* p = L->next;
	while (p != NULL && p->data != e) {
		p = p->next;
	}

	return p;
}

// 在第i个位置插入元素e（按位序插入）
bool ListInsert(LinkList& L, int i, ElemType e) {
	if (i < 1) {		// 插入位置不合法
		return false;
	}
	/*
	LNode* p = L;
	int j = 0;		// 当前p指向第几个结点
	while (p != NULL && j < i - 1) {
		p = p->next;
		++j;
	}
	*/

	LNode* p = GetElem(L, i - 1);	// 找到第i-1个结点

	/*
	if (p == NULL)	// i的值不合法
		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;
	*/

	return InsertNextNode(p, e);	// 在结点p后面插入新元素e
}

// 删除第i个位置上的元素，并用e返回删除元素的值（按位序删除）
bool ListDelete(LinkList& L, int i, ElemType& e) {
	if (i < 1)			// 删除位置不合法
		return false;

	/*
	LNode* p;
	int j = 0;
	p = L;
	while (p != NULL && j < i - 1) {
		p = p->next;
		j++;
	}
	*/

	LNode* p = GetElem(L, i - 1);	// 找到第i-1个结点

	
	if (p == NULL)
		return false;
	if (p->next == NULL)
		return false;
	/*
	LNode* q = p->next;
	e = q->data;
	p->next = q->next;
	free(q);
	return true;
	*/
	return DeleteNode(p);
}

// 指定结点的后插操作（在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->next = p->next;
	p->next = s;

	return true;
}

// 指定结点的前插操作（在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->data = p->data;		// 将p中元素复制到s中
	p->data = e;			// p中元素覆盖为e(此时s指向一开始的p，而p成为插入的元素)

	p = s;					// 使p指向原来的结点

	return true;
}

// 删除指定结点p
bool DeleteNode(LNode* p) {
	if (p == NULL)
		return false;

	LNode* q = p->next;
	p->data = q->data;
	p->next = q->next;
	free(q);
	return q;
}

// 求表的长度
int Length(LinkList L) {
	int len = 0;
	LNode* p = L;
	while (p->next != NULL) {
		p = p->next;
		len++;
	}
	return len;
}

// 打印单链表
void PrintList(LinkList L) {
	LNode* p = L->next;
	while (p != NULL) {
		std::cout << p->data << " ";
		p = p->next;
	}
	std::cout << std::endl;
}

// 销毁单链表
void DestroyList(LinkList& L) {
	LNode* p = L->next;
	LNode* q;
	while (p != NULL) {
		q = p;
		p = p->next;
		free(q);
	}
	free(L);
	L = NULL;
}