@@ -37,6 +37,7 @@ import leetcode_treenode_cpp.parseLeetCodeBinaryTree;
37
37
import insert_into_a_binary_search_tree.Solution;
38
38
import insert_into_a_binary_search_tree.HashTreeNode;
39
39
import insert_into_a_binary_search_tree.EqualTreeNode;
40
+ import insert_into_a_binary_search_tree.PostOrderTraversal;
40
41
using namespace insert_into_a_binary_search_tree ;
41
42
using namespace leetcode_treenode_cpp ;
42
43
using namespace std ;
@@ -67,19 +68,24 @@ void test1()
67
68
println (" insert-into-a-binary-search-tree" );
68
69
println (" test1 start" );
69
70
TreeNode* none = NULL ;
71
+ auto nodes = unordered_set<TreeNode*, HashTreeNode, EqualTreeNode> {};
70
72
73
+ PostOrderTraversal (none, [&](auto * node) {
74
+ nodes.emplace (node);
75
+ });
71
76
auto result2 = Solution ().insertIntoBST (none, 111 );
72
-
77
+ PostOrderTraversal (result2, [&](auto * node) {
78
+ nodes.emplace (node);
79
+ });
73
80
println (serializeTreeNode (none));
74
81
assertEquals (serializeTreeNode (none), " null" );
75
82
println (serializeTreeNode (result2));
76
83
assertEquals (serializeTreeNode (result2),
77
84
" TreeNode{val:111,left:null,right:null}" );
78
85
79
- auto nodes = unordered_set<TreeNode*, HashTreeNode, EqualTreeNode> { none, result2 };
80
86
for (auto node : nodes) {
81
87
printTreeNode (node);
82
- freeTreeNode (node);
88
+ delete (node);
83
89
}
84
90
println (" test1 end" );
85
91
}
@@ -88,20 +94,26 @@ void test2()
88
94
{
89
95
println (" test2 start" );
90
96
auto tree = new TreeNode (99 );
97
+ auto nodes = unordered_set<TreeNode*, HashTreeNode, EqualTreeNode> {};
98
+
99
+ PostOrderTraversal (tree, [&](auto * node) {
100
+ nodes.emplace (node);
101
+ });
91
102
println (serializeTreeNode (tree));
92
103
assertEquals (serializeTreeNode (tree),
93
104
" TreeNode{val:99,left:null,right:null}" );
94
105
auto result = Solution ().insertIntoBST (tree, 111 );
95
-
106
+ PostOrderTraversal (result, [&](auto * node) {
107
+ nodes.emplace (node);
108
+ });
96
109
println (serializeTreeNode (result));
97
110
assertEquals (serializeTreeNode (result),
98
111
" TreeNode{val:99,left:null,right:TreeNode{val:111,left:null,"
99
112
" right:null}}" );
100
113
101
- auto nodes = unordered_set<TreeNode*, HashTreeNode, EqualTreeNode> { tree, result };
102
114
for (auto node : nodes) {
103
115
printTreeNode (node);
104
- freeTreeNode (node);
116
+ delete (node);
105
117
}
106
118
println (" test2 end" );
107
119
}
@@ -134,17 +146,23 @@ class StringTest : public CppUnit::TestFixture {
134
146
TreeNode* root = nullptr ;
135
147
int status = parseLeetCodeBinaryTree (example.root , &root);
136
148
CPPUNIT_ASSERT_EQUAL (0 , status);
137
- auto output = Solution (). insertIntoBST (root, example. val ) ;
149
+ auto nodes = unordered_set<TreeNode*, HashTreeNode, EqualTreeNode> {} ;
138
150
151
+ PostOrderTraversal (root, [&](auto * node) {
152
+ nodes.emplace (node);
153
+ });
154
+ auto output = Solution ().insertIntoBST (root, example.val );
155
+ PostOrderTraversal (output, [&](auto * node) {
156
+ nodes.emplace (node);
157
+ });
139
158
CPPUNIT_ASSERT_EQUAL (LeetCodeTreeNodeToString (output),
140
159
example.output );
141
160
println (example.root );
142
161
println (example.val );
143
162
println (example.output );
144
- auto nodes = unordered_set<TreeNode*, HashTreeNode, EqualTreeNode> { root, output };
145
163
for (auto node : nodes) {
146
164
printTreeNode (node);
147
- freeTreeNode (node);
165
+ delete (node);
148
166
}
149
167
}
150
168
}
0 commit comments