Returns the maximum distance between any two nodes in a binary tree and defines the distance between the two nodes.

Question: calculate the maximum distance between any two nodes in a binary tree. The distance between the two nodes is defined as the number of edges between the two nodes, for example, the distance between a child node and its parent node is 1, and the distance between the child node and the adjacent brother node is 2. This optimizes the time space clutter. Idea 1: There are two situations for calculating the maximum distance of A binary tree: Case A: the path goes through the left sub-tree

Question: calculate the maximum distance between any two nodes in a binary tree. The distance between the two nodes is defined as the number of edges between the two nodes, for example, the distance between a child node and its parent node is 1, and the distance between the child node and the adjacent brother node is 2. This optimizes the time space clutter. Idea 1: There are two situations for calculating the maximum distance of A binary tree: Case A: the path goes through the left sub-tree

Question:
Calculate the maximum distance between any two nodes in a binary tree. The distance between the two nodes is defined as the number of edges between the two nodes. For example, the distance between a child node and its parent node is 1, the distance between the two adjacent sibling nodes is 2,

Optimized Time Space clutter.

Thought 1:

There are two possible conditions for calculating the maximum distance of a binary tree:
Case A: the path goes through the deepest node of the Left subtree, and then to the deepest node of the right subtree through the root node.
Case B: the path does not pass through the root node, but is the maximum distance path of the Left or right subtree.
First, calculate the distance of the maximum path passing through the root node, which is actually the depth and distance of the left and right subtree, and then calculate the maximum distance between the left and right subtree, respectively, the maximum value is the maximum distance of the current binary tree.

The Code is as follows:

[Cpp]View plaincopyprint?

1. /*-----------------------------
2. Copyright by yuucyf. 2011.09.02
3. ------------------------------*/
4. # Include "stdafx. h"
5. # Include
6. # Include
7. Using namespace std;
9. Typedef struct tagSBTreeNode
10. {
11. TagSBTreeNode * psLeft;
12. TagSBTreeNode * psRight;
13. Int nValue;
15. Int nMaxLeft;
16. Int nMaxRight;
18. TagSBTreeNode ()
19. {
20. PsLeft = psRight = NULL;
21. NValue = 0;
22. NMaxLeft = nMaxRight = 0;
23. }
24. } S_TreeNode;
27. Void AddTreeNode (S_TreeNode * & psTreeNode, int nValue)
28. {
29. If (NULL = psTreeNode)
30. {
31. PsTreeNode = new S_TreeNode;
32. Assert (NULL! = PsTreeNode );
33. PsTreeNode-> nValue = nValue;
34. }
35. Else if (psTreeNode-> nValue <nValue)
36. {
37. AddTreeNode (psTreeNode-> psRight, nValue );
38. }
39. Else
40. AddTreeNode (psTreeNode-> psLeft, nValue );
41. }
43. Int MaxDepth (const S_TreeNode * psTreeNode)
44. {
45. Int nDepth = 0;
46. If (NULL! = PsTreeNode)
47. {
48. Int nLeftDepth = MaxDepth (psTreeNode-> psLeft );
49. Int nRightDepth = MaxDepth (psTreeNode-> psRight );
50. NDepth = (nLeftDepth> nRightDepth )? NLeftDepth: nRightDepth;
51. NDepth ++;
52. }
54. Return nDepth;
55. }
57. Int MaxDistance (const S_TreeNode * psRootNode)
58. {
59. Int nDistance = 0;
60. If (NULL! = PsRootNode)
61. {
62. NDistance = MaxDepth (psRootNode-> psLeft) + MaxDepth (psRootNode-> psRight );
63. Int nLeftDistance = MaxDistance (psRootNode-> psLeft );
64. Int nRightDistance = MaxDistance (psRootNode-> psRight );
66. NDistance = (nLeftDistance> nDistance )? NLeftDistance: nDistance;
67. NDistance = (nRightDistance> nDistance )? NRightDistance: nDistance;
68. }
70. Return nDistance;
71. }
76. Int _ tmain (int argc, _ TCHAR * argv [])
77. {
78. S_TreeNode * psRoot = NULL;
79. AddTreeNode (psRoot, 9 );
80. AddTreeNode (psRoot, 6 );
81. AddTreeNode (psRoot, 4 );
82. AddTreeNode (psRoot, 8 );
83. AddTreeNode (psRoot, 7 );
84. AddTreeNode (psRoot, 15 );
85. AddTreeNode (psRoot, 13 );
86. AddTreeNode (psRoot, 16 );
87. AddTreeNode (psRoot, 18 );
89. Cout <"the maximum distance between any two nodes is:" <MaxDistance (psRoot) <endl;
91. Return 0;
92. }

/* ----------------------------- Copyright by yuucyf. 2011.09.02 -------------------------------- */# include "stdafx. h" # include
 
  
# Include using namespace std; typedef struct tagSBTreeNode {tagSBTreeNode * psLeft; tagSBTreeNode * psRight; intnValue; int nMaxLeft; int nMaxRight; weight () {psLeft = psRight = NULL; nValue = 0; nMaxLeft = nMaxRight = 0 ;}s_treenode; void AddTreeNode (S_TreeNode * & psTreeNode, int nValue) {if (NULL = psTreeNode) {psTreeNode = new S_TreeNode; assert (NULL! = PsTreeNode); psTreeNode-> nValue = nValue;} else if (psTreeNode-> nValue <nValue) {AddTreeNode (psTreeNode-> psRight, nValue );} elseAddTreeNode (psTreeNode-> psLeft, nValue);} int MaxDepth (const S_TreeNode * psTreeNode) {int nDepth = 0; if (NULL! = PsTreeNode) {int nLeftDepth = MaxDepth (psTreeNode-> psLeft); int nRightDepth = MaxDepth (psTreeNode-> psRight); nDepth = (nLeftDepth> nRightDepth )? NLeftDepth: nRightDepth; nDepth ++;} return nDepth;} int MaxDistance (const S_TreeNode * psRootNode) {int nDistance = 0; if (NULL! = PsRootNode) {nDistance = MaxDepth (psRootNode-> psLeft) + MaxDepth (psRootNode-> psRight); int nLeftDistance = MaxDistance (psRootNode-> psLeft ); int nRightDistance = MaxDistance (psRootNode-> psRight); nDistance = (nLeftDistance> nDistance )? NLeftDistance: nDistance; nDistance = (nRightDistance> nDistance )? NRightDistance: nDistance;} return nDistance;} int _ tmain (int argc, _ TCHAR * argv []) {S_TreeNode * psRoot = NULL; AddTreeNode (psRoot, 9 ); addTreeNode (psRoot, 6); AddTreeNode (psRoot, 4); AddTreeNode (psRoot, 8); AddTreeNode (psRoot, 7); AddTreeNode (psRoot, 15); AddTreeNode (psRoot, 13); AddTreeNode (psRoot, 16); AddTreeNode (psRoot, 18); cout <"the maximum distance between any two nodes is:" <MaxDistance (psRoot) <endl; return 0 ;}
 

Thought 2:

Idea 1 is not the most efficient, because there are repeated computations when calculating the depth of Binary Trees. However, it should be readable, without changing the structure of the original binary tree and using additional global variables. The code is provided here, because the comments of the Code have been written in great detail.

The Code is as follows:

[Cpp]View plaincopyprint?

1. Int g_nMaxLeft = 0;
2. Void MaxDistance_2 (S_TreeNode * psRoot)
3. {
4. // Traverse to the leaf node and return
5. If (NULL = psRoot)
6. Return;
8. // If the left subtree is empty, the maximum left distance of the node is 0.
9. If (psRoot-> psLeft = NULL)
10. {
11. PsRoot-> nMaxLeft = 0;
12. }
14. // If the right subtree is empty, the maximum distance to the right of the node is 0.
15. If (psRoot-> psRight = NULL)
16. {
17. PsRoot-> nMaxRight = 0;
18. }
20. // If the left subtree is not empty, Recursively search for the longest distance of the Left subtree
21. If (psRoot-> psLeft! = NULL)
22. {
23. MaxDistance_2 (psRoot-> psLeft );
24. }
26. // If the right subtree is not empty, Recursively search for the longest distance of the right subtree
27. If (psRoot-> psRight! = NULL)
28. {
29. MaxDistance_2 (psRoot-> psRight );
30. }
32. // Calculate the longest node distance of the Left subtree
33. If (psRoot-> psLeft! = NULL)
34. {
35. Int nTempMax = 0;
36. If (psRoot-> psLeft-> nMaxLeft> psRoot-> psLeft-> nMaxRight)
37. {
38. NTempMax = psRoot-> psLeft-> nMaxLeft;
39. }
40. Else
41. {
42. NTempMax = psRoot-> psLeft-> nMaxRight;
43. }
44. PsRoot-> nMaxLeft = nTempMax + 1;
45. }
47. // Calculate the longest node distance of the right subtree
48. If (psRoot-> psRight! = NULL)
49. {
50. Int nTempMax = 0;
51. If (psRoot-> psRight-> nMaxLeft> psRoot-> psRight-> nMaxRight)
52. {
53. NTempMax = psRoot-> psRight-> nMaxLeft;
54. }
55. Else
56. {
57. NTempMax = psRoot-> psRight-> nMaxRight;
58. }
59. PsRoot-> nMaxRight = nTempMax + 1;
60. }
62. // Update the longest distance
63. If (psRoot-> nMaxLeft + psRoot-> nMaxRight> g_nMaxLeft)
64. {
65. G_nMaxLeft = psRoot-> nMaxLeft + psRoot-> nMaxRight;
66. }
67. }

Int g_nMaxLeft = 0; void MaxDistance_2 (S_TreeNode * psRoot) {// traverse to the leaf node and return if (NULL = psRoot) return; // if the left subtree is empty, the longest left distance of the node is 0if (psRoot-> psLeft = NULL) {psRoot-> nMaxLeft = 0;} // if the right subtree is empty, the maximum distance to the right of the node is 0if (psRoot-> psRight = NULL) {psRoot-> nMaxRight = 0;} // If the left subtree is not empty, recursively search for the longest left subtree if (psRoot-> psLeft! = NULL) {MaxDistance_2 (psRoot-> psLeft);} // if the right subtree is not empty, Recursively search for the longest distance of the right subtree if (psRoot-> psRight! = NULL) {MaxDistance_2 (psRoot-> psRight);} // calculates the longest node distance from the left subtree to if (psRoot-> psLeft! = NULL) {int nTempMax = 0; if (psRoot-> psLeft-> nMaxLeft> psRoot-> psLeft-> nMaxRight) {nTempMax = psRoot-> psLeft-> nMaxLeft ;} else {nTempMax = psRoot-> psLeft-> nMaxRight;} psRoot-> nMaxLeft = nTempMax + 1;} // calculates the longest node distance from the right subtree if (psRoot-> psRight! = NULL) {int nTempMax = 0; if (psRoot-> psRight-> nMaxLeft> psRoot-> psRight-> nMaxRight) {nTempMax = psRoot-> psRight-> nMaxLeft ;} else {nTempMax = psRoot-> psRight-> nMaxRight;} psRoot-> nMaxRight = nTempMax + 1 ;} // update the longest-distance if (psRoot-> nMaxLeft + psRoot-> nMaxRight> g_nMaxLeft) {g_nMaxLeft = psRoot-> nMaxLeft + psRoot-> nMaxRight ;}}