标签: binary-tree

我想要在树中的某个级别显示所有节点:

被称为: allNodesAtACertainLevel(0, *whatever level you want*, root);

这产生了正确的答案.

private void allNodesAtACertainLevel(int count, int level, Node n){

        count += 1;

        if(count <= level){
            if(n.left != null) allNodesAtACertainLevel(count, level, n.left);
            if(n.right != null) allNodesAtACertainLevel(count, level, n.right);
        }
        else{
            System.out.print(n.value);
        }

    }

事实并非如此.

private void allNodesAtACertainLevel(int count, int level, Node n){

        if(count < level){
            if(n.left != null) allNodesAtACertainLevel(count++, level, n.left);
            if(n.right != null) allNodesAtACertainLevel(count++, level, n.right);
        }
        else{
            System.out.print(n.value);
        }

    }

有人能解释为什么吗？

存在具有特殊属性的二叉树,其所有内部节点具有val ='N'并且所有叶具有val ='L'.鉴于其预订.构造树并返回根节点.

每个节点可以有两个孩子或没有孩子

所以我试图使用这个递归函数将值插入二叉树:

void add(node* *hd, int v){
node* curr = *hd;
if(curr == NULL){
    curr = (node*)malloc(sizeof(node));
    curr->value = v;
}else{
    if(v < curr->value){
        add(&curr->left, v);
    }else{
        add(&curr->right, v);
    }
}
}

它似乎没有用,我只是不明白为什么我不能做这样的事情.我该怎么办呢？

存在未知深度的不平衡二叉树.具有两个子节点的节点的数量由表示T2.仅具有一个子T1节点的节点由叶节点表示,并且叶节点由表示L.如果考虑到T1 = m和T2 = n节点,那么你可以定义一个数学函数f(m, n),其给出的叶节点L个？

例如,在下面的树T2中m = 3,总T1节点数和总节点数是n = 2.叶节点的数量L = f(m,n) = 4.你能找到一个数学函数f(m,n),它给出了所有树的叶子节点数量吗？

我试图在Haskell中打印一个二叉树,这样如果你把头转向左边,它应该看起来像一棵树.树中的每个级别应该比前一级别缩进2个空格.

这是预期的输出:

--        18
--      17
--        16
--    15
--          14
--        13
--      12
--        11
--  10
--        9
--          8
--      7
--        6
--    5
--        4
--      3
--          2
--        1

对于这棵树:

treeB = (Node (Node (Node (Node Empty 1 (Node Empty 2 Empty)) 3 (Node Empty 4 Empty)) 5 (Node (Node Empty 6 Empty) 7 (Node (Node Empty 8 Empty) 9 Empty))) 10 (Node (Node (Node Empty 11 Empty) 12 (Node Empty …

我正在将二进制搜索树作为一项任务.
当我尝试添加1,000,000个元素时,我遇到了问题.
插入15,000个元素后我收到错误:

线程"main"中的异常java.lang.StackOverflowError

我的代码有问题我无法找到我做错的地方.

public class BinarytreeInsert {

    public static void main(String[] args) {
        new BinarytreeInsert().run();
    }

    static class Node {

        Node left;
        Node right;
        int value;

        public Node(int value) {
            this.value = value;
        }
    }

    public void run() {
        Node rootnode = new Node(25);
        System.out.println("Building tree with root value " + rootnode.value);
        System.out.println("=================================");
        for(int i = 0 ; i<1_000_000;i++)
            insert(rootnode, i);

    }


    public void insert(Node node, int value) {
        if (value < node.value) {
            if (node.left != null) …

我有这个树与不同类型的节点,我需要进行深层复制.层次结构看起来像这样:

class AllNodes
{
    //this is a purely virtual base class
};
class TreeNode : public AllNodes
{
    AllNodes *rChild, *lChild;
};
class LeefNode : public AllNodes
{
    int value;
};

问题是,当我想要对整个树进行深层复制时,我不知道哪些节点会有子节点以及哪些节点将具有值.我试过这个,但它不会工作(原因很明显):

void AllNodes::deepCopy(AllNodes* &copied, AllNodes* o)
{
    if(o->rChild == nullptr)
        copied->rChild = nullptr;
    else
    {
        copied->rChild = o->rChild;   
        deepCopy(copied->rchild, o->rChild);
    }

    if(o->lChild == nullptr)
        copied->lChild = nullptr;
    else
    {
        copied->lChild = o->lChild;
        deepCopy(copied->lChild, o->lChild);
    }
}

有没有人对如何实现这一点有一些想法？

逻辑很简单 - 遍历根以后期顺序结束,然后使节点为空.下面是我为删除树的所有节点而编写的代码(即删除二叉树).

问题:未删除实际树.我的意思是deleteTree(BTNode root)函数只将null ref的所有值都归零,而不是head的值.

    tree.preorder();
    tree.deleteTree();
    tree.preorder();- this still prints all values of a tree

即使在执行tree.deleteTree()之后,它也会打印树中的所有节点.

有人可以帮我解决代码中的错误吗？

注意:插入和预订功能没有错误.因此,您可以专注于deleteTree()代码

package com.practice;

import java.util.LinkedList;

public class BinaryTree {
    private BTNode head;

    public void insert(int data){
        BTNode n= new BTNode (data);
        BTNode temp=null;

        if(head==null){
            head=n;
            return;
        }
        else{
            LinkedList q= new LinkedList();
            q.addLast(head); //enque
            while(!q.isEmpty()){
                    temp=(BTNode) q.removeFirst();
                    if( temp.getLeft() ==null){

                            temp.setLeft(n);
                            return;
                    }
                    else{
                    //enque
                        q.addLast( temp.getLeft());
                    }

                    if( temp.getRight() ==null){
                        temp.setRight(n);
                        return;
                }
                else{
                //enque
                    q.addLast( temp.getRight());
                }
            }//while …

我知道在Rust中，编译器不能保证您以声明它们的顺序获取结构数据，以节省内存（我也相信某些C代码优化器会做同样的事情）。假设现在我有一棵二叉树，想将其转换为双链表。在CI中将声明两个结构：

typedef struct tree{
    void* left_child;
    void* right_child;
    void* data;
}tree_t;

对于树，以及：

typedef struct list{
    void* before;
    void* after;
    void* data;
}list_t;

用于链接列表。如果现在我想将树转换为列表，则可以就地执行此操作，只需将树的内存与列表结构相关联并更改指针：

tree_t mytree;
/*fill tree*/
list_t *list_p;
list_p = (list_t)&mytree;
/*change pointers accordingly*/

但是如何在Rust中做这样的事情？甚至不用unsafe代码也有可能吗？直到现在我有了我的树：

struct TreeNode<'a, T> {
    left_child: BinaryTreeLink<'a, T>,
    right_child: BinaryTreeLink<'a, T>,
    data : &'a T,
}

type BinaryTreeLink<'a, T> = Option<Box<TreeNode<'a, T>>>;

列表将是：

struct ListNode<'a, T> {
    before: ListLink<'a, T>,
    after: ListLink<'a, T>,
    data : &'a T,
}

type ListLink<'a, T> = Option<Box<ListNode<'a, …

我自学Lisp，并认为一个不错的简单程序是编写一组标准的树插入和操作例程。我认为可以使用CONS完成此操作，但想尝试使用一种结构。

我整理了一个可行的版本：

(defstruct treenode data left right)

(defun tree-insert ( value tree )
"Insert data into tree"
(if tree
  (if (< value (treenode-data tree))
       (setf (treenode-left tree) (tree-insert value (treenode-left tree)))
       (setf (treenode-right tree) (tree-insert value (treenode-right tree))))
  (setf tree (make-treenode :data value)))
tree)

它在似乎计算效率低下的每一步都重建了树。效率低下，是指每次执行另一级别的递归时都必须使用setf。因此，我想尝试一种通过引用而不是通过值传递树的方案，以便可以在插入树的子例程中进行分配。

我将以下内容拼凑在一起，但不起作用（但请给予我宝贵的评论）：

(defstruct treenode data left right)

(defun tree-insert ( value tree )
"Insert data value into tree, using pass by reference.

value  A datum to insert, in this version has to be a number.
tree …