数据结构基础-C/C++实现单链表（带头结点）

1. 定义结构体

/**
 * @brief 链表节点 
 */
typedef struct LinkedNode{
	// 存储数据  
	int data;
	// 下一个节点的地址 
	LinkedNode *next;	
}LinkedNode, *LinkedList;

2. 初始化

/**
 * @brief 初始化一个带头结点的单链表
 * 
 * @return LinkedList 单链表的头节点
 */
LinkedList initLinkedListHaveHead() {
	// 为单链表申请一块内存空间，最为头节点
	LinkedList list = (LinkedNode *)malloc(sizeof(LinkedNode));
	// 初始化头节点之后无数据
	list -> next = NULL;
	return list;
}

3. 判空

/**
 * @brief 有头节点的单链表是否为空
 * 
 * @param l 有头节点的单链表
 * @return true 为空
 * @return false 不为空
 */
bool isEmptyHaveHead(LinkedList l) {
	// 有头节点判断头节点的next是否为null
	return l -> next == NULL;
}

4. 遍历打印

/**
 * @brief 遍历打印带头结点单链表
 * 
 * @param list 有头结点单链表
 */
void haveHeadPrint(LinkedList list) {
	LinkedNode *node = list -> next;
	int i = 0;
	while (node != NULL) {
		cout << "data" << i << "：" << node -> data << "\n" << endl;
		node = node -> next;
		i++;
	}
	
}

5. 第一个位置插入

/**
 * @brief 有头节点的单链表在第一个位置插入
 * 
 * @param list 有头节点的单链表
 * @param data 要插入的数据
 * @return true 插入成功
 * @return false 插入失败
 */
bool haveHeadInsertToFirst(LinkedList &list, int data) {
	// 如果链表为空不进行插入
	if(list == NULL) {
		return false;
	}
	// 为新节点申请内存空间
	LinkedNode *node = (LinkedNode *)malloc(sizeof(LinkedNode));
	// 新节点数据赋值
	node -> data = data;
	// 新节点的next指针指向头节点的next
	node -> next = list-> next;
	// 头节点的next指向新节点
	// 上面一部和这一步顺序不能调换不然将会丢失头节点之后的所有数据
	list -> next = node;
	return true;
}

6. 按位查找

/**
 * @brief 有头节点按位查找
 * 
 * @param list 有头节点的单链表
 * @param index 要查找的下标（0开始）
 * @return LinkedNode* 节点指针
 */
LinkedNode* haveHeadGetByIndex(LinkedList &list, int index) {
	// 链表为空无法操作
	if (isEmptyHaveHead(list)) {
		return NULL;
	}

	// 下标不合法
	if (index < 0) {
		return NULL;
	}
	
	// 声明临时节点指针指向点链表的第一个元素下标为0
	LinkedNode *node = list -> next;
	int i = 0;
	// 得到对应位置的节点
	while(node != NULL && i < index) {
		node = node -> next;
		i++;
	}
	
	// 结束循环时i的值小于index的值
	// 证明index的值超过了最大下标返回null
	if(i < index) {
		return NULL;
	}
	
	return node;
}

7. 后插

/**
 * @brief 节点后插入新节点
 * 
 * @param node 执行后插的节点
 * @param data 插入的数据
 * @return true 让如成功
 * @return false 插入失败
 */
bool insertByNodeAfter(LinkedNode *node, int data) {
	// 节点为null无法操作
	if (node == NULL) {
		return false;
	}
	
	// 为新节点申请内存空间
	LinkedNode *newNode = (LinkedNode *)malloc(sizeof(LinkedNode));

	// 新节点数据赋值
	newNode -> data = data;
	// 新节点的下一个元素为后插节点的下一个元素
	newNode -> next = node -> next;
	// 后插节点的下一个元素为新节点
	node -> next = newNode;
	return true;
}

8. 前插

/**
 * @brief 节点前插入数据
 * 
 * 因为单链表只能向一个方向查找，所以前插操作可以将前插操作的节点数据更新为要插入的数据，然后在将前插节点的原本的数据进行后插
 * 
 * @param node 前插节点
 * @param data 插入数据
 * @return true 插入成功
 * @return false 插入失败
 */
bool insertByNodeFront(LinkedNode *node, int data) {
	// 节点指针为null无法操作
	if (node == NULL) {
		return false;
	}

	// 将前插节点的数据进行保存
	int nodeData = node -> data;
	// 将前插节点的数据更新为要插入的数据
	node -> data = data;
	// 将前插节点的数据以后插方式插入到链表中
	return insertByNodeAfter(node, nodeData);
}

9. 按下标插入

/**
 * @brief 带头结点的按位插入
 * 
 * @param list 带头结点的单链表
 * @param index 插入位置的下标
 * @param data 插入的数据
 * @return true 插入成功
 * @return false 插入失败
 */
bool haveHeadInsertByIndex(LinkedList &list, int index, int data) {
	// 下标小于零为非法参数
	if (index < 0) {
		return false;
	}
	
	// 下标等于零直接调用带头节点的单链表的在第一个位置插入的方法
	if (index == 0) {
		haveHeadInsertToFirst(list, data);
		return true;
	}

	// 链表为空无法操作
	if (isEmptyHaveHead(list)) {
		return false;
	}

	// 调用有头节点的按位查找获取插入下标的前一个节点
	LinkedNode *node = haveHeadGetByIndex(list, index - 1);
	
	// 如果返回的节点指针为null则证明下标不合法
	if (node == NULL) {
		return false;
	}
	
	// 直接调用后插方法
	return insertByNodeAfter(node, data);
}

10. 删除第一个

/**
 * @brief 带头结点删除第一个元素
 * 
 * @param list 到头节点的单链表
 * @return true 删除成功
 * @return false 删除失败
 */
bool haveHeadRemoveFirst(LinkedList &list) {
	// 判断带头结点的单链表是否为空
	bool flag = isEmptyHaveHead(list);
	if (flag) {
		// 为空无法操作
		return false;
	}

	// 将带头结点的额第一个元素及逆行临时保存
	LinkedNode *node = list -> next;
	// 将头节点的next域指向第二个节点
	list -> next = node -> next;
	// 释放第一个节点
	free(node);
	// 删除成功
	return true;
}

11. 按下标删除

/**
 * @brief 有头节点根据下标删除
 * 
 * @param list 有头节点单链表
 * @param index 下标
 * @return true 删除成功
 * @return false 删除失败
 */
bool haveHeadRemoveByIndex(LinkedList &list, int index) {
	// 链表为空无法操作
	if (isEmptyHaveHead(list)) {
		return false;
	}
	
	// 获取删除节点的上一个节点
	LinkedNode *node = haveHeadGetByIndex(list, index - 1);
	// 上一个节点为空无法操作
	if (node == NULL) {
		return false;
	}

	// 获取删除节点
	LinkedNode *removeNode = node -> next;
	// 将前一节点的next指向删除节点的next
	node -> next = removeNode -> next;
	// 释放删除节点的内存
	free(removeNode);
	// 删除成功
	return true;
}

12. 按值查找

/**
 * @brief 有头节点的按值获取
 * 
 * @param list 带头结点的单链表
 * @param data 要查找的数据
 * @return LinkedNode* 根据条件查找到的节点
 */
LinkedNode* haveHeadGetValueFirst(LinkedList &list, int data) {
	// 临时指针指向第一个节点
	LinkedNode *node = list -> next;
	while (node != NULL) {
		// 循环如果没到最后一个几点，判断当前节点的数据是否和传入数据相等
		if (node -> data == data) {
			// 相等返回这个节点
			return node;
		}
		// 不相等继续往下一个节点判断
		node = node -> next;
	}
	// 整个链表没找到对应的值返回null
	return NULL;
}

注：在第一个插入、按下标插入以及删除第一个、按下标删除的操作是可以整合在一起的，但是由于个人习惯将其分开，因为插入删除第一个的时间复杂度都是O(1), 但是下标插入、下标删除都是O(n)，并且在调用方法的时候代码的可用性比较高，简单明了。

若有错误欢迎指正，如有不懂也可相互交流