线性表-向前链表的存储结构

/*****************************************************************************************************
*线性表-向前链表的存储结构
*概念：
*它不要求逻辑上相邻的元素在物理地址上也相邻，因此可以避免顺序线性表的弱点
*向前链表的基本操作有：插入、删除、查找、遍历等
*****************************************************************************************************/

//======================================================向前链式线性表BEGIN====================================================


/*****************************************************************************************************
*数据域info存放线性表元素的值，指针域link保存下一个元素的指针
*****************************************************************************************************/
typedef struct node
{
	char info;							//数据域
	struct node *link;					//指针域
}NODE;


/*****************************************************************************************************
*函数名称:chainedAppend
*功能描述:在表头节点之后插入一个新的节点
*输入参数:NODE*:表头节点		arg:插入的数据
*返 回 值:无
*作    者:zj
*日    期:2024-12-13
*备    注:
*****************************************************************************************************/
void chainedAppend(NODE* head, const char arg)
{
	NODE *ptr = (NODE*)malloc(sizeof(NODE));
	ptr->info = arg;
	ptr->link = head->link;
	head->link = ptr;
}


/*****************************************************************************************************
*函数名称:chainedInsert
*功能描述:在已知节点后插入一个节点
*输入参数:NODE*:已知节点		arg:插入值
*返 回 值:无
*作    者:zj
*日    期:2024-12-13
*备    注:
*****************************************************************************************************/
void chainedInsert(NODE* pf, const char arg)
{
	NODE* ptr = (NODE*)malloc(sizeof(NODE));
	ptr->info = arg;
	ptr->link = pf->link;
	pf->link = ptr;
}


/*****************************************************************************************************
*函数名称:chainedDelete
*功能描述:删除指定节点
*输入参数:NODE*:被删除节点的前一个节点
*返 回 值:无
*作    者:zj
*日    期:2024-12-13
*备    注:
*****************************************************************************************************/
void chainedDelete(NODE* pf)
{
	if (pf->link == nullptr)
	{
		return;
	}

	NODE* ptr = pf->link;
	pf->link = ptr->link;
	ptr->link = nullptr;
	free(ptr);
}


/*****************************************************************************************************
*函数名称:chainedDeleteAll
*功能描述:删除当前节点后的所有节点
*输入参数:NODE*:当前节点
*返 回 值:无
*作    者:zj
*日    期:2024-12-13
*备    注:
*****************************************************************************************************/
void chainedDeleteAll(NODE* pf)
{
	while (pf->link)
	{
		chainedDelete(pf);
	}
}


/*****************************************************************************************************
*函数名称:chainedFind
*功能描述:查找指定的节点
*输入参数:NODE*:表头节点		arg:要查找的值
*返 回 值:若找到返回当前节点，否则返回空
*作    者:zj
*日    期:2024-12-13
*备    注:
*****************************************************************************************************/
NODE* chainedFind(NODE* head, const char arg)
{
	NODE* it = head->link;
	while (it)
	{
		if (it->info == arg)
		{
			return it;
		}
		it = it->link;
	}

	return nullptr;
}

//递归实现
NODE* chainedFind_Rec(NODE* pf, const char arg)
{
	if (pf == nullptr)
	{
		return nullptr;
	}

	if (pf->info == arg)
	{
		return pf;
	}
	return chainedFind_Rec(pf->link, arg);
}



/*****************************************************************************************************
*函数名称:chainedDiff
*功能描述:利用向前链表实现集合A-B,删除集合A中在集合B中存在的元素
*输入参数:NODE*:集合A	NODE*:集合B
*返 回 值:无
*作    者:zj
*日    期:2024-12-13
*备    注:
*****************************************************************************************************/
void chainedDiff(NODE* target, NODE* source)
{
	NODE* ptr = target;
	while (ptr->link)
	{
		NODE* it = ptr->link;
		if (NODE* ret = chainedFind(source, it->info))
		{
			chainedDelete(ptr);
			continue;
		}
		ptr = ptr->link;
	}
}


/*****************************************************************************************************
*函数名称:chainedUnion
*功能描述:利用向前链表实现集合A与集合B的并集
*输入参数:NODE*:集合A	NODE*:集合B
*返 回 值:无
*作    者:zj
*日    期:2024-12-13
*备    注:
*****************************************************************************************************/
void chainedUnion(NODE* target, NODE* source)
{
	NODE* it = source->link;
	while (it)
	{
		chainedAppend(target, it->info);
		it = it->link;
	}
}


/*****************************************************************************************************
*函数名称:chainedCopy
*功能描述:拷贝向前链表
*输入参数:NODE*:目标位置	NODE*:源数据
*返 回 值:无
*作    者:zj
*日    期:2024-12-13
*备    注:
*****************************************************************************************************/
void chainedCopy(NODE* target, NODE* source)
{
	NODE* it = source->link;
	while (it)
	{
		chainedAppend(target, it->info);
		it = it->link;
	}
}


/*****************************************************************************************************
*函数名称:chainedProcess
*功能描述:利用向前链表实现集合运算(A-B)并集(B-A)
*输入参数:NODE*:集合A	NODE*:集合B
*返 回 值:无
*作    者:zj
*日    期:2024-12-13
*备    注:
*****************************************************************************************************/
void chainedProcess(NODE* target, NODE* source)
{
	//创建辅助空间
	NODE* targetCopy = (NODE*)malloc(sizeof(NODE));
	targetCopy->link = nullptr;
	chainedCopy(targetCopy, target);

	NODE* sourceCopy = (NODE*)malloc(sizeof(NODE));
	sourceCopy->link = nullptr;
	chainedCopy(sourceCopy, source);

	chainedDiff(target, sourceCopy);
	chainedDiff(sourceCopy, targetCopy);
	chainedUnion(target, sourceCopy);

	//删除辅助空间
	chainedDeleteAll(targetCopy);
	free(targetCopy);

	chainedDeleteAll(sourceCopy);
	free(sourceCopy);
}

//======================================================向前链式线性表END====================================================

//测试代码
//======================================================链式存储BEGIN====================================================
void printNode(NODE* head)
{
	NODE* it = head->link;
	while (it)
	{
		std::cout << it->info ;
		it = it->link;
	}
	std::cout << std::endl;
}
void nodeTest()
{
	NODE* head = (NODE*)malloc(sizeof(NODE));
	head->link = nullptr;
	NODE* head1 = (NODE*)malloc(sizeof(NODE));
	head1->link = nullptr;
	for (int i = 0; i < 26; i++)
	{
		chainedAppend(head, i + 'a');
	}
	printNode(head);

	for (int i = 0; i < 10; i++)
	{
		chainedAppend(head1, i + 'a');
	}
	for (int i = 0; i < 10; i++)
	{
		chainedAppend(head1, i + '0');
	}
	printNode(head1);

	chainedDelete(head);
	printNode(head);

	NODE* ptr = chainedFind_Rec(head, '0');
	if (ptr != nullptr)
	{
		std::cout << ptr->info << std::endl;
	}

	chainedProcess(head, head1);
	printNode(head);
}
//======================================================链式存储END====================================================
//使用main函数调用nodeTest

测试代码：