标签: binary-tree

我正在尝试删除所有的叶子.我知道叶子没有孩子,这就是我到目前为止所拥有的.

 public void removeLeaves(BinaryTree n){  

    if (n.left == null && n.right == null){

        n = null;

    }

    if (n.left != null)

        removeLeaves(n.left);

    if (n.right != null)

        removeLeaves(n.right);

}

我们知道预订,有序和后期遍历.什么算法会重建BST？

我有一组范围:

Range1 ----(0-10)

Range2 ----(15-25)

范围3 ----(100-1000)和同样.我想只存储边界,因为存储大范围,它会很有效.

现在我需要搜索一个数字,比如14.在这种情况下,14不存在于任何范围内,而(例如数字)16存在于其中一个范围内.

我需要一个功能

bool search(ranges, searchvalue)
{
    if searchvalues present in any of the ranges
        return true;
    else
        return false;
}

如何才能做到最好？这是严格不重叠的,重要的标准是搜索必须最有效.

我在接受采访时被问及双链表和二叉树的节点结构之间的区别.

双重链表结构

typedef struct
{
int data;
struct node * next;
struct node * prev;
}node;    

二叉树结构

typedef struct
{
int data;
struct node * left;
struct node * right;
}node;  

1. 在双向链表中,我们使用指针在线性排列的列表中向后和向前遍历.
   
2. 但是左右指针用于访问左右节点的位置.

我发现节点结构没有任何区别,除了它们的使用方式.你能不能给我一些分歧？

给定二进制树节点(X)写入方法的数量,该方法返回具有X个节点的二叉树的随机排列的数量.

例子:

X = 1:1

     o

X = 2:2

     o    o
   o        o

X = 3:5

        o    o          o     o        o
      o        o      o         o    o   o
    o            o      o     o

我结束了:

    public static int numOfPerms(int numOfNodes) {
       if (numOfNodes<=2 && numOfNodes > 0) {
           return numOfNodes;
       }
       int res = 1;
       for (int i=1; i<=numOfNodes; i++) {
           res = res*(4*i-1)/(i+1);
       }
       return res;
    } 

我希望在这里分享更好的解决方案.

我已经实现了二叉搜索树,但我也想让它变得通用.代码如下:

typedef struct treeNode {
  int data;
  struct treeNode *left;
  struct treeNode *right;
} treeNode;

和功能:

treeNode* FindMin(treeNode *node) {
  if(node==NULL) {
    /* There is no element in the tree */
    return NULL;
  }
  if(node->left) /* Go to the left sub tree to find the min element */
    return FindMin(node->left);
  else 
    return node;
}

treeNode * Insert(treeNode *node,int data) {
  if(node==NULL) {
    treeNode *temp;
    temp = (treeNode *)malloc(sizeof(treeNode));
    temp -> data = data;
    temp -> left = temp -> right …

我正在使用PyGraphviz绘制二叉搜索树.我无法使用PyGraphviz创建重复节点,因为边缘循环回节点.

例如,以下代码仅生成5个节点,从而省略了重复的节点.我尝试使用唯一索引标记每个节点,但这不能解决问题.

import pygraphviz as pgv
tree = pgv.AGraph(directed=True, strict=True)
tree.add_node(2)
tree.add_node(3)
tree.add_node(1)
tree.add_node(7)
tree.add_node(3)
tree.add_node(9)
tree.add_node(2)
tree.write('foo.dot')
image = pgv.AGraph('foo.dot')
image.layout()
image.draw('foo.pdf')
image.close()

我的代码绘制到BST:

import pygraphviz as pgv
import random


class Node:
    insertion_step = []

    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None

    def addNode(self, data):
        if data < self.data:
            if self.left is None:
                self.left = Node(data)
                self.printSubtree()
            else:
                self.left.addNode(data)  # recursively calling addNode method
        else:
            if self.right is None:
                self.right = Node(data)
                self.printSubtree()
            else: …

我正在尝试编写一个方法来查找给定节点的父节点.这是我的方法.
我创建了一个BinaryNode最初引用root 的对象r.

    public BinaryNode r=root;
    public BinaryNode parent(BinaryNode p){
    BinaryNode findParent=p;        
        if (isRoot(findParent) || r==null){
                return null;
        }
        else{
            if(r.left==findParent || r.right==findParent)
                return r;
            else{
                if (r.element<findParent.element)
                    return parent(r.right);
                else
                    return parent(r.left);
            }
        }
    }  

这段代码不能正常工作.我认为这是因为r是一个空对象.因为当我这样做

if (isRoot(findParent) || r==null){
                System.out.println(r==null);
                return null;}  

r==null评估为true.如何发生,因为我已插入节点

public static void main (String args[]){
        BinaryTree t=new BinaryTree();
        t.insert(5);
        t.insert(t.root,4);
        t.insert(t.root,6);
        t.insert(t.root,60);
        t.insert(t.root,25);
        t.insert(t.root,10);  

并且root不为null.
有人可以指出为什么会发生这种情况,以及我为了找到父节点而尝试做的事情在逻辑上是否正确.

我是JavaScript的数据结构的新手,我正在尝试学习二进制搜索树.我正在关注博客文章,并且能够找到解决BST中最大深度问题的有效解决方案,但我不清楚递归是如何工作的以及每次每次添加+1的方法深度.考虑这个问题的好方法是什么？基本上每次节点值不为空时,1会被添加到最终将被调用堆栈返回的内容中(即在每个级别向后回溯到根目录时)？

 function maxDepth(node) {
  // console.log(node.left);
  if (node) {
    return Math.max(maxDepth(node.left), maxDepth(node.right)) + 1;
  } else {

    return 0;
  }
}

我要求定义函数：

treeMap :: (a -> b) -> BinaryTree a -> BinaryTree b

它接受一个函数和一个二叉树，并生成一个二叉树，其中所有节点都是在给定树上应用该函数的结果

二进制树是：

data BinaryTree a = Nil | BNode a (BinaryTree a) (BinaryTree a)

和我的代码不符合。我收到以下错误：

error: Not in scope: data constructor ‘BinaryTree’
treeMap f (BNode x (BinaryTree l) (BinaryTree r)) =    |                                    ^^^^^^^^^^

我的代码：

data BinaryTree a = Nil | BNode a (BinaryTree a) (BinaryTree a)

treeMap :: (a -> b) -> BinaryTree a -> BinaryTree b
treeMap f Nil  = Nil
treeMap f (BNode x (BinaryTree l) …