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

1. 定义一个结构体

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

2. 初始化

/**
 * @brief 初始化一个不带头结点的单链表
 * 
 * @return LinkedList NULL
 */
LinkedList initLinkedListNoHead() {
	// 因为不带头结点，所以这个单链表的第一个元素就为null
	// 则直接返回null调用的时候使用声明并使用LinkedList接收即可 
	return NULL;
}

3. 判空

/**
 * @brief 没有头节点的单链表是否为空
 * 
 * @param l 一个没有头节点的单链表
 * @return true 为空
 * @return false 不为空
 */
bool isEmptyNoHead(LinkedList l) {
	// 因为没有头节点，直接判断其next是否为null
	return l == NULL;
}

4. 遍历打印

/**
 * @brief 遍历打印无头结点单链表
 * 
 * @param list 无头结点单链表
 */
void noHeadPrint(LinkedList list) {
	LinkedNode *node = list;
	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 noHeadInsertToFirst(LinkedList &list, int data) {
	// 申请一个空间存放节点
	LinkedNode *node = (LinkedNode *)malloc(sizeof(LinkedNode));
	// 节点的数据赋值
	node -> data = data;
	// 将新节点的next指针指向链表指向的位置
	node -> next = list;
	// 更改链表指针
	list = node;
	return true;
}

6. 按位查找

/**
 * @brief 无头结点的单链表按位查找
 * 
 * @param list 
 * @param index 
 * @return LinkedNode* 
 */
LinkedNode* noHeadGetByIndex(LinkedList &list, int index) {
	// 如果当前链表为空直接返回NULL
	if (isEmptyNoHead(list)) {
		return NULL;
	}
	
	// 下标不合法
	if (index < 0) {
		return NULL;
	}
	

	// 声明临时节点指针指向链表的第一个节点
	LinkedNode *node = list;
	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 noHeadInsterByIndex(LinkedList &list, int index, int data) {
	// 下标小于零为非法参数
	if (index < 0) {
		return false;
	}
	
	// 下标等于一直接调用没有头节点的单链表在第一个位置插入的方法
	if (index == 0) {
		noHeadInsertToFirst(list, data);
		return true;
	}
	
	// 链表为空无法操作
	if (isEmptyNoHead(list)) {
		return false;
	}

	// 调用不带头结点的单链表的按位查找找到要插入下标位置的前一个节点
	LinkedNode *node = noHeadGetByIndex(list, index - 1);

	// 如果返回的节点指针为null则证明下标不合法
	if (node == NULL) {
		return false;
	}

	// 直接调用后插方法
	return insertByNodeAfter(node, data);
}

10. 删除第一个

/**
 * @brief 删除不带头结点的第一个元素
 * 
 * @param list 不带头结点的单链表
 * @return true 删除成功
 * @return false 删除失败
 */
bool noHeadRemoveFirst(LinkedList &list) {
	// 判断单链表是否为空
	bool flag = isEmptyNoHead(list);
	if (flag) {
		// 为空无法操作
		return false;
	}
	
	// 将无头节点的第一个元素进行临时保存
	LinkedNode *node = list;
	// 将无头节点的头指针指向第二个元素作为删除后的第一个元素
	list = node -> next;
	// 释放临时存储的第一个节点
	free(node);
	// 删除成功
	return true;
}

11. 删除指定下标

/**
 * @brief 无头节点根据下标删除
 * 
 * @param list 无头结点单链表
 * @param index 下标
 * @return true 删除成功
 * @return false 删除失败
 */
bool noHeadRemoveByIndex(LinkedList &list, int index) {
	// 链表为空无法操作
	if (isEmptyNoHead(list)) {
		return false;
	}

	// 获取要删除节点的前一个节点
	LinkedNode *node = noHeadGetByIndex(list, index - 1);
	if (node == NULL) {
		// 如果前一个节点为null无法操作
		return false;
	}
	
	// 得到要删除的节点
	LinkedNode *removeNode = node -> next;
	// 将前一个节点的next指向删除的节点的下一个节点
	node -> next = removeNode -> next;
	// 释放删除的节点内存
	free(removeNode);
	// 删除成功
	return true;
}

12. 按值获取

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

13. 元素下标修改元素值

/**
 * @brief 无头节点的根据下标修改元素值
 * 
 * @param list 无头结点单链表
 * @param index 下标
 * @param data 目标数据
 * @return true 修改成功
 * @return false 修改失败
 */
bool noHeadModifyByIndex(LinkedList &list, int index, int data) {
	// 链表为空无法操作
	if (isEmptyNoHead(list)) {
		return false;
	}
	// 非法参数
	if (index < 0) {
		return false;
	}
	// 获取要修改位置节点的前一个节点
	LinkedNode *node = noHeadGetByIndex(list, index - 1);
	// 节点为null下标为非法参数
	if (node == NULL) {
		return false;
	}
	// 将修改位置的数据赋值为新的值
	node -> next -> data = data;
	// 修改成功
	return true;
}

14. 将无头结点中的某个值全部修改成另一个值

/**
 * @brief 无头结点将链表中的某个值全部修改成另一个值
 * 
 * @param list 无头结点单链表
 * @param source 原值
 * @param target 目标值
 * @return true 修改成功
 * @return false 修改失败
 */
bool noHeadModifyByValue(LinkedList &list, int source, int target) {
	// 链表为空无法操作
	if (isEmptyNoHead(list)) {
		return false;
	}

	// 临时变量指向链表的第一个元素
	LinkedNode *node = list;
	while (node != NULL) {
		if (node -> data == source) {
			// 如果当前节点的数据和传入的source相同，则修改成target
			node -> data = target;
		}
		node = node -> next;
	}
	// 修改成功
	return true;
}

15. 尾插法

/**
 * @brief 无头节点的尾插法
 * 
 * @param dataArr 要插入的数据数组
 * @param initLength 初始化长度
 * @return LinkedList 初始化好的无头结点的单链表
 */
LinkedList noHeadCreateByTail(int dataArr[], int initLength) {
	// 初始化一个空的不带头结点的单链表
	LinkedList list = initLinkedListNoHead();
	// 声明一个节点指针指向链表
	LinkedNode *node = list;
	// 声明一个尾指针指向链表
	LinkedNode *tail = list;
	for (int i = 0; i < initLength; i++) {
		// 申请一个内存空间给节点指针
		node = (LinkedNode*) malloc(sizeof(LinkedNode));
		
		// 节点数据
		node -> data = dataArr[i];
		// 节点的next为空
		node -> next = NULL;
		if (i == 0)	{
			// 如果当前是第一个元素则将头指针指向当前节点
			list = node;
		} else {
			// 如果不是第一个则将尾指针指向的节点的next指向新节点
			tail -> next = node;
		}
		// 将尾指针指向当前节点
		tail = node;
	}
	// 返回这个单链表
	return list;
}

16. 头插法

/**
 * @brief 无头结点的头插法
 * 
 * @param dataArr 初始化数据
 * @param initLehgth 初始化长度
 * @return LinkedList 初始化完成的无头结点单链表
 */
LinkedList noHeadCreateByHead(int dataArr[], int initLength) {
	// 初始化一个无头结点的的单链表
	LinkedList list = initLinkedListNoHead();
	for (int i = 0; i < initLength; i++) {
		// 为新节点申请内存空间
		LinkedNode *node = (LinkedNode*)malloc(sizeof(LinkedNode));
		// 新节点数据赋值
		node -> data = dataArr[i];
		if(i == 0) {
			// 头插法数组第一个元素最终为表尾元素
			node -> next = NULL;
		} else {
			// 其他元素的next指向当list的第一个元素
			node -> next = list;
		}
		// list指向当前节点
		list = node;
	}
	// 返回这个链表
	return list;
}

17. 逆置

/**
 * @brief 无头结点单链表逆置
 * 
 * @param list 无头结点单链表
 * @return LinkedList 逆置后的单链表
 */
LinkedList noHeadInversion(LinkedList list) {
	// 定义指针指向存储原单链表的数据
	int *data;
	// 临时指针指向单链表的每个节点
	LinkedNode *node = list;
	LinkedNode *temp;
	// 计数器
	int i = 0;
	while (node != NULL) {
		// 循环单链表的节点存储数据
		data[i] = node -> data;
		temp = node -> next;
		// 释放节点内存空间
		free(node);
		// 指向下一个节点
		node = temp;
		i++;
	}
	// 头插法逆置返回逆置后的单链表
	return noHeadCreateByHead(data, i);
}

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

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