我必须为树集编写一个模板。 叶子的大小是0。 当调用create_empty_set（）时，它应该生成一个叶子，当你添加T数据时，叶子应该成为一个分支，它的值应该放在左边或右边。不允许重复。 我会在这里发布老师的指示：
So, you'll need three classes: a supertype SortedTree and two subtypes named Branch and Leaf.
LinkedList nodes carried little integers with them. For our set, we want to do something better: we wish
the set to be able to contain any kind of values. The way to accomplish this is to make use of templates:
a TreeSet<T> contains values of type T.
Where do the set's elements reside exactly? Each Branch node contains exactly one T, while the leaves contain nothing:
they merely serve as "plugs" to fill the holes in the tree.
We don't want the T-values to be stored arbitrarily: there'd be no point in using a tree.
We want the values to be sorted. As mentioned above, each branch refers to two nodes (its child nodes) and has its own value.
A branch's value must be larger than all values stored in its left children but less than all values stored in its right children.
For example (leaves are not shown):
[BRANCH 8]
| |
+---------------+ +-------------------+
| |
[BRANCH 4] [BRANCH 11]
| | | |
+-----+ +----+ +-----+ +------+
| | | |
[BRANCH 1] [BRANCH 7] [BRANCH 9] [BRANCH 15]
Take the root node, i.e., the branch carrying 8. All values in its left node (1, 4, 7) are less than 8
and the values in the right children (9, 11, 15) are all greater than 8. The same rule is applicable on each branch in the tree.
Note that no duplicates are allowed: a set cannot contain the same value twice.
我真的很困惑，不知道如何继续。 任何向正确方向的推进都将非常感激。
[BRANCH] --> [BRANCH] --> [BRANCH] --> [LEAF]
| | |
| | +-----> [LEAF]
| |
| +-----> [BRANCH] --> [LEAF]
| |
| +-----> [LEAF]
|
+------> [BRANCH] --> [LEAF]
|
+-----> [BRANCH] --> [LEAF]
|
+-----> [LEAF]
这就是我已经拥有的。
#ifndef TREE_SET_H
#define TREE_SET_H
#include <memory>
template<typename T>
class TreeSet
{
public:
TreeSet();
virtual int size();
std::shared_ptr<TreeSet<T>> add(T data);
private:
int _size;
T value;
std::shared_ptr<TreeSet<T>> left;
std::shared_ptr<TreeSet<T>> right;
};
template<typename T>
class Leaf : public TreeSet<T> {
public:
Leaf();
private:
};
template<typename T>
class Branch : public TreeSet<T> {
public:
Branch();
private:
};
template <typename T>
TreeSet<T>::TreeSet():_size(0) {
}
template<typename T>
Leaf<T>::Leaf() : TreeSet()
{
}
template<typename T>
Branch<T>::Branch() : TreeSet()
{
}
template<typename T>
std::shared_ptr<TreeSet<T>> create_empty_set()
{
//return std::make_shared<TreeSet<T>>();
return std::make_shared<Leaf<T>>();
}
template<typename T>
int TreeSet<T>::size() {
return _size;
}
template<typename T>
std::shared_ptr<TreeSet<T>> TreeSet<T>::add(T data)
{
return std::shared_ptr<TreeSet<T>>();
}`#endif
`
这是添加测试
#include "Catch.h"
#include "tree-set.h"
#include "util.h"
/*
Add a method named "add" to the hierarchy. The method must take
a value to be added to the set and return a new TreeSet that contains the element.
The original tree must remain unchanged.
Also update Branch's size().
*/
TEST_CASE("Adding element to TreeSet<int> yields new TreeSet<int>")
{
const auto t1 = create_empty_set<int>();
std::shared_ptr<TreeSet<int>> t2 = t1->add(5);
}
TEST_CASE("Adding element to TreeSet<bool> yields new TreeSet<bool>")
{
auto t1 = create_empty_set<bool>();
std::shared_ptr<TreeSet<bool>> t2 = t1->add(true);
}
TEST_CASE("Adding single element increments size from 0 to 1")
{
auto t1 = create_empty_set<bool>();
auto t2 = t1->add(true);
CHECK(t2->size() == 1);
}
TEST_CASE("Adding leaves the original TreeSet unchanged")
{
auto t1 = create_empty_set<char>();
auto t2 = t1->add('a');
CHECK(t1->size() == 0);
}
TEST_CASE("Adding multiple elements increases size by 1 at each time")
{
auto t = create_empty_set<int>();
CHECK(t->size() == 0);
t = t->add(0);
CHECK(t->size() == 1);
t = t->add(1);
CHECK(t->size() == 2);
t = t->add(2);
CHECK(t->size() == 3);
t = t->add(3);
CHECK(t->size() == 4);
}
TEST_CASE("Adding an element already in the set does not increment size")
{
auto t = create_empty_set<int>();
CHECK(t->size() == 0);
t = t->add(0);
CHECK(t->size() == 1);
t = t->add(0);
CHECK(t->size() == 1);
t = t->add(78);
CHECK(t->size() == 2);
t = t->add(78);
CHECK(t->size() == 2);
}
这是另一个测试
/*
Add a method size() to your hierarchy. For now, Branch's implementation of this method
can return a dummy value.
*/
TEST_CASE("Size of an empty TreeSet<int> is zero")
{
const auto t = create_empty_set<int>();
CHECK(t->size() == 0);
}
TEST_CASE("Size of an empty TreeSet<bool> is zero")
{
const auto t = create_empty_set<bool>();
CHECK(t->size() == 0);
}
TEST_CASE("Size of an empty TreeSet<char> is zero")
{
const auto t = create_empty_set<char>();
CHECK(t->size() == 0);
}
TEST_CASE("TreeSet is a polymorphic type (i.e., it contains at least one virtual member)")
{
const auto t = create_empty_set<int>();
CHECK(is_leaf(*t));
}
这是给定的util.h标题
#ifndef UTIL_H
#define UTIL_H
struct Foo
{
bool operator <(const Foo& foo) const
{
return false;
}
};
struct Bar
{
int x;
bool operator <(const Bar& bar) const
{
return x < bar.x;
}
};
template<typename T, typename U>
bool has_dynamic_type(const U& x)
{
return dynamic_cast<const T*>(&x) != nullptr;
}
template<typename T>
bool is_leaf(const TreeSet<T>& x)
{
return has_dynamic_type<Leaf<T>>(x);
}
template<typename T>
bool is_branch(const TreeSet<T>& x)
{
return has_dynamic_type<Branch<T>>(x);
}
#endif
提前致谢， Kelvijn
答案 0 :(得分：1)
你的问题非常广泛。我想指出一些事情。 首先，由于您的树节点是模板类，为了对树进行排序，您应该能够对类型进行比较和排序。你可以比较整数，你可以比较字符串（你必须定义一个函数来比较它们或使用strcmp），但你不能真正比较布尔值。除非你想把左边的虚假和左边的虚假放在一边。此外，当您创建一个“Foo”树，其中Foo是某个类时，您需要为该类定义一个比较器。也许重载所有或部分运算符==＆lt; ＆GT; ＆gt; =＆lt; =
无论如何对树进行排序还意味着要保持平衡的操作。我建议您从维基百科https://en.wikipedia.org/wiki/Tree_sort开始，并搜索其他问题和答案。
另一个重要的事情：在你的代码中我将TreeSet重命名为TreeNode。这就是它的真实含义，你写的是什么。 TreeSet是一组TreeNode。只需将其声明为指向树的根节点的指针。而Branch和Leaf实际上不值得成为子类。这根本没有意义。只需创建一个成员函数（为了清楚起见，我调用了TreeSet TreeNode）
bool TreeNode::isLeaf(){
return !this.right && !this.left;
}
如果返回true，则节点为叶子，否则为分支（或根）...
当你调用create_empty_set（）时，它应该生成一个叶子 添加T数据叶子应该成为一个分支，并且应该放置它的值 在左边或右边。
一些清晰度。请在TreeSet和TreeNode之间进行适当的区分。然后到create_empty_set首先调用构造函数（new TreeNode）（这已经创建了一个空节点）接下来，你需要将它放在树中：运行TreeSet（我提醒你，指针指向根）您的树，最顶层的节点）通过节点的所有指针，直到找到所需的空白点并将其放在您喜欢的位置。例如，如果要向TreeSet添加唯一值，请按某种顺序（例如，在3个订单之一中）{}进行遍历树检查，并检查数据是否已存在：如果存在，请停在那里，否则将其添加到适当的节点。