searchBST

- rewrite print_tree and deserialize with inorder traversal
- rename compare_tree with is_same_tree
- add some testcases

Author: Pokerpoke

include/btree.cc

@@ -8,7 +8,7 @@
  * @brief    
  * @version  0.0.1
  * 
- * Last Modified:  2019-07-29
+ * Last Modified:  2019-07-30
  * Modified By:    Jiang Yang ([email protected])
  * 
  */
@@ -20,33 +20,50 @@ void print_tree(TreeNode *root)
 {
     using std::cout;
     using std::endl;
-    if (root != nullptr)
+    using std::queue;
+
+    if (root == nullptr)
+    {
+        cout << "NULL" << endl;
+        return;
+    }
+    queue<TreeNode *> root_ptrs;
+
+    root_ptrs.push(root);
+
+    while (!root_ptrs.empty())
     {
-        cout << root->val << " ";
-        print_tree(root->left);
-        print_tree(root->right);
+        TreeNode *temp = root_ptrs.front();
+        if (temp == nullptr)
+            cout << "NULL ";
+        else
+            cout << temp->val << " ";
+        if (temp->left != nullptr)
+            root_ptrs.push(temp->left);
+        if (temp->right != nullptr)
+            root_ptrs.push(temp->right);
+        root_ptrs.pop();
     }
-    else
-        cout << "NULL ";
+    cout << endl;
 }
 
-bool compare_tree(TreeNode *root1, TreeNode *root2)
+bool is_same_tree(TreeNode *root1, TreeNode *root2)
 {
     if (root1 == nullptr && root2 == nullptr)
         return true;
     else if (root1 == nullptr || root2 == nullptr)
         return false;
     else if (root1->val == root2->val)
-        return (compare_tree(root1->left, root2->left) &&
-                compare_tree(root1->right, root2->right));
+        return (is_same_tree(root1->left, root2->left) &&
+                is_same_tree(root1->right, root2->right));
     return false;
 }
 
 Tree::Tree(std::initializer_list<int> il) : q(il)
 {
     if (q.empty())
         return;
-    this->root = deserialize(q);
+    root = deserialize(q);
 }
 
 void delete_root_helper(TreeNode *root)
@@ -71,30 +88,66 @@ Tree::~Tree()
 
 TreeNode *Tree::deserialize(std::queue<int> &in)
 {
-    if (in.empty())
+    using std::queue;
+
+    queue<TreeNode *> root_ptrs;
+    if (in.empty() || in.front() == NULL)
         return nullptr;
-    if (in.front() == NULL)
+    TreeNode *temp = new TreeNode(in.front());
+    TreeNode *ret = temp;
+    in.pop();
+    root_ptrs.push(temp);
+    while (!in.empty())
     {
+        temp = root_ptrs.front();
+        if (in.front() == NULL)
+            temp->left = nullptr;
+        else
+            temp->left = new TreeNode(in.front());
+        in.pop();
+        if (in.empty())
+            break;
+        if (in.front() == NULL)
+            temp->right = nullptr;
+        else
+            temp->right = new TreeNode(in.front());
         in.pop();
-        return nullptr;
-    }
 
-    TreeNode *temp = new TreeNode(in.front());
-    in.pop();
-    temp->left = deserialize(in);
-    temp->right = deserialize(in);
+        if (temp->left != nullptr)
+            root_ptrs.push(temp->left);
+        if (temp->right != nullptr)
+            root_ptrs.push(temp->right);
 
-    return temp;
+        root_ptrs.pop();
+    }
+    return ret;
 }
 
+// TreeNode *Tree::deserialize(std::queue<int> &in)
+// {
+//     if (in.empty())
+//         return nullptr;
+//     if (in.front() == NULL)
+//     {
+//         in.pop();
+//         return nullptr;
+//     }
+
+//     TreeNode *temp = new TreeNode(in.front());
+//     in.pop();
+//     temp->left = deserialize(in);
+//     temp->right = deserialize(in);
+
+//     return temp;
+// }
+
 void Tree::print()
 {
-    print_tree(this->root);
-    std::cout << std::endl;
+    print_tree(root);
 }
 
 bool Tree::operator==(const Tree &t2) const
 {
-    return compare_tree(this->root, t2.root);
+    return is_same_tree(root, t2.root);
 }
 } // namespace LeetCode

include/btree.h

@@ -8,7 +8,7 @@
  * @brief    
  * @version  0.0.1
  * 
- * Last Modified:  2019-07-29
+ * Last Modified:  2019-07-30
  * Modified By:    Jiang Yang ([email protected])
  * 
  */
@@ -33,7 +33,7 @@ struct TreeNode
 };
 
 void print_tree(TreeNode *root);
-bool compare_tree(TreeNode *root1, TreeNode *root2);
+bool is_same_tree(TreeNode *root1, TreeNode *root2);
 
 class Tree
 {

src/searchBST.cc

@@ -0,0 +1,46 @@
+/**
+ * 
+ * Copyright (c) 2018 NUAA Jiang Yang
+ * 
+ * @file
+ * @author   Jiang Yang ([email protected])
+ * @date     2018-11
+ * @brief    
+ * @version  0.0.1
+ * 
+ * Last Modified:  2019-07-30
+ * Modified By:    Jiang Yang ([email protected])
+ * 
+ */
+#include "headers.h"
+
+class Solution
+{
+public:
+    TreeNode *searchBST(TreeNode *root, int val)
+    {
+        while (root != nullptr && root->val != val)
+        {
+            if (root->val > val)
+                root = root->left;
+            else
+                root = root->right;
+        }
+        return root;
+    }
+};
+
+TEST(searchBST, searchBST_1)
+{
+    Solution s;
+    Tree in = {4, 2, 7, 1, 3};
+    Tree res = {2, 1, 3};
+    EXPECT_TRUE(is_same_tree(s.searchBST(in.root, 2), res.root));
+}
+
+int main(int argc, char **argv)
+{
+    ::testing::InitGoogleTest(&argc, argv);
+
+    return RUN_ALL_TESTS();
+}

test/test_tree.cc

@@ -8,7 +8,7 @@
  * @brief    
  * @version  0.0.1
  * 
- * Last Modified:  2019-07-29
+ * Last Modified:  2019-07-30
  * Modified By:    Jiang Yang ([email protected])
  * 
  */
@@ -43,19 +43,32 @@ TEST(test_tree, create)
     Tree t4{1, NULL};
 }
 
+TEST(test_tree, create_with_NULL)
+{
+    Tree t{NULL};
+}
+
 TEST(test_tree, print)
 {
     Tree t1{1, 2, 3, 4, NULL, NULL, NULL};
     t1.print();
 }
 
+TEST(test_tree, print_NULL)
+{
+    Tree t1{NULL, NULL, NULL};
+    t1.print();
+}
+
 TEST(test_tree, compare)
 {
     Tree t1{1, 2, 3, 4, NULL, NULL, NULL};
     Tree t2{1, 2, 3, NULL, NULL, NULL, NULL};
     Tree t3{1, 2, 3, 4, NULL, NULL, NULL};
+    Tree t4{1, 2, 3, 4};
     EXPECT_FALSE(t1 == t2);
     EXPECT_TRUE(t1 == t3);
+    EXPECT_TRUE(t1 == t4);
 }
 
 int main(int argc, char **argv)