标签: binary-tree

我正在寻找一种能够实现快速搜索的二进制数据结构(树,列表).我只会在程序的开头/结尾添加/删除项目.因此它将是固定大小的,因此我并不真正关心插入/删除速度.基本上我正在寻找的是一种提供快速搜索并且不使用太多内存的结构.

谢谢

我想执行二叉树的级别顺序遍历.因此,对于给定的树,请说:

     3
    / \
   2   1
  / \   \
 4   6   10

输出将是:

3 2 1 4 6 10

我知道我可以使用某种队列,但是在C中递归执行此算法的算法是什么？任何帮助赞赏.

我有一个遍历树的函数,并将元素作为列表返回.有没有办法简化所有if语句treeToList::traverse,因为它看起来有点多余？

#!/usr/bin/python

def enum(**enums):
  return type('Enum', (), enums)

Order = enum(PREORDER=0, INORDER=1, POSTORDER=2)
def treeToList(root, order=Order.INORDER):
  ret = list()
  def traverse(node, order):
    if order == Order.PREORDER: ret.append(node.data)
    if node.right != None: traverse(node.right, order)
    if order == Order.INORDER: ret.append(node.data)
    if node.down != None: traverse(node.down, order)
    if order == Order.POSTORDER: ret.append(node.data)
  traverse(root, order)
  return ret

class node:
  def __init__(self, data=None):
    self.data = data
    self.down = None
    self.right = None

if __name__ == '__main__':
  root = node('F')
  root.right = node('B')
  root.down …

我想垂直打印二叉树.我知道使用hashmap的解决方案.但是,我在许多地方读到可以通过使用双向链表来完成.但是,我无法弄清楚如何做到这一点.我也无法在网上找到任何可以理解的材料.有人可以帮助我使用双向链表方法吗？

例:

        5
    4       3
  6   7   8   9

这给了

6
4
5 7 8
3
9

即它就像一个水平顺序遍历垂直顺序.

使用哈希映射解决方案:假设根是索引0,那么离开的会是-1,-2等和右的人会+1,+2等等.所以,我们可以建立键安装在列数的哈希,并有所有列表具有该特定列号作为值的根.然后我们可以简单地打印哈希条目.

请参阅此链接,阅读第1轮评论,技术问题1.

我在其他许多地方也发现了同样的评论.

我必须以这样的方式完成方法maxElem(节点节点),方法maxElem()返回二叉树中包含的最大值.

我怎样才能做到这一点？我不知道如何去做..

public class BinaryTree {

    protected class Node {
        protected Integer element;
        protected Node left;
        protected Node right;

        Node(int element) {
            this.element = element;
            left = right = null;
        }

        Node(int element, Node left, Node right) {
            this.element = element;
            this.left = left;
            this.right = right;
        }

    } //end Node class

    public class NodeReference {
        private Node node;

        private NodeReference(Node node) {
            this.node = node;
        }

        public int getElement() {
            return node.element;
        }

        public void …

我正在读二元树.在练习编码问题时,我遇到了一些解决方案,要求找到二叉树的最小深度.现在根据我的理解,深度不是从根到节点的边缘(叶节点/二叉树的情况下的叶节点)

二叉树的最小深度是多少{1,2}

根据我的解决方案,它应该是1.

我有这个算法,A和B是两个不同的二叉树根的地址.

每个节点都有一个值,指向左子树的指针和指向右子树的指针.

这是算法:

foo(A,B){

    if (A == NULL){
        return B;
    }
    if (B != NULL){
        if(A->value > B->value){
            return foo(B,A);
        }
        B->left = foo(A->right,B->left);
        A->right = B;
    }
    return A;
}

我确实设法理解它将树B合并到树A的右子树中,但是我没有经理去了解值的规律性.

希望你能帮我这个,谢谢!

我想了解红黑树是如何工作的.我理解算法,如何在插入和删除操作后修复属性,但我不清楚.为什么红黑树比二叉树更平衡？我想了解直觉,为什么旋转和固定树属性使红黑树更加平衡.

谢谢.

我正在学习Haskell使用Haskell表达学校:通过多媒体学习功能编程,我不确定如何解决这个问题.

使用由给定的树的定义

data Tree a = Node (Tree a) (Tree a) | Leaf a

Run Code Online (Sandbox Code Playgroud)

定义列表函数的树版本zip和zipWith.在树叶或树木形状不同的情况下,您将不得不做出设计决定.尽量让你的决定尽可能优雅.

因为zip我有这个,但我不确定它是否"优雅"

zipTree :: Tree a -> Tree b -> Tree (a,b)
zipTree (Leaf a)     (Leaf b)     = Leaf (a,b)
zipTree (Node l1 r1) (Node l2 r2) = 
  let l = zipTree l1 l2
      r = zipTree r1 r2 
  in Node l r 

-- Problems...
zipTree (Node _ _)  (Leaf _)   = Node undefined undefined
zipTree (Leaf _)    (Node _ …

给定以下数据类型:

data Tree a =
    Branch (Tree a) (Tree a)
  | Leaf a deriving (Eq, Show)

以下的Functor实例:

instance Functor Tree where
  fmap f (Leaf a)       = Leaf $ f a
  fmap f (Branch t1 t2) = Branch (fmap f t1) (fmap f t2)

如何最好地实现这棵树的Applicative实例？我提出了:

instance Applicative Tree where
  pure = Leaf

  Leaf f       <*> t            = f <$> t
  Branch t1 t2 <*> Leaf a       = t1 <*> Leaf a
  Branch t1 t2 <*> Branch t3 t4 = Branch (t1 …