java 树最大距离_[C语言]求二叉树节点最大距离(C、JAVA 递归、非递归)

求二叉树节点最大距离

注：C语言的两种实现代码参考了前辈的文章， JAVA为原创，4段代码均运行通过

C语言 递归实现

#include

#include

//求二叉树节点最大距离

//C语言 递归实现

typedef struct node{

struct node *left;

struct node *right;

int maxLeft;

int maxRight;

}treeNode;

int maxLength = 0;

treeNode* getNewNode(){

treeNode *temp;

temp= (treeNode*)malloc(sizeof(treeNode));

temp->maxLeft = 0;

temp->maxRight = 0;

temp->left = NULL;

temp->right = NULL;

return temp;

}

void findMaxLength(treeNode *root){

if(root == NULL)

return;

//如果左子树不为空，递归寻找左边最长距离

if(root->left != NULL)

findMaxLength(root->left);

//如果右子树不为空，递归寻找右边最长距离

if(root->right != NULL)

findMaxLength(root->right);

//计算左子树最长节点距离

if(root->left != NULL){

if(root->left->maxLeft > root->left->maxRight)

root->maxLeft = root->left->maxLeft + 1;

else

root->maxLeft = root->left->maxRight + 1;

}

//计算右子树最长节点距离

if(root->right != NULL){

if(root->right->maxLeft > root->right->maxRight)

root->maxRight = root->right->maxLeft + 1;

else

root->maxRight =root->right->maxRight + 1;

}

//更新最长距离

if(root->maxLeft + root->maxRight > maxLength)

maxLength = root->maxLeft + root->maxRight;

}

treeNode* buildTree(){

treeNode *root;

treeNode *temp;

root = getNewNode();

temp= getNewNode();

root->left = temp;

temp= getNewNode();

root->right = temp;

temp= getNewNode();

root->left->left = temp;

temp= getNewNode();

root->right->right = temp;

return root;

}

void main(){

treeNode *root;

root = buildTree();

findMaxLength(root);

printf("%d \n",maxLength);

}

C语言 非递归实现

#include

#include

#include

using namespace std;

//求二叉树节点最大距离

//C语言 非递归实现

struct Node

{

bool _visited;

Node* left;

Node* right;

int maxLeft;

int maxRight;

Node()

{

_visited = false;

maxLeft = 0;

maxRight = 0;

left = NULL;

right = NULL;

}

};

int maxLen = 0;

stack nodeStack;

int getMax(int a, int b){

if(a>b) return a;

return b;

}

void findMaxLen(Node* root){

if(!root) return;

Node* node;

nodeStack.push(root);

while(!nodeStack.empty()){

node = nodeStack.top();

if(node->left == NULL && node->right ==NULL){

node->_visited = true;

nodeStack.pop();

continue;

}

if(node->left){

if(!node->left->_visited)

nodeStack.push(node->left);

else

node->maxLeft = getMax(node->left->maxLeft,node->left->maxRight) + 1;

}

if((!node->left || node->left->_visited) && node->right){

if(!node->right->_visited)

nodeStack.push(node->right);

else

node->maxRight = getMax(node->right->maxLeft,node->right->maxRight) + 1;

}

if((!node->left || node->left->_visited) && (!node->right || node->right->_visited)){

maxLen = getMax(maxLen,node->maxLeft + node->maxRight);

node->_visited = true;

nodeStack.pop();

}

}

}

void main()

{

Node *tmp ;

Node* root = new Node();

tmp = new Node();

root->left = tmp ;

tmp = new Node();

root->right = tmp;

tmp = new Node();

root->right->right = tmp;

tmp = new Node();

root->left->left = tmp;

tmp = new Node();

root->right->right->left = tmp;

findMaxLen(root);

cout << maxLen << endl;

}

Java 递归实现

package dataStruct;

/**

* 求二叉树节点最大距离

* 递归实现

* @author YangYi

*/

public class TreeMaxLenthBetweenNodes2 {

public static int maxLen = 0;

public static void main(String args[]) {

TreeNode root = buildTree();

getMaxLength(root);

System.out.println(maxLen);

}

public static void getMaxLength(TreeNode root) {

if (root == null)

return;

if (root.left != null) {

getMaxLength(root.left);

root.maxLeft = Math.max(root.left.maxLeft, root.left.maxRight) + 1;

}

if (root.right != null) {

getMaxLength(root.right);

root.maxRight = Math.max(root.right.maxLeft, root.right.maxRight) + 1;

}

maxLen = Math.max(maxLen, root.maxLeft + root.maxRight);

}

public static TreeNode buildTree() {

TreeNode root = new TreeNode();

TreeNode temp = new TreeNode();

root.left = temp;

temp = new TreeNode();

root.right = temp;

temp = new TreeNode();

root.right.right = temp;

temp = new TreeNode();

root.left.right = temp;

temp = new TreeNode();

root.left.right.right = temp;

return root;

}

}

class TreeNode {

int maxLeft = 0;

int maxRight = 0;

TreeNode left = null;

TreeNode right = null;

}

Java 非递归实现

package dataStruct;

import java.util.Stack;

/**

* 求二叉树节点最大距离

* 递归实现

* @author YangYi

*/

public class TreeMaxLengthBetweenNodes {

private static int maxLen = 0;

private static Stack stack = new Stack();

public static void main(String args[]) {

Node root = buildTree();

getMaxLen(root);

System.out.println(maxLen);

}

public static int getMaxLen(Node root) {

if (root == null)

return 0;

stack.push(root);

while (!stack.isEmpty()) {

Node node = stack.peek();

if (node.left == null && node.right == null) {

node.visited = true;

stack.pop();

continue;

}

if (node.left != null) {

if (!node.left.visited) {

stack.push(node.left);

} else {

node.maxLeft = Math.max(node.left.maxLeft,

node.left.maxRight) + 1;

}

}

if ((node.left == null || node.left.visited) && node.right != null) {

if (!node.right.visited) {

stack.push(node.right);

} else {

node.maxRight = Math.max(node.right.maxLeft,

node.right.maxRight) + 1;

}

}

if ((node.left == null || node.left.visited)

&& (node.right == null || node.right.visited)) {

maxLen = Math.max(maxLen, node.maxLeft + node.maxRight);

node.visited = true;

stack.pop();

}

}

return maxLen;

}

public static Node buildTree() {

Node root = new Node();

Node temp = new Node();

root.left = temp;

temp = new Node();

root.right = temp;

temp = new Node();

root.right.right = temp;

temp = new Node();

root.left.right = temp;

temp = new Node();

root.left.right.right = temp;

return root;

}

}

class Node {

boolean visited = false;

int maxLeft = 0;

int maxRight = 0;

Node left = null;

Node right = null;

}