想知道最有效的方法是通过读入1000字的字典文件,然后让它检查另一个说有几段的文件,将二元搜索树变成拼写检查器.
我目前关于如何输出我的二叉树的实现让我在g ++中遇到错误
Conditional jump or move depends on uninitialised value(s)
我目前的实施是:
void Foo::output(ostream &s, const Node *p)
{
if( p )
{
output( s , p -> left );
s << p -> info;
output( s , p -> right );
}
}
Node是一个基本结构,带有左右指针和一个整数信息变量.
ostream只是cout
错误信息是非常直接的,它不喜欢我让它"跑掉".
我的问题是双重的:
谢谢
所以我想创建一个代码,它创建一个二进制树,保存数据,例如像1,6,2,10,8这样的整数,在pop我得到最大的数字,然后它从树中删除,并且在推送时我可以插入一个新元素.这应该在一个模板中,这样我就可以轻松更改我想要在树中保存的数据类型.现在我得到了树到目前为止,没有模板它工作正常,我可以添加项目,我可以打印它们,但是当我尝试将它放在模板中时,我得到以下错误:使用类模板需要模板参数列表.可能是什么问题呢？也许我做错了.欢迎任何建议.
到目前为止,我得到了以下代码:
#include <iostream>
using namespace std;
template<class T>
class BinaryTree
{
struct Node
{
T data;
Node* lChildptr;
Node* rChildptr;
Node(T dataNew)
{
data = dataNew;
lChildptr = NULL;
rChildptr = NULL;
}
};
private:
Node* root;
void Insert(T newData, Node* &theRoot)
{
if(theRoot == NULL)
{
theRoot = new Node(newData);
return;
}
if(newData < theRoot->data)
Insert(newData, theRoot->lChildptr);
else
Insert(newData, theRoot->rChildptr);;
}
void PrintTree(Node* theRoot)
{
if(theRoot != NULL)
{
PrintTree(theRoot->lChildptr);
cout<< theRoot->data<<" ";;
PrintTree(theRoot->rChildptr);
}
} …我习惯了以下Tree定义:
data Tree a = Empty | Node a (Tree a) (Tree a)
直到我遇到某个地方:
data Tree a = Empty | Leaf a | Node a (Tree a) (Tree a)
这让我对Haskell成语感到疑惑.
既然Leaf a只是Node a Empty Empty,这个构造函数应该存在吗？我们也可以删除Empty,使用像这样的独特构造函数
Tree (Maybe (a, (Tree a), (Tree a)))
或类似的东西.
我写的第二个定义是"扩展最多"的定义,第一个定义介于它和最后一个定义之间.什么是实际和理论上最好的？换句话说,性能和数据类型的设计呢？
部分原因是我必须实现二阶树的顺序遍历的非递归方法.我有点卡住了.这是我到目前为止:
public void inorder(BinaryTree v) {
Stack<BinaryTree> stack = new Stack<BinaryTree>();
stack.push(v);
System.out.println(v.getValue());
while(!stack.isEmpty()) {
while(v.getLeft() != null) {
v = v.getLeft();
stack.push(v);
System.out.println(v.getValue());
}
while(v.getRight() != null) {
v = v.getRight();
stack.push(v);
System.out.println(v.getValue());
}
stack.pop();
}
}
我注意到它只打印出我树的左侧,例如
A
/ \
B C
/ \ / \
D E F G
/ \
H I
/ \
J K
给 A B D H J
我知道递归函数是F#中一种强大的技术.我的问题是:是否有退出语句,它可以跳出递归函数,就像命令式语言一样.例如,将节点插入二叉树.
type Tree<'a> when 'a :> IComparable<'a> =
| Nil
| Leaf of 'a
| Node of Tree<'a> * 'a * Tree<'a>
let tt2 = Node(
Node(Leaf "D", "B",Node(Leaf "G", "E", Leaf "H" )),
"A",
Node(Nil, "C", Node(Nil, "F", Leaf "I")))
let rec contains (x : #IComparable<'a>) = function
| Nil -> false
| Leaf y -> if x.CompareTo(y) = 0 then true else false
| Node(l, y, r) ->
match l, y, r with
| l, y, Nil -> …我需要在二叉树中找到所有可能的子树:
allSubtrees :: BinaryT a -> [BinaryT a]
allSubtrees = undefined
树是:
data BinaryT a =
Empty
| Node (BinaryT a) a (BinaryT a)
deriving (Eq, Show)
我是Haskell的新手,我知道Haskell中没有while/ forloop.Haskell就是递归.我的问题是,如何在没有无限递归的情况下获得树的所有可能的子树？
有人可以帮助我使用算法迭代地遍历二叉树而不使用任何其他数据结构,如堆栈
我读到某处我们可以为每个节点设置一个名为visited的标志,如果访问了该节点但是我的BinaryTreeNode类没有定义访问变量,则打开.所以我不可能做像node.left.visited = false这样的事情
有没有其他方法可以迭代遍历？
更新:抱歉令人困惑的术语 - 我不需要二叉树,但需要分段树或区间树.
想象一下,每次执行我的程序时,我都必须静态初始化一个搜索树.
Tree t;
t.add(10, 'Apple');
t.add(20, 'Pear');
t.add(50, 'Orange');
...
t.add(300, 'Cucumber');
..
// then I use it.
int key = 15;
String s = t.lookup(key) // Returns 'Apple' ( as the key is between 10 and 20)
树中的键和值是"静态的",是硬编码的,但必须不时地进行维护.是否存在元编程技巧如何在编译期间将键值组织成二进制搜索树(或跳过列表)？
例如,整个搜索树是直接在代码中实现的.text,什么都没有.data？我还可以"预测"键的数量并提供订单.
我编写了一个C程序,用于从数组构造二进制搜索树.它通过以下步骤:
1:使用排序数组qsort().
2:使用递归函数将数组的已排序元素放入二叉树中treeify():
2a:获取数组的中间元素(通过将其长度除以2)并将其作为content树结构的字段(此子树的根节点)放置.
2b:函数然后将剩余元素的左半部分和右半部分复制到较小的数组中,并分别为这些数组中的每一个调用自身.
2c:通过根节点返回树.
3:递归遍历树并以缩进格式打印其内容.
基本上,我使用了一个分而治之的范例来从已经排序的数组构建树.令人惊讶的是(因为这是我第一次设计D&C算法),这部分进展得相当顺利.
我真正遇到麻烦的地方是在第3步.有时它可以工作,当它确实时,所有的元素都是正确的顺序,所以这部分显然有用.但是,有90%的时间我运行程序,它会在到达第一个叶节点时发生段错误.
这是完整的程序文本.我已经改变了打印功能,以便打印节点的地址(用于调试目的).最初显示数值...
#include <stdio.h>
#include <stdlib.h>
struct tree {
int content;
struct tree *left;
struct tree *right;
};
struct tree *treeify( int *, size_t );
void printtree( struct tree *, int );
int comp( int *, int * );
int main( int argc, char **argv ){
int array[] = { 5, 6, 7, 2, 3, 4, 9, 1, 8, 0 };
/* Sort array */
qsort( …