二叉树的线索化——C语言描述

最新推荐文章于 2024-08-25 22:48:39 发布
最新推荐文章于 2024-08-25 22:48:39 发布
阅读量64 收藏
点赞数
分类专栏： c语言学习 数据结构 文章标签： c语言 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59469991/article/details/128695523
版权

二叉树的线索化——C语言描述

文章目录

0 测试用例框架

https://blog.csdn.net/m0_59469991/article/details/127137119?csdn_share_tail=%7B%22type%22%3A%22blog%22%2C%22rType%22%3A%22article%22%2C%22rId%22%3A%22127137119%22%2C%22source%22%3A%22m0_59469991%22%7D

1 定义

​ 利用叶子节点左右孩子的空指针部分，若无孩子节点，那该节点的孩子指针指向中序遍历的下一个节点。中序遍历的第一个节点指向头节点，中序遍历的最后一个节点指向头节点。头节点的左孩子指向根节点，头节点右孩子指向中序遍历的最后一个节点。这时整个树的结构变成一个双向链表。

2 数据结构

/*BINARY_THREAD_TREE_NODE*/
typedef struct _BINARY_THREAD_TREE_NODE {
	char Data;
	char IfExistDirectLeftNodeFlag;
	char IfExistDirectRightNodeFlag;
	struct _BINARY_THREAD_TREE_NODE *LeftChild;
	struct _BINARY_THREAD_TREE_NODE *RightChild;
}BINARY_THREAD_TREE_NODE;

3 实现方法

void PreOrderTraversePrintBinaryThreadTree(const BINARY_THREAD_TREE_NODE *BiThrTreeNode) {
	//printf("BiThrTreeNode = 0x%lx\n", BiThrTreeNode);
	if (BiThrTreeNode == NULL) {
		return;
	}
	else {
		printf("BiThrTreeNode = 0x%lx, BiThrTreeNode->Data = %c, BiThrTreeNode->LeftChild = 0x%lx, BiThrTreeNode->RightChild = 0x%lx\n", (long unsigned int)BiThrTreeNode, BiThrTreeNode->Data, (long unsigned int)BiThrTreeNode->LeftChild, (long unsigned int)BiThrTreeNode->RightChild);
		//printf("BiThrTreeNode->LeftChild = 0x%lx, BiThrTreeNode->RightChild = 0x%lx\n", BiThrTreeNode->LeftChild, BiThrTreeNode->RightChild);
		PreOrderTraversePrintBinaryThreadTree(BiThrTreeNode->LeftChild);
		PreOrderTraversePrintBinaryThreadTree(BiThrTreeNode->RightChild);
	}
}

void InOrderTraversePrintBinaryThreadTree(const BINARY_THREAD_TREE_NODE *BiThrTreeNode) {
	if (BiThrTreeNode == NULL) {
		return;
	}
	else {
		InOrderTraversePrintBinaryThreadTree(BiThrTreeNode->LeftChild);
		printf("BiThrTreeNode = 0x%lx, BiThrTreeNode->Data = %c, BiThrTreeNode->LeftChild = 0x%lx, BiThrTreeNode->RightChild = 0x%lx\n", (long unsigned int)BiThrTreeNode, BiThrTreeNode->Data, (long unsigned int)BiThrTreeNode->LeftChild, (long unsigned int)BiThrTreeNode->RightChild);
		InOrderTraversePrintBinaryThreadTree(BiThrTreeNode->RightChild);
	}
}

void PostOrderTraversePrintBinaryThreadTree(const BINARY_THREAD_TREE_NODE *BiThrTreeNode) {
	if (BiThrTreeNode == NULL) {
		return;
	}
	else {
		PostOrderTraversePrintBinaryThreadTree(BiThrTreeNode->LeftChild);
		PostOrderTraversePrintBinaryThreadTree(BiThrTreeNode->RightChild);
		printf("BiThrTreeNode = 0x%lx, BiThrTreeNode->Data = %c, BiThrTreeNode->LeftChild = 0x%lx, BiThrTreeNode->RightChild = 0x%lx\n", (long unsigned int)BiThrTreeNode, BiThrTreeNode->Data, (long unsigned int)BiThrTreeNode->LeftChild, (long unsigned int)BiThrTreeNode->RightChild);
	}
}

int Index = 0;
void PreOrderBuildBiThrTree(BINARY_THREAD_TREE_NODE **BiThrTreeNodePtr, BINARY_THREAD_TREE_NODE_DATA *DataPtr, char IfExistNodeFlag) {
	char IfExistLeftChildNodeFlag = 0;
	char IfExistRightChildNodeFlag = 0;

	// printf("Index = %d\n", Index);
	// printf("PreOrderBuildBiThrTree start\n");
	// printf("IfExistNodeFlag = %d\n", IfExistNodeFlag);
	//Exit condition
	if (IfExistNodeFlag == 0) {
		*BiThrTreeNodePtr = NULL;
		//--Index;
		return;
	}
	else {
		//The level logic
		*BiThrTreeNodePtr = (BINARY_THREAD_TREE_NODE *)malloc(sizeof(BINARY_THREAD_TREE_NODE));
		// printf("*BiThrTreeNodePtr = 0x%lx\n", (long unsigned int )(*BiThrTreeNodePtr));
		// printf("In else, DataPtr[%d] = %c\n", Index, DataPtr[Index].BiThrTreeData);
		(*BiThrTreeNodePtr)->Data = DataPtr[Index].BiThrTreeData;
		(*BiThrTreeNodePtr)->IfExistDirectLeftNodeFlag = DataPtr[Index].IfExistDirectLeftNodeFlag;
		(*BiThrTreeNodePtr)->IfExistDirectRightNodeFlag = DataPtr[Index].IfExistDirectRightNodeFlag;

		IfExistLeftChildNodeFlag = DataPtr[Index].IsExistLeftChildFlag;
		IfExistRightChildNodeFlag = DataPtr[Index].IsExistRightChildFlag;

		// printf("IfExistLeftChildNodeFlag = %d, IfExistRightChildNodeFlag = %d\n", IfExistLeftChildNodeFlag, IfExistRightChildNodeFlag);

		Index++;

		//Next level
		PreOrderBuildBiThrTree(&((*BiThrTreeNodePtr)->LeftChild), DataPtr, IfExistLeftChildNodeFlag);

		// printf("Index = %d\n", Index);

		PreOrderBuildBiThrTree(&((*BiThrTreeNodePtr)->RightChild), DataPtr, IfExistRightChildNodeFlag);
	}

	// printf("PreOrderBuildBiThrTree end\n");
}


BINARY_THREAD_TREE_NODE *BiThrTrPreNode = NULL;
void InOrderThrBiTree(BINARY_THREAD_TREE_NODE *BiThrTrNode) {
	if (BiThrTrNode == NULL) {
		return;
	}
	else {
		InOrderThrBiTree(BiThrTrNode->LeftChild);

		//printf("BiThrTrNode = 0x%lx, BiThrTrNode->Data = %c, BiThrTrNode->LeftChild = 0x%lx, BiThrTrNode->RightChild = 0x%lx\n", (long unsigned int )BiThrTrNode, BiThrTrNode->Data, (long unsigned int )BiThrTrNode->LeftChild, (long unsigned int )BiThrTrNode->RightChild);

		//The Level
		if (BiThrTrNode->LeftChild == NULL) {
			BiThrTrNode->LeftChild = BiThrTrPreNode;
		}

		if (BiThrTrPreNode->RightChild == NULL) {
			BiThrTrPreNode->RightChild = BiThrTrNode;
		}

		BiThrTrPreNode = BiThrTrNode;
		//printf("BiThrTrNode->Data = %c\n", BiThrTrNode->Data);
		InOrderThrBiTree(BiThrTrNode->RightChild);
	}
}


void PrintThrTree(BINARY_THREAD_TREE_NODE *BiThrTrNode) {
	BINARY_THREAD_TREE_NODE *BiThrTrNodeTemp = BiThrTrNode->LeftChild;

	//printf("\nPrintThrTree start\n");
	//printf("Root Node, BiThrTrNodeTemp = 0x%lx, BiThrTrNodeTemp->Data = %c, BiThrTrNodeTemp->LeftChild = 0x%lx, BiThrTrNodeTemp->RightChild = 0x%lx\n", (long unsigned int)BiThrTrNodeTemp, BiThrTrNodeTemp->Data, (long unsigned int)BiThrTrNodeTemp->LeftChild, (long unsigned int)BiThrTrNodeTemp->RightChild);
	while (BiThrTrNodeTemp != BiThrTrNode) {
		//printf("test01\n");
		while (BiThrTrNodeTemp->IfExistDirectLeftNodeFlag != 0) {
			BiThrTrNodeTemp = BiThrTrNodeTemp->LeftChild;
		}

		printf("BiThrTrNodeTemp = 0x%lx, BiThrTrNodeTemp->Data = %c, BiThrTrNodeTemp->LeftChild = 0x%lx, BiThrTrNodeTemp->RightChild = 0x%lx\n", (long unsigned int)BiThrTrNodeTemp, BiThrTrNodeTemp->Data, (long unsigned int)BiThrTrNodeTemp->LeftChild, (long unsigned int)BiThrTrNodeTemp->RightChild);

		while ((BiThrTrNodeTemp->IfExistDirectRightNodeFlag == 0) && (BiThrTrNodeTemp->RightChild != BiThrTrNode)) {
			BiThrTrNodeTemp = BiThrTrNodeTemp->RightChild;
			printf("BiThrTrNodeTemp = 0x%lx, BiThrTrNodeTemp->Data = %c, BiThrTrNodeTemp->LeftChild = 0x%lx, BiThrTrNodeTemp->RightChild = 0x%lx\n", (long unsigned int)BiThrTrNodeTemp, BiThrTrNodeTemp->Data, (long unsigned int)BiThrTrNodeTemp->LeftChild, (long unsigned int)BiThrTrNodeTemp->RightChild);
		}

		BiThrTrNodeTemp = BiThrTrNodeTemp->RightChild;
		//printf("BiThrTrNodeTemp = 0x%lx, BiThrTrNodeTemp->RightChild = 0x%lx\n", (long unsigned int )BiThrTrNodeTemp, (long unsigned int )BiThrTrNodeTemp->RightChild);
	}

	printf("PrintThrTree end\n");
}

void BuildBinaryThreadTree(BINARY_THREAD_TREE_NODE **BiThrTreeNode, BINARY_THREAD_TREE_NODE_DATA *DataPtr) {
	char IfExistNodeFlag = 1;
	Index = 0;
	BINARY_THREAD_TREE_NODE *BiThrTrHeadNode = NULL;

	/*HeadNode*/
	*BiThrTreeNode = (BINARY_THREAD_TREE_NODE *)malloc(sizeof(BINARY_THREAD_TREE_NODE));
	BiThrTrHeadNode = *BiThrTreeNode;
	BiThrTrHeadNode->Data = 'H';
	BiThrTrHeadNode->IfExistDirectLeftNodeFlag = 1;
	BiThrTrHeadNode->IfExistDirectRightNodeFlag = 1;
	BiThrTrHeadNode->RightChild = (BINARY_THREAD_TREE_NODE *)malloc(sizeof(BINARY_THREAD_TREE_NODE));
	BiThrTrHeadNode->LeftChild = NULL;

	printf("BuildBinaryThreadTree start\n");
	//printf("BiThrTrHeadNode = 0x%lx\n", (long unsigned int)BiThrTrHeadNode);

	   /*Build tree*/
	PreOrderBuildBiThrTree(&(BiThrTrHeadNode->LeftChild), DataPtr, IfExistNodeFlag);

	BiThrTrPreNode = BiThrTrHeadNode;

	// printf("\nPreOrderTraversePrintBinaryThreadTree\n"); 
	// PreOrderTraversePrintBinaryThreadTree(BiThrTrHeadNode->LeftChild);
	// printf("InOrderTraversePrintBinaryThreadTree\n"); 
	// InOrderTraversePrintBinaryThreadTree(BiThrTrHeadNode->LeftChild);
	// printf("PostOrderTraversePrintBinaryThreadTree\n");
	// PostOrderTraversePrintBinaryThreadTree(BiThrTrHeadNode->LeftChild);

	   /*In Order thread*/
	printf("\nInOrderThrBiTree\n");
	InOrderThrBiTree(BiThrTrHeadNode->LeftChild);

	BiThrTrPreNode->RightChild = BiThrTrHeadNode;
	BiThrTrHeadNode->RightChild = BiThrTrPreNode;

	PrintThrTree(BiThrTrHeadNode);

	printf("BuildBinaryThreadTree end\n");
}

4 测试用例

typedef struct _BINARY_THREAD_TREE_NODE_DATA {
	char BiThrTreeData;
	char IfExistDirectLeftNodeFlag;
	char IfExistDirectRightNodeFlag;
	char IsExistLeftChildFlag;
	char IsExistRightChildFlag;
}BINARY_THREAD_TREE_NODE_DATA;

/*BINARY_THREAD_TREE*/
int PreOrderTraverseCmpPreOderBuildBiThrTree(const BINARY_THREAD_TREE_NODE_DATA *CmpNode, int Index, const BINARY_THREAD_TREE_NODE *BiThrTreeNode, int PreOrderTraverseCmpBiThrTreeNum) {
	BINARY_THREAD_TREE_NODE *BiThrTrNodeTemp = BiThrTreeNode->LeftChild;

	printf("\n\nTest PreOrderTraverseCmpPreOderBuildBiThrTree start\n");
	//printf("Root Node, BiThrTrNodeTemp = 0x%lx, BiThrTrNodeTemp->Data = %c, BiThrTrNodeTemp->LeftChild = 0x%lx, BiThrTrNodeTemp->RightChild = 0x%lx\n", (long unsigned int)BiThrTrNodeTemp, BiThrTrNodeTemp->Data, (long unsigned int)BiThrTrNodeTemp->LeftChild, (long unsigned int)BiThrTrNodeTemp->RightChild);
	while (BiThrTrNodeTemp != BiThrTreeNode) {
		//printf("test01\n");
		while (BiThrTrNodeTemp->IfExistDirectLeftNodeFlag != 0) {
			BiThrTrNodeTemp = BiThrTrNodeTemp->LeftChild;
		}

		printf("BiThrTrNodeTemp = 0x%lx, BiThrTrNodeTemp->Data = %c, BiThrTrNodeTemp->LeftChild = 0x%lx, BiThrTrNodeTemp->RightChild = 0x%lx\n", (long unsigned int)BiThrTrNodeTemp, BiThrTrNodeTemp->Data, (long unsigned int)BiThrTrNodeTemp->LeftChild, (long unsigned int)BiThrTrNodeTemp->RightChild);
		printf("CmpNode[Index].BiThrTreeData = %c\n", CmpNode[Index].BiThrTreeData);
		if (CmpNode[Index++].BiThrTreeData == BiThrTrNodeTemp->Data) {
			PreOrderTraverseCmpBiThrTreeNum++;
		}

		while ((BiThrTrNodeTemp->IfExistDirectRightNodeFlag == 0) && (BiThrTrNodeTemp->RightChild != BiThrTreeNode)) {
			BiThrTrNodeTemp = BiThrTrNodeTemp->RightChild;
			printf("BiThrTrNodeTemp = 0x%lx, BiThrTrNodeTemp->Data = %c, BiThrTrNodeTemp->LeftChild = 0x%lx, BiThrTrNodeTemp->RightChild = 0x%lx\n", (long unsigned int)BiThrTrNodeTemp, BiThrTrNodeTemp->Data, (long unsigned int)BiThrTrNodeTemp->LeftChild, (long unsigned int)BiThrTrNodeTemp->RightChild);
			printf("CmpNode[Index].BiThrTreeData = %c\n", CmpNode[Index].BiThrTreeData);
			if (CmpNode[Index++].BiThrTreeData == BiThrTrNodeTemp->Data) {
				PreOrderTraverseCmpBiThrTreeNum++;
			}
		}

		BiThrTrNodeTemp = BiThrTrNodeTemp->RightChild;
		//printf("BiThrTrNodeTemp = 0x%lx, BiThrTrNodeTemp->RightChild = 0x%lx\n", (long unsigned int )BiThrTrNodeTemp, (long unsigned int )BiThrTrNodeTemp->RightChild);
	}

	printf("PreOrderTraverseCompareBinaryThreadTree03 end\n");
	return PreOrderTraverseCmpBiThrTreeNum;
}

void CmpPreOderBuildBiThrTree(const BINARY_THREAD_TREE_NODE_DATA *CmpNode, int Index, const BINARY_THREAD_TREE_NODE *BiThrTreeNode, int NodeNum) {
	//unsigned char Index = 0;
	int PreOrderTraverseCmpBiThrTreeNum = 0;
	//Index = 0;

	TestNum++;

	PreOrderTraverseCmpBiThrTreeNum = PreOrderTraverseCmpPreOderBuildBiThrTree(CmpNode, Index, BiThrTreeNode, PreOrderTraverseCmpBiThrTreeNum);
	printf("PreOrderTraverseCmpBiThrTreeNum = %d, NodeNum = %d\n", PreOrderTraverseCmpBiThrTreeNum, NodeNum);
	if (PreOrderTraverseCmpBiThrTreeNum != NodeNum) {
		FaildNum++;
	}
	else {
		PassNum++;
	}
}


/*BINARY_THREAD_TREE*/
void TestBuildBinaryThreadTree(void) {
	/*Test01*/
	//    A
	//  B    C
	BINARY_THREAD_TREE_NODE  *BiThrTreeNodePtr01 = NULL;
	BINARY_THREAD_TREE_NODE_DATA  BiThrTreeNodeData01[] = { {'A', 1, 1, 1, 1}, {'B', 0, 0, 0, 0}, {'C', 0, 0, 0, 0} };
	int NodeNum01 = 3;
	char IfExistNodeFlag01 = 1;
	BINARY_THREAD_TREE_NODE_DATA  CmpBiThrTreeNodeData01[] = { {'B', 0, 0, 0, 0}, {'A', 1, 1, 1, 1}, {'C', 0, 0, 0, 0} };
	int Index01 = 0;

	//    A
	//  B    E
	// C  D  F  G
	BINARY_THREAD_TREE_NODE  *BiThrTreeNodePtr02 = NULL;
	BINARY_THREAD_TREE_NODE_DATA  BiThrTreeNodeData02[] = { {'A', 1, 1, 1, 1}, {'B', 1, 1, 1, 1}, {'C', 0, 0, 0, 0}, {'D', 0, 0, 0, 0},
				 {'E', 1, 1, 1, 1}, {'F', 0, 0, 0, 0}, {'G', 0, 0, 0, 0} };
	int NodeNum02 = 7;

	BINARY_THREAD_TREE_NODE_DATA  CmpBiThrTreeNodeData02[] = { {'C', 0, 0, 0, 0}, {'B', 0, 0, 0, 0}, {'D', 0, 0, 0, 0}, {'A', 1, 1, 1, 1},
				   {'F', 0, 0, 0, 0}, {'E', 1, 1, 1, 1}, {'G', 0, 0, 0, 0} };
	int Index02 = 0;

	//    A
	//  B    C
	//   D    
	BINARY_THREAD_TREE_NODE  *BiThrTreeNodePtr03 = NULL;
	BINARY_THREAD_TREE_NODE_DATA BiThrTreeNodeData03[] = { {'A', 1, 1, 1, 1}, {'B', 0, 1, 0, 1}, {'D', 0, 0, 0, 0}, {'C', 0, 0, 0, 0} };
	int NodeNum03 = 4;
	BINARY_THREAD_TREE_NODE_DATA  CmpBiThrTreeNodeData03[] = { {'B', 0, 0, 0, 0}, {'D', 0, 0, 0, 0}, {'A', 1, 1, 1, 1}, {'C', 0, 0, 0, 0} };
	int Index03 = 0;


	printf("-------Test start----------\n");
	InitNum();

	/*Test01*/
	printf("\n-------Test 01----------\n");
	BuildBinaryThreadTree(&BiThrTreeNodePtr01, BiThrTreeNodeData01);
	CmpPreOderBuildBiThrTree(CmpBiThrTreeNodeData01, Index01, BiThrTreeNodePtr01, NodeNum01);


	/*Test02*/
	printf("\n-------Test 02----------\n");
	BuildBinaryThreadTree(&BiThrTreeNodePtr02, BiThrTreeNodeData02);
	CmpPreOderBuildBiThrTree(CmpBiThrTreeNodeData02, Index02, BiThrTreeNodePtr02, NodeNum02);

	/*Test03*/
	printf("\n-------Test 03----------\n");
	BuildBinaryThreadTree(&BiThrTreeNodePtr03, BiThrTreeNodeData03);
	CmpPreOderBuildBiThrTree(CmpBiThrTreeNodeData03, Index03, BiThrTreeNodePtr03, NodeNum03);

	/*Test Result*/
	printf("\n-------Test result----------\n");
	TestResult();
}

打印结果

-------Test start----------

-------Test 01----------

BuildBinaryThreadTree start

InOrderThrBiTree

BiThrTrNodeTemp = 0xcf3ee0, BiThrTrNodeTemp->Data = B, BiThrTrNodeTemp->LeftChild = 0xcf4d00, BiThrTrNodeTemp->RightChild = 0xcf3ea8

BiThrTrNodeTemp = 0xcf3ea8, BiThrTrNodeTemp->Data = A, BiThrTrNodeTemp->LeftChild = 0xcf3ee0, BiThrTrNodeTemp->RightChild = 0xcf8da0

BiThrTrNodeTemp = 0xcf8da0, BiThrTrNodeTemp->Data = C, BiThrTrNodeTemp->LeftChild = 0xcf3ea8, BiThrTrNodeTemp->RightChild = 0xcf4d00

PrintThrTree end

BuildBinaryThreadTree end

Test PreOrderTraverseCmpPreOderBuildBiThrTree start

BiThrTrNodeTemp = 0xcf3ee0, BiThrTrNodeTemp->Data = B, BiThrTrNodeTemp->LeftChild = 0xcf4d00, BiThrTrNodeTemp->RightChild = 0xcf3ea8

CmpNode[Index].BiThrTreeData = B

BiThrTrNodeTemp = 0xcf3ea8, BiThrTrNodeTemp->Data = A, BiThrTrNodeTemp->LeftChild = 0xcf3ee0, BiThrTrNodeTemp->RightChild = 0xcf8da0

CmpNode[Index].BiThrTreeData = A

BiThrTrNodeTemp = 0xcf8da0, BiThrTrNodeTemp->Data = C, BiThrTrNodeTemp->LeftChild = 0xcf3ea8, BiThrTrNodeTemp->RightChild = 0xcf4d00

CmpNode[Index].BiThrTreeData = C

PreOrderTraverseCompareBinaryThreadTree03 end

PreOrderTraverseCmpBiThrTreeNum = 3, NodeNum = 3

-------Test 02----------

BuildBinaryThreadTree start

InOrderThrBiTree

BiThrTrNodeTemp = 0xcfd648, BiThrTrNodeTemp->Data = C, BiThrTrNodeTemp->LeftChild = 0xcf8dd8, BiThrTrNodeTemp->RightChild = 0xcf8e80

BiThrTrNodeTemp = 0xcf8e80, BiThrTrNodeTemp->Data = B, BiThrTrNodeTemp->LeftChild = 0xcfd648, BiThrTrNodeTemp->RightChild = 0xcfd808

BiThrTrNodeTemp = 0xcfd808, BiThrTrNodeTemp->Data = D, BiThrTrNodeTemp->LeftChild = 0xcf8e80, BiThrTrNodeTemp->RightChild = 0xcf8e48

BiThrTrNodeTemp = 0xcf8e48, BiThrTrNodeTemp->Data = A, BiThrTrNodeTemp->LeftChild = 0xcf8e80, BiThrTrNodeTemp->RightChild = 0xcfd5d8

BiThrTrNodeTemp = 0xcfd5a0, BiThrTrNodeTemp->Data = F, BiThrTrNodeTemp->LeftChild = 0xcf8e48, BiThrTrNodeTemp->RightChild = 0xcfd5d8

BiThrTrNodeTemp = 0xcfd5d8, BiThrTrNodeTemp->Data = E, BiThrTrNodeTemp->LeftChild = 0xcfd5a0, BiThrTrNodeTemp->RightChild = 0xcfd4c0

BiThrTrNodeTemp = 0xcfd4c0, BiThrTrNodeTemp->Data = G, BiThrTrNodeTemp->LeftChild = 0xcfd5d8, BiThrTrNodeTemp->RightChild = 0xcf8dd8

PrintThrTree end

BuildBinaryThreadTree end

Test PreOrderTraverseCmpPreOderBuildBiThrTree start

BiThrTrNodeTemp = 0xcfd648, BiThrTrNodeTemp->Data = C, BiThrTrNodeTemp->LeftChild = 0xcf8dd8, BiThrTrNodeTemp->RightChild = 0xcf8e80

CmpNode[Index].BiThrTreeData = C

BiThrTrNodeTemp = 0xcf8e80, BiThrTrNodeTemp->Data = B, BiThrTrNodeTemp->LeftChild = 0xcfd648, BiThrTrNodeTemp->RightChild = 0xcfd808

CmpNode[Index].BiThrTreeData = B

BiThrTrNodeTemp = 0xcfd808, BiThrTrNodeTemp->Data = D, BiThrTrNodeTemp->LeftChild = 0xcf8e80, BiThrTrNodeTemp->RightChild = 0xcf8e48

CmpNode[Index].BiThrTreeData = D

BiThrTrNodeTemp = 0xcf8e48, BiThrTrNodeTemp->Data = A, BiThrTrNodeTemp->LeftChild = 0xcf8e80, BiThrTrNodeTemp->RightChild = 0xcfd5d8

CmpNode[Index].BiThrTreeData = A

BiThrTrNodeTemp = 0xcfd5a0, BiThrTrNodeTemp->Data = F, BiThrTrNodeTemp->LeftChild = 0xcf8e48, BiThrTrNodeTemp->RightChild = 0xcfd5d8

CmpNode[Index].BiThrTreeData = F

BiThrTrNodeTemp = 0xcfd5d8, BiThrTrNodeTemp->Data = E, BiThrTrNodeTemp->LeftChild = 0xcfd5a0, BiThrTrNodeTemp->RightChild = 0xcfd4c0

CmpNode[Index].BiThrTreeData = E

BiThrTrNodeTemp = 0xcfd4c0, BiThrTrNodeTemp->Data = G, BiThrTrNodeTemp->LeftChild = 0xcfd5d8, BiThrTrNodeTemp->RightChild = 0xcf8dd8

CmpNode[Index].BiThrTreeData = G

PreOrderTraverseCompareBinaryThreadTree03 end

PreOrderTraverseCmpBiThrTreeNum = 7, NodeNum = 7

-------Test 03----------

BuildBinaryThreadTree start

InOrderThrBiTree

BiThrTrNodeTemp = 0xcfd680, BiThrTrNodeTemp->Data = B, BiThrTrNodeTemp->LeftChild = 0xcfd610, BiThrTrNodeTemp->RightChild = 0xcfd6f0

BiThrTrNodeTemp = 0xcfd6f0, BiThrTrNodeTemp->Data = D, BiThrTrNodeTemp->LeftChild = 0xcfd680, BiThrTrNodeTemp->RightChild = 0xcfd7d0

BiThrTrNodeTemp = 0xcfd7d0, BiThrTrNodeTemp->Data = A, BiThrTrNodeTemp->LeftChild = 0xcfd680, BiThrTrNodeTemp->RightChild = 0xcfd488

BiThrTrNodeTemp = 0xcfd488, BiThrTrNodeTemp->Data = C, BiThrTrNodeTemp->LeftChild = 0xcfd7d0, BiThrTrNodeTemp->RightChild = 0xcfd610

PrintThrTree end

BuildBinaryThreadTree end

Test PreOrderTraverseCmpPreOderBuildBiThrTree start

BiThrTrNodeTemp = 0xcfd680, BiThrTrNodeTemp->Data = B, BiThrTrNodeTemp->LeftChild = 0xcfd610, BiThrTrNodeTemp->RightChild = 0xcfd6f0

CmpNode[Index].BiThrTreeData = B

BiThrTrNodeTemp = 0xcfd6f0, BiThrTrNodeTemp->Data = D, BiThrTrNodeTemp->LeftChild = 0xcfd680, BiThrTrNodeTemp->RightChild = 0xcfd7d0

CmpNode[Index].BiThrTreeData = D

BiThrTrNodeTemp = 0xcfd7d0, BiThrTrNodeTemp->Data = A, BiThrTrNodeTemp->LeftChild = 0xcfd680, BiThrTrNodeTemp->RightChild = 0xcfd488

CmpNode[Index].BiThrTreeData = A

BiThrTrNodeTemp = 0xcfd488, BiThrTrNodeTemp->Data = C, BiThrTrNodeTemp->LeftChild = 0xcfd7d0, BiThrTrNodeTemp->RightChild = 0xcfd610

CmpNode[Index].BiThrTreeData = C

PreOrderTraverseCompareBinaryThreadTree03 end

PreOrderTraverseCmpBiThrTreeNum = 4, NodeNum = 4

-------Test result----------

Print test result;

TestNum = 3, PassNum = 3, FaildNum = 0

Meditatorss
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树线索化示意图_线索二叉树（C语言详解）
weixin_39892481的博客
12-28 1206
通过前面对二叉树的学习，了解到二叉树本身是一种非线性结构，采用任何一种遍历二叉树的方法，都可以得到树中所有结点的一个线性序列。在这个序列中，除第一个结点外，每个结点都有自己的直接前趋；除最后一个结点外，每个结点都有一个直接后继。图1 满二叉树例如，图 1 采用先序遍历的方法得到的结点序列为：1 2 4 5 3 6 7，在这个序列中，结点 2 的直接前趋结点为 1，直接后继结点为 4。什么...
C语言：二叉线索树
weixin_50711484的博客
09-08 405
二叉线索树就是利用n+1个空链域来存放结点的前驱和后继结点的信息。此篇文章将带大家学习怎样用中序遍历来创建一个二叉线索树！
二叉树的线索化算法——C语言
yu57955的博客
09-16 632
typedef struct ThreadNode { // 定义线索二叉树存储结构 ElemType data; // 数据域 struct ThreadNode *lchild, *rchild; // 左、右孩子指针 int ltag, rtag; // 左、右线索标志 }ThreadNode, *ThreadTree; /************************辅助栈**********
【数据结构】树（四）—— 线索二叉树（C语言版）
haoweixl的博客
09-15 934
【数据结构】树（四）—— 线索二叉树（C语言）前言导论为什么要加线索？线索二叉树的结构特点二叉树的存储结构二叉树的线索化如何在线索二叉树中找前驱与后继结点三种线索二叉树的比较（总结）图文详解中序线索二叉树的线索化完整代码 前言导论 由《树（二）—— 二叉树》一文的介绍中可知，二叉数本身是一种非线性结构，采用任何一种遍历二叉树的方法，都可以得到树中所有结点的一个线性序列。在这个序列中，除第一个结点外，每个结点都有自己的直接前趋；除最后一个结点外，每个结点都有一个直接后继。 传统的二叉链表存储仅能体现一种父子关
数据结构——二叉树 线索化二叉树 C语言
03-16
中序线索二叉树，反方向进行中序遍历(要求非递归，顺前驱进行)。 （1）建立二叉树； (2) 按先序、中序、后序输出二叉树; （3）复制二叉树； （4）在字符模式下画出无缺陷的二叉树
二叉树实验报告 C语言
12-29
**二叉树实验报告——C语言实现** 在本次实验中，我们将探讨如何使用C语言来创建和操作二叉树。二叉树是一种重要的数据结构，它由节点组成，每个节点最多有两个子节点，通常分为左子节点和右子节点。在计算机科学中...
严蔚敏《数据结构》源码 顺序表——二叉树
06-08
开发环境 VS2019 由于C语言中没有引用 （&），所以这里使用的是C++，极大程度还原了课本中的代码。 若有不足，请批评指正！！ 谢谢！！！ 目前写在了图，之后的内容会在github上持续...BiThrTree-------线索二叉树
数据结构课程设计-线索二叉树算法的实现.doc
05-26
### 数据结构课程设计——线索二叉树算法的实现 #### 一、课题描述与任务分析 **课题描述：** 本次课程设计的主要目标是通过编程实现二叉树的线索化过程，包括前序、中序和后序线索化，并能够对线索化后的二叉树...
[C语言]一、C语言基础
weixin_44428807的博客
08-25 331
Code::Block是一个免费的跨平台IDE，它支持C、C++和Fortan程序的开发。Code::Block的最大特点是它支持通过插件的方式对IDE自身功能进行扩展，这使得Code::Block具有很强的灵活性，方便用户使用。Visual C++ 2010，简称VC2010，是由微软开发的独立的、免费的 C/C++ 编译工具，与Visual Basic等并列，最后微软将它们整合在一起组成了Visual Studio。
数据库的读写分离技术MVCC
海鲨MYSQL精英架构师
08-21 792
因此MVCC应该说是多版本读写分离,当然也可以这样说 MVCC 是多版本读写分离提升读并发的协议
C-迷宫（牛客月赛99
m0_74310050的博客
08-24 264
分析：先从终点开始走，将沿路的障碍的横坐标和纵坐标都做上标记，再从起点开始走，如果下一个网格为障碍，判断该方向的坐标是否被做上标记，如果被标记，则可以在该方向上释放超能力。题意：在n×m的迷宫里，有空地和障碍，有一个超能力：当前位置朝任意方向上所有的障碍物都会清除，超能力最多使用一次，如果可以到终点输出yes。
C语言04--数组超详解
weixin_69902486的博客
08-20 570
数组在编程中广泛应用，能够帮助我们有效地存储和管理数据。无论是在处理一组相似的数据时，还是在实现复杂的算法时，数组都扮演着不可或缺的角色。
使用 C 语言实现字符走迷宫 DFS算法应用
最新发布
delepaste的博客
08-25 387
迷宫问题是一个经典的编程问题，通常用于算法训练。我们将通过使用 C 语言来实现一个字符迷宫的求解，其中玩家可以控制字符在迷宫中移动，直到找到出口。
c语言利用三目运算符制作订单判断免运费程序
2301_81968528的博客
08-21 168
这里要制作一个餐厅外卖订单超过15元免运费的程序，订单低于15加5元运费。printf("您的订单共计%d元，请支付\n",fee);printf("您的订单餐费是:");c语言三目运算符语法格式。
OD C卷 - 路口最短时间问题
weixin_45228198的博客
08-21 325
方向控制；BFS;
C语言 ——— 常见的动态内存错误（上篇）
weixin_55341642的博客
08-21 185
使用 malloc 函数动态开辟 sizeof(int)*INT_MAX 这么多个字节的空间，而 INT_MAX 是整型类型的最大值，那么肯定会开辟失败，开辟失败就会返回空指针（NULL）但是开辟失败后没有进行判断，直接对 ptr 指针解引用并且赋值为10，对空指针解引用的话，程序会直接报错，因为空指针没有任何指向的空间，解引用后系统也不知道该指向哪块空间，所以程序会报错这样就避免了直接对空指针解引用操作。
[嵌入式 C 语言] 知识库
庐陵居士
08-19 642
数据类型关键字分类打印格式其他打印格式char字符类型%c内存地址%pshort短整型%hd字符串%sint整型%d八进制数据%#olong长整型%ld十六进制数据%#xlong long长长整形%lld百分号%%float单精度浮点型%f左占位符%5ddouble双精度浮点型%lf右占位符%-5dunsigned long无符号长整型%lu取小数后几位%.5funsigned int无符号整型%usizeof关键字%lu或%ld
C语言实现的线索化二叉树及其遍历
本篇文章详细介绍了如何在C语言环境下实现线索化二叉树的数据结构和算法。线索化二叉树是一种特殊的二叉树存储结构，通过额外的信息（线索）来辅助遍历操作，使得在遍历时可以更方便地追踪前驱和后继节点，从而简化...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值