二叉树节点的最大距离---ms

最新推荐文章于 2021-09-26 00:39:35 发布

jinnlxl

最新推荐文章于 2021-09-26 00:39:35 发布

阅读量518

点赞数

分类专栏： algorithms

本文链接：https://blog.csdn.net/yejing_utopia/article/details/43836237

版权

algorithms 专栏收录该内容

39 篇文章 1 订阅

订阅专栏

该代码实现了一个计算二叉树中任意两个节点的最大距离的算法，包括递归和非递归两种方法。通过创建二叉搜索树，然后遍历每个节点更新左右子树的最大距离，最终得到整个树的最大距离。

摘要由CSDN通过智能技术生成

/*************************************************************
 * file: max_distance_of_binary_tree.c
 * brief:求二叉树节点的最大距离的递归和非递归算法
 * yejing@2015.2.9    1.0      creat
 *************************************************************/
 
 #include <stdi.h>
 #include <stdlib.h>
 #include <string.h>
 #include <assert.h>
 
 typedef struct _tree_node_t{
	struct _tree_node_t* left;
	struct _tree_node_t* right;
	int left_distance;   //左子树的最大距离
	int right_distance;  //右子树的最大距离
	char value;          
	char res[3];         //对齐
 }tree_node_t, node_t;
 
 static int current_max_distance = 0;
 
 static void recursive_get_mdistance_bintree(tree_node_t* node){
	if(!node)
		return;
	int tmp;
		
	if(node->left){
		tmp = 0;
		if(node->left->left_distance > node->left->right_distance)
			tmp = node->left->left_distance;
		else
			tmp = node->left->right_distance;
		node->left_distance = ++tmp;
	}
	else node->left_distance = 0;
	
	if(node->right){
		tmp = 0;
		if(node->right->left_distance > node->right->right_distance)
			tmp = node->right->left_distance;
		else
			tmp = node->right->right_distance;
		node->right_distance = ++tmp;
	}
	else node->right_distance = 0;
	
	if(current_max_distance < node->right_distance + node->left_distance)
		current_max_distance = node->right_distance + node->left_distance;
		
	return;
 }
 
//暂时没有找到好办法
 static void loop_get_mdistance_bintree(tree_node_t* node){
	
 }
 
 
 static node_t* create_binary_search_tree_node(int value){
	node_t* root = (node_t*)malloc(sizeof(node_t));
	if(!root)
		assert(0);
	root->value = value;
	root->left  = NULL;
	root->right = NULL;
	
	return root;
}

static search_appriproate_position(node_t* root, int value){
	if(!root)
		assert(0);
	node_t* tmp = root;
	do{
		if(value < tmp->value){
			if(tmp->left)
				tmp = tmp->left;
			else
				return tmp;
		}
		else{
			if(tmp->right)
				tmp = tmp-right;
			else
				return tmp;
		}
	}while(1);
	return NULL;
}

static node_t* add_node_to_tree(node_t* root, int value){
	node_t* tmp = create_binary_search_tree_node(value);
	if(!tmp)
		return root;
		
	node_t* pos = search_appriproate_position(root, value);
	if(pos){
		if(value < pos->value)
			pos->left = tmp;
		else
			pos->right = tmp;
	}
	
	return root;
}
 
 int main(int argc, char* argv[]){
	node_t* root = create_binary_search_tree_node(8);
	if(!root)
		assert(0);
		
	add_node_to_tree(root, 6);
	add_node_to_tree(root, 10);
	add_node_to_tree(root, 5);
	add_node_to_tree(root, 7);
	add_node_to_tree(root, 9);
	add_node_to_tree(root, 11);
	
	recursive_get_mdistance_bintree();
	printf("current_max_distance:%d after recursive_get_mdistance_bintree\n", current_max_distance);
	
	current_max_distance = 0;
	loop_get_mdistance_bintree();
	printf("current_max_distance:%d after loop_get_mdistance_bintree\n", current_max_distance);
	
	return 1;
 }