【数据结构】二叉树的基本操作

二叉树的基本操作

BinTree.h

	#pragma once

	#include<stdio.h>
	#include<stddef.h>
	#include<assert.h>

	typedef char BinTreeType;

	typedef struct BinTreeNode {
		BinTreeType data;
		struct BinTreeNode* lchild;
		struct BinTreeNode* rchild;
	}BinTreeNode;

	/*初始化*/
	void BinTreeInit(BinTreeNode** root);

	/*创建一个二叉树结点*/
	BinTreeNode* CreateBinTreeNode(BinTreeType value);
	/*
	**前序遍历
	**递归和非递归实现
	*/
	void BinTreePreOrder1(BinTreeNode* root);
	void BinTreePreOrder2(BinTreeNode* root);

	/*
	**中序遍历
	**递归和非递归实现
	*/
	void BinTreeInOrder1(BinTreeNode* root);
	void BinTreeInOrder2(BinTreeNode* root);

	/*
	**后续遍历
	**递归和非递归实现
	*/
	void BinTreePostOrder1(BinTreeNode* root);
	void BinTreePostOrder2(BinTreeNode* root);

	/*层级遍历*/
	void BinTreeLevelOrder(BinTreeNode* root);

	/*给定一个树的前序遍历，求出树，带空结点标记*/

	BinTreeNode* GetBinTree_Pre(BinTreeType array[], size_t size, BinTreeType null_node);

	/*销毁树*/
	void BinTreeDestory(BinTreeNode** root);

	//复制树
	BinTreeNode* BinTreeClone(BinTreeNode* root, BinTreeNode* new_root);

	/*求树的结点的个数*/
	size_t BinTreeSize(BinTreeNode* root);

	/*求叶子结点的个数*/
	size_t BinTreeLeafSize(BinTreeNode* root);

	/*第k层的结点的个数*/
	size_t BinTreeKlevelSize(BinTreeNode* root, int k);

	/*树的高度*/
	size_t BinTreeHeight(BinTreeNode* root);

	/*在树中查找某个结点*/
	BinTreeNode* BinTreeFind(BinTreeNode* root, BinTreeType to_find);

	/*
	**查找左孩子结点，
	**查找右孩子结点，
	**查找双亲结点
	*/
	BinTreeNode* BinTreeLChild(BinTreeNode* node);
	BinTreeNode* BinTreerChild(BinTreeNode* node);
	BinTreeNode* BinTreeParent(BinTreeNode* root, BinTreeNode* node);

	/*把链表镜像反转*/
	void BinTreeMirror(BinTreeNode* root);

	/*判断当前链表是否是完全二叉树*/
	int IsCompleteTree(BinTreeNode* root);

	/*由前序遍历序列和中序遍历序列重建二叉树*/
	BinTreeNode* ReBulidBinTree(BinTreeType pre_array[], size_t pre_size, 
								BinTreeType in_array[], size_t in_size);

BinTree.c

#define _CRT_SECURE_NO_WARNINGS 1

#include"Bin_Tree.h"
#include"SeqStack.h"
#include"SeqQueue.h"

void BinTreeInit(BinTreeNode** root) {
	if (root == NULL) {
		return;
	}
	*root = NULL;
}

BinTreeNode* CreateBinTreeNode(BinTreeType value) {
	BinTreeNode* node = (BinTreeNode*)malloc(sizeof(BinTreeNode));

	if (node != NULL) {
		node->data = value;
		node->lchild = NULL;
		node->rchild = NULL;
	}
	return node;
}

/*
**前序遍历
**递归实现
*/
void BinTreePreOrder1(BinTreeNode* root) {
	if (root == NULL) {
		return;
	}
	printf("%c ", root->data);
	BinTreePreOrder1(root->lchild);
	BinTreePreOrder1(root->rchild);
}
/*非递归实现*/
void BinTreePreOrder2(BinTreeNode* root) {
	if (root == NULL) {
		return;
	}
	SeqStack seq;
	SeqStackInit(&seq);
	SeqStackPush(&seq, root);

	BinTreeNode* top = NULL;
	while (1) {
		/*判断栈是不是空，如果是表示树已经遍历完毕*/
		if (isEmpty(&seq)) {
			break;
		}
		/*取了个栈顶元素,然后出栈一个元素*/
		top = SeqStackTopValue(&seq);
		SeqStackPop(&seq);
		printf("%c ", top->data);

		if (top->rchild != NULL) {
			SeqStackPush(&seq, top->rchild);
		}
		if (top->lchild != NULL) {
			SeqStackPush(&seq, top->lchild);
		}
	}
	printf("\n");
}

/*
**中序遍历
*/
//递归
void BinTreeInOrder1(BinTreeNode* root) {
	if (root == NULL) {
		return;
	}
	BinTreeInOrder1(root->lchild);
	printf("%c ", root->data);
	BinTreeInOrder1(root->rchild);
}
//非递归
void BinTreeInOrder2(BinTreeNode* root) {
	if (root == NULL) {
		return;
	}
	SeqStack seq;
	SeqStackInit(&seq);

	while (NULL != root || !isEmpty(&seq)) {
		while (root) {
			SeqStackPush(&seq, root);
			root = root->lchild;
		}
		root = SeqStackTopValue(&seq);
		printf("%c ", root->data);
		SeqStackPop(&seq);

		/*如果当前结点右子树为空，就把root置为空再继续循环*/
		if (root->rchild == NULL) {
			root = NULL;
		}
		else {
			/*如果当前结点的右子树不为空，就访问root的右子树*/
			root = root->rchild;
		}
	}
	printf("\n");
}

/*
**后续遍历
**递归和非递归实现
*/
//递归实现
void BinTreePostOrder1(BinTreeNode* root) {
	if (root == NULL) {
		return;
	}
	BinTreePostOrder1(root->lchild);
	BinTreePostOrder1(root->rchild);

	printf("%c ", root->data);
}

//非递归实现
void BinTreePostOrder2(BinTreeNode* root) {
	if (root == NULL) {
		return;
	}
	SeqStack stack;
	SeqStackInit(&stack);
	
	BinTreeNode* prev = NULL;
	while (root != NULL || !isEmpty(&stack)) {
		/*直接让root走到当前树的最左边的叶节点*/
		while (root) {
			SeqStackPush(&stack, root);
			root = root->lchild;
		}

		/*root等于当前栈顶元素*/
		root = SeqStackTopValue(&stack);

		/*
		**如果当前结点的右孩子结点为空，或者，
		**已经出栈打印的上一个结点等于当前结点的右孩子结点
		*/
		if (root->rchild == NULL || prev == root->rchild) {
			/*prev表示最后打印的结点，即已经遍历完的最后一个结点*/
			prev = root;
			printf("%c ", root->data);
			SeqStackPop(&stack);
			root = NULL;
		}
		else {
			/*让