【数据结构】线索化二叉树（前序中序后序）

ThreadTree.h

#pragma once

#include<stdio.h>

typedef enum Flag{
	Is_Chlid,
	Is_Thread,
}Flag;

typedef  char ThreadType;

typedef struct ThreadNode{
	ThreadType data;
	struct ThreadNode* left;
	struct ThreadNode* right;
	/*这个两个flag分别表示上面两个指针的状态*/
	Flag lflag;
	Flag rflag;
}ThreadNode;

/*创建一个树*/
ThreadNode* ThreadTreeCreate(ThreadType arr[], size_t size, ThreadType invalid);

/*把树线索化*/
/*前序线索化*/
void Pre_Threading(ThreadNode* root);
/*中序线索化*/
void In_Threading(ThreadNode* root);
/*后序线索化*/
void Post_Threading(ThreadNode* root);

/*线索化后遍历*/
/*前序*/
void PreOrderByThreading(ThreadNode* root); 
/*中序*/
void InOrderByThreading(ThreadNode* root);

ThreadTree.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"ThreadTree.h"
#include"SeqStack.h"
#include<stdio.h>
#include<assert.h>

/*创建一个结点*/
ThreadNode* CreateThreadNode(ThreadType value) {
	ThreadNode* new_node = (ThreadNode*)malloc(sizeof(ThreadNode));

	if (new_node != NULL) {
		new_node->data = value;
		new_node->left = NULL;
		new_node->right = NULL;

		new_node->lflag = Is_Chlid;
		new_node->rflag = Is_Chlid;
	}
	return new_node;
}

/*创建一个树*/
ThreadNode* _ThreadTreeCreate(ThreadType pre_arr[], size_t size, int* index, ThreadType invalid) {
	if (*index >= size) {
		/*表示前序数组已经找完了*/
		return NULL;
	}
	/*判断当前结点是不是空字符*/
if (pre_arr[*index] == invalid) {
		return NULL;
	}
	/*创建一个结点*/
	ThreadNode* root = CreateThreadNode(pre_arr[*index]);
	if (root != NULL) {
		++(*index);
		root->left = _ThreadTreeCreate(pre_arr, size, index, invalid);
		++(*index);
		root->right = _ThreadTreeCreate(pre_arr, size, index, invalid);

		return root;
	}
}

ThreadNode* ThreadTreeCreate(ThreadType pre_arr[], size_t size, ThreadType invalid) {
	assert(pre_arr);
	int index = 0;
	return _ThreadTreeCreate(pre_arr, size, &index, invalid);
}

/*把树线索化*/

/*前序*/
ThreadNode* _Pre_Threading(ThreadNode* root, ThreadNode** prev) {
	if (root == NULL || prev == NULL) {
		return NULL;
	}
	if (root->left == NULL) {
		root->left = *prev;  //相当于前驱结点
		root->lflag = Is_Thread;
	}
	if ((*prev)!= NULL && (*prev)->right == NULL) {
		/*如果前序遍历的前一个结点的右结点等于空，则把它的右结点指向当前结点,后继结点*/
		(*prev)->right = root;
		(*prev)->rflag = Is_Thread;
	}
	*prev = root;

	if (root->lflag != Is_Thread) {
		root->left = _Pre_Threading(root->left, prev);
	}
	if (root->rflag != Is_Thread) {
		root->right = _Pre_Threading(root->right, prev);
	}
	return root;
}
/*先序线索化*/
void Pre_Threading(ThreadNode* root) {
	if (root == NULL) {
		return;
	}
	ThreadNode* prev = NULL;
	_Pre_Threading(root, &prev);
}

/*前序遍历线索化的二叉树*/
void PreOrderByThreading(ThreadNode* root) {
	if (root == NULL) {
		return;
	}
	while (root != NULL) {
		while (root->left != NULL && root->lflag != Is_Thread) {
			printf("%c ", root->data);
			root = root->left;
		}
		printf("%c ", root->data);
		/*一直打印到最左边的结点了*/
		root = root->right;
	}
}

/*中序线索化*/

ThreadNode* _In_Theading(ThreadNode* root, ThreadNode** prev) {
	if (root == NULL || prev == NULL) {
		return NULL;
	}

	if (root->lflag != Is_Thread) {
		root->left = _In_Theading(root->left, prev);
	}

	if (root->left == NULL) {
		root->left = (*prev);
		root->lflag = Is_Thread;
	}
	if ((*prev) != NULL && (*prev)->right == NULL) {
		(*prev)->right = root;
		(*prev)->rflag = Is_Thread;
	}
	*prev = root;

	if (root->rflag != Is_Thread) {
		root->right = _In_Theading(root->right, prev);
	}
	return root;
}

void In_Threading(ThreadNode* root) {
	ThreadNode* prev = NULL;

	_In_Theading(root, &prev);
}

/*后序线索化*/

ThreadNode* _Pos_Threading(ThreadNode* root, ThreadNode** prev) {
	if (root == NULL || prev == NULL) {
		return NULL;
	}
	if (root->lflag != Is_Thread) {
		root->left = _Pos_Threading(root->left, prev);
	}
	if (root->rflag != Is_Thread) {
		root->right = _Pos_Threading(root->right, prev);
	}

	if (root->left == NULL) {
		root->left = (*prev);
		root->lflag = Is_Thread;
	}
	if ((*prev) != NULL && (*prev)->right == NULL) {
		(*prev)->right = root;
		(*prev)->rflag = Is_Thread;
	}
	*prev = root;
	return root;
}

void Post_Threading(ThreadNode* root) {
	ThreadNode* prev = NULL;
	_Pos_Threading(root, &prev);
}

/*中序遍历*/
void InOrderByThreading(ThreadNode* root) {
	if (root == NULL) {
		return;
	}
	while (root != NULL) {

		while (root->lflag == Is_Chlid) {
			root = root->left;
		}
		/*root现在到了这棵树的最左边的那个结点*/
		printf("%c ", root->data);

		/*然后开始找中序后继节点*/
		while (root && root->rflag == Is_Thread) {
			root = root->right;
			printf("%c ", root->data);
		}
		/*如果没有当前节点没有后继结点了，那么它一定有右子树*/
		root = root->right;
	}
}

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"ThreadTree.h"
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#define TESTHEAD printf("------------%s----------\n",__FUNCTION__)

void TestCreateThreadTree() {
	TESTHEAD;
	ThreadType pre_arr[] = "ABD##EG###C#F#";
	int sz = strlen(pre_arr);
	ThreadNode* root = NULL;
	root = ThreadTreeCreate(pre_arr, sz, '#');
}

void TestPrevThreading() {
	TESTHEAD;
	ThreadType pre_arr[] = "ABD##EG###C#F#";
	int sz = strlen(pre_arr);
	ThreadNode* root = NULL;
	root = ThreadTreeCreate(pre_arr, sz, '#');

	Pre_Threading(root);
}
/*线索二叉树的前序遍历*/
void TestPreOrderByThreading() {
	TESTHEAD;
	ThreadType pre_arr[] = "ABD###CE##F##";
	int sz = strlen(pre_arr);
	ThreadNode* root = NULL;
	root = ThreadTreeCreate(pre_arr, sz, '#');
	Pre_Threading(root);

	PreOrderByThreading(root);
	printf("\n");
	PrevOrderByLoop(root);
}

void TestInThreading() {
	TESTHEAD;
	ThreadType pre_arr[] = "ABD###CE##F##";
	int sz = strlen(pre_arr);
	ThreadNode* root = NULL;
	root = ThreadTreeCreate(pre_arr, sz, '#');
	In_Threading(root);
}

void TestPosThreading() {
	TESTHEAD;
	ThreadType pre_arr[] = "ABD###CE##F##";
	int sz = strlen(pre_arr);
	ThreadNode* root = NULL;
	root = ThreadTreeCreate(pre_arr, sz, '#');
	Post_Threading(root);
}

/*线索二叉树的中序遍历*/
void TestInOrderByThreading() {
	TESTHEAD;
	ThreadType pre_arr[] = "ABD###CE##F##";
	int sz = strlen(pre_arr);
	ThreadNode* root = NULL;
	root = ThreadTreeCreate(pre_arr, sz, '#');
	In_Threading(root);
	
	InOrderByThreading(root);
	printf("\n");
}

int main() {
	TestCreateThreadTree();
	TestPrevThreading();
	TestPreOrderByThreading();
	TestInThreading();
	TestInOrderByThreading();
	TestPosThreading();
	system("pause");
	return 0;
}