二叉树（有几题面试题包含在代码中）

二叉树：
是一种常用的数据结构。
定义：二叉树是n个有限元素的集合，由一个根和左子树以及右子树组成，是有序树。当集合为空时，又称为空二叉树。
二叉树的性质：
性质1：二叉树的第i层上最多有2^(i-1)个节点。
每层的节点数都是2^(i-1)，这种树叫满二叉树。
对树中的结点按从上至下、从左到右的顺序进行编号，如果编号为i（1≤i≤n）的结点与满二叉树中编号为i的结点在二叉树中的位置相同，则这棵二叉树称为完全二叉树。
性质2：深度为h的二叉树中至多含有2^h-1个节点。
性质3：若在任意一棵二叉树中，有n0个叶子节点，有n2个度为2的节点，则必有n0=n2+1。
性质4：具有n个节点的完全二叉树深为log2^n+1。
性质5：若对一棵有n个节点的完全二叉树进行顺序编号（1≤i≤n），那么，对于编号为i（i≥1）的节点：
当i=1时，该节点为根，它无双亲节点。
当i>1时，该节点的双亲节点的编号为i/2(顺序存储)。
如果2i<=n，则编号为2i 则有编号为i的左孩子。
如果2i+1<=n，则编号为 2i+1 为编号为i的右孩子。
二叉树的操作：
构建、销毁、遍历、高度、密度、插入、删除、查询、求左、求右、求根
二叉树的存储：
顺序：必须按照完全二叉树的格式存储，空位置使用特殊数据代替。
数据项：
存储节点的内存
容量
链式：由一个个节点组成，每一个节点就是一棵树。
节点数据项：
数据

二叉树的遍历：
前序：根、左、右
中序：左、根、右
后序：左、右、根
注意：前中后由根节点决定，不存在左、左根的后序，左、右子的次序不变。
注意：根据 前序+中序 或者 中序+后序 还原一棵树，前序+后序无法还原（无法判断出根节点的左右子树）。

关于二叉树的代码：

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include "list_stack.h"

typedef struct TreeNode	//创建二叉树
{
	int data;
	struct TreeNode* left;
	struct TreeNode* right;
}TreeNode;

TreeNode* create_tree_node(int data)//创建节点
{
	TreeNode* node = malloc(sizeof(TreeNode));
	node->data = data;
	node->left = NULL;
	node->right = NULL;
	return node;
}
void _insert_tree(TreeNode** root,TreeNode* node)
{
	if(NULL == *root)
	{
		*root = node;
		return;
	}

	if(node->data < (*root)->data)
		_insert_tree(&(*root)->left,node);
	else
		_insert_tree(&(*root)->right,node);

}

void insert_tree(TreeNode** root,int data)//插入
{
	_insert_tree(root,create_tree_node(data));
}

// 前序
void dlr_show(TreeNode* root)
{
	if(NULL == root) return;
	printf("%d ",root->data);
	dlr_show(root->left);
	dlr_show(root->right);
}

// 中序
void ldr_show(TreeNode* root)
{
	if(NULL == root) return;
	ldr_show(root->left);
	printf("%d ",root->data);
	ldr_show(root->right);
}

// 后序
void lrd_show(TreeNode* root)
{
	if(NULL == root) return;
	lrd_show(root->left);
	lrd_show(root->right);
	printf("%d ",root->data);
}

// 查找
bool query_tree(TreeNode* root,int data)
{
	if(NULL == root) return false;
	if(data == root->data) return true;

	if(data < root->data)
		return query_tree(root->left,data);
	else
		return query_tree(root->right,data);

}

// 密度
int density_tree(TreeNode* root)
{
	if(NULL == root) return 0;
	return density_tree(root->left)+density_tree(root->right)+1;
}

// 销毁
void destory_tree(TreeNode* root)
{
	if(NULL == root) return;
	destory_tree(root->left);
	destory_tree(root->right);
	free(root);
}

bool _access_tree(TreeNode* root,int* k,size_t index,int* ptr)
{
	if(NULL == root) return false;
	bool rflag = _access_tree(root->right,k,index,ptr);
	if((*k)++ == index)
	{
		*ptr = root->data;
		return true;
	}
	bool lflag = _access_tree(root->left,k,index,ptr);
	return lflag || rflag;
}

// 访问
bool access_tree(TreeNode* root,size_t index,int* ptr)
{
	int k = 0;
	return _access_tree(root,&k,index,ptr);
}

// 删除
bool del_tree(TreeNode** root,int data)
{
	if(NULL == *root) return false;
	if((*root)->data == data)
	{
		TreeNode* temp = *root;
		*root = temp->left;
		_insert_tree(root,temp->right);
		free(temp);
		return true;
	}

	if(data < (*root)->data)
		return del_tree(&(*root)->left,data);
	else
		return del_tree(&(*root)->right,data);

}

int _high_tree(TreeNode* root,bool* flag)
{
	if(NULL == root) return 0;
	int lh = _high_tree(root->left,flag);
	int rh = _high_tree(root->right,flag);
	if(flag && abs(lh-rh)>1) *flag = false;
	return lh>rh?lh+1:rh;
}

// 高度
int high_tree(TreeNode* root)
{
	return _high_tree(root,NULL);
}


// 判断是否平衡
int isAVL_tree(TreeNode* root)
{
	bool flag = true;
	_high_tree(root,&flag);
	return flag;
}

bool treecmp(TreeNode* r1,TreeNode* r2)
{
	if(NULL == r1 && NULL == r2) return true;
	if(NULL == r1 && NULL != r2) return false;
	if(NULL != r1 && NULL == r2) return true;

	if(r1->data != r2->data) return false;
	return treecmp(r1->left,r2->left) && treecmp(r1->right,r2->right);

}

bool is_subtree(TreeNode* root,TreeNode* node)//判断是否是子节点
{
	if(NULL == root) return false;

	if(root->data == node->data)
		return treecmp(root,node);
	bool lflag = is_subtree(root->left,node);
	bool rflag = is_subtree(root->right,node);
	return lflag || rflag;

}

void _add_tail_list(TreeNode** head,TreeNode* node)
{
	printf("%d\n",node->data);
	if(NULL == *head)
	{
		*head = node;
	}
	else
	{
		(*head)->left->right = node;
		node->left = (*head)->left;
	}
	(*head)->left = node;
}

void _tree_to_list(TreeNode* root,TreeNode** head)
{
	if(NULL == root) return;
	_tree_to_list(root->left,head);
	_add_tail_list(head,root);
	_tree_to_list(root->right,head);
}

TreeNode* tree_to_list(TreeNode* root)
{
	TreeNode* head = NULL;
	_tree_to_list(root,&head);
	return head;
}

void z_show(TreeNode* root)//二叉树Z序打印
{
	ListStack* s1 = create_list_stack();
	ListStack* s2 = create_list_stack();
	push_list_stack(s1,root);

	while(!empty_list_stack(s1) || !empty_list_stack(s2))
	{
		while(!empty_list_stack(s1))
		{
			TreeNode* node = top_list_stack(s1);
			pop_list_stack(s1);
			printf("%d ",node->data);
			if(node->left) push_list_stack(s2,node->left);
			if(node->right) push_list_stack(s2,node->right);
		}
		printf("\n============\n");
		while(!empty_list_stack(s2))
		{
			TreeNode* node = top_list_stack(s2);
			pop_list_stack(s2);
			printf("%d ",node->data);
			if(node->right) push_list_stack(s1,node->right);
			if(node->left) push_list_stack(s1,node->left);
		}
		printf("\n============\n");
	}

}

int main(int argc,const char* argv[])
{
	TreeNode* root = NULL;
	for(int i=0; i<10; i++)
	{
		int data = rand() % 100;
		printf("%d ",data);
		insert_tree(&root,data);
	}
	printf("\n");
	z_show(root);

	/*dd
	int num = 0;
	access_tree(root,3,&num) && printf("倒数k个数：%d\n",num);
	del_tree(&root,100);
	int num = 0;
	access_tree(root,6,&num) && printf("access:%d\n",num);
	printf("%d\n",high_tree(root));
	printf("%d\n",density_tree(root));
	printf("%s\n",isAVL_tree(root)?"平衡":"不平衡");
	ldr_show(root); puts("");
	density_tree(root);
	root = NULL;
	*/

}