tree-traversal

How to traverse a Btree?

浪尽此生 — Wed, 27 Jan 2021 22:27:17 +0000

How to traverse a Btree? 浪尽此生 2021-01-28 06:27:17

问题

I have a Btree and I'm trying to figure out how traverse it so that the keys are displayed ascending order.

All I can figure out is that this can be done with a recursive function.

What's the pseudo-code to do it?

回答1:

Assuming you have a definition like:

template <class T>
class btree_node
{
    btree_node **child;  // an array of child nodes
    T **element;  // the elements in this node

    unsigned int child_count; // the number of children
                              // the number of elements is 1 less then child_count
};

Then you'll need do something like this:

void btree_inorder(node):
    for (int i = 0; i < node.child_count; ++i)
    {
        btree_inorder(node.child[i]);
        handle_element(node.element[i]);
    }
    btree_inorder(node.child[node.child_count-1]);

回答2:

void traversalBtree(struct node * root){
    int i = 1;
    if(root != NULL){
        while(i <= root->n){
            if(root->leaf == 0)
                traversalBtree(root->link[i]);
            printf("\t%d", root->key[i]);
            i++;
        }
        if(root->leaf == 0)
            traversalBtree(root->link[i]);
    }
}

来源：https://stackoverflow.com/questions/2799966/how-to-traverse-a-btree

标签

c++

g++

traversal

b-tree

tree-traversal

Amortized Time Calculation in AVL tree

旧巷老猫 — Sat, 26 Dec 2020 23:24:49 +0000

Amortized Time Calculation in AVL tree 旧巷老猫 2020-12-27 07:24:49

问题

My professor showed the following problem in class and mentioned that the answer is O(1) while mine was quit different, I hope to get some help knowing of what mistakes did I made.

Question:

Calculate the Amortized Time Complexity for F method in AVL tree, when we start from the minimal node and each time we call F over the last found member.

Description of F: when we are at specific node F continues just like inorder traversal starting from the current one until the next one in inorder traversal for the next call.

What I did:

First I took an random series of m calls to F.

I said for the first one we need O(log n) - to find the most minimal node then for the next node we need to do inorder again but continues one more step so O(log n)+1 an so on until I scan m elements.

Which gets me to:

To calculate Amortized Time we do T(m)/m then I get:

Which isn't O(1) for sure.

回答1:

The algorithm doesn't start by searching for any node, but instead is already passed a node and will start from that node. E.g. pseudocode for F would look like this:

F(n):
     if n has right child
         n = right child of n

         while n has left child
             n = left child of n

         return n
     else
         prev = n
         cur = parent of n
         while prev is right child of cur and cur is not root
             prev = cur
             cur = parent of prev

         if cur is root and prev is right child of cur
             error "Reached end of traversal"
         else
             return cur

The above code basically does an in-order traversal of a tree starting from a node until the next node is reached.

Amortized runtime:
Pick an arbitrary tree and m. Let r_0 be the lowest common ancestor of all nodes visited by F. Now define r_(n + 1) as the lowest common ancestor of all nodes in the right subtree of r_n that will be returned by F. This recursion bottoms out for r_u, which will be the m-th node in in-order traversal. Any r_n will be returned by F in some iteration, so all nodes in the left subtree of r_n will be returned by F as well.

All nodes that will be visited by F are either also returned by F or are nodes on the path from r_0 to r_u. Since r_0 is an ancestor of r_1 and r_1 is an ancestor of r_2, etc., the path from r_0 to r_u can be at most as long as the right subtree is high. The height of the tree is limited by log_phi(m + 2), so in total at most

m + log_phi(m + 2)

nodes will be visited during m iterations of F. All nodes visited by F form a subtree, so there are at most 2 * (m + log_phi(m + 2)) edges that will be traversed by the algorithm, leading to an amortized runtime-complexity of

2 * (m + log_phi(m + 2)) / m = 2 + 2 * log_phi(m + 2) / m = O(1)

(The above bounds are in reality considerably tighter, but for the calculation presented here completely sufficient)

来源：https://stackoverflow.com/questions/65314222/amortized-time-calculation-in-avl-tree

标签

Find Path to Specified Node in Binary Tree (Python)

删除回忆录丶 — Fri, 12 Jun 2020 14:09:16 +0000

Find Path to Specified Node in Binary Tree (Python) 删除回忆录丶 2020-06-12 22:09:16

问题

I'm having trouble computing the path from the root to a specified node in a binary tree (this is specifically about a Python solution to this problem).

Here's an example. Given the binary tree below, if I specify the node whose value is 4, I want to return [1, 2, 4]. If I specify the node whose value is 5, I want to return [1, 2, 5].

Here's my attemped solution.

class TreeNode:
 def __init__(self, x):
     self.val = x
     self.left = None
     self.right = None

def path(root, k, l=[]):
    if not root:
        return []
    if root.val == k:
        return l

    # Pre-order traversal: Visit root, then left, then right.
    l.append(root.val)
    path(root.left, k, l)
    path(root.right, k, l)
    return l

Now if I run this

>>> a = TreeNode(1)
>>> b = TreeNode(2)
>>> c = TreeNode(3)
>>> d = TreeNode(4)
>>> e = TreeNode(5)
>>> a.left = b
>>> a.right = c
>>> b.left = d
>>> b.right = e
>>> path(a, 4) # should be [1, 2, 4]
[1, 2, 5, 3]

You can see that I don't get the expected. I'm sure it has to do with my traversal algorithm, but I can't figure out where I'm going wrong. Any help is greatly appreciated.

回答1:

The missing 4 is caused by the fact that you never append it. In your success case:

if root.val == k:
    return l

… you need to d this:

if root.val == k:
    l.append(root.val)
    return l

The extra 3 and 5 are caused by the fact that you always append the value in the intermediate case, even for the nodes where you're going to backtrack.

You can fix that by only appending it if either of the recursive calls returns a non-empty list, but then of course you'll have the nodes out of order. The easiest fix for that is to intentionally get the nodes out of order:

# Pre-order traversal: Visit root, then left, then right.
if path(root.left, k, l) or path(root.right, k, l):
    l.append(root.val)

… and then reverse the list at the end, e.g., in a wrapper function:

def path2(root, k):
    return list(reversed(path(root, k)))

However, there's still one problem left in your code, right here:

def path(root, k, l=[]):

That [] that's the default value for l gets created one time, when the def is executed, and then reused on every call. That means that path2(a, 4) will return the right answer the first time, [1, 2, 4], but when you call it a second time, it'll keep appending to that same list and return [1, 2, 4, 1, 2, 4].

There are a couple idiomatic ways around this, but in our case, since we're already using that path2 wrapper function, we might as well just fix it there:

def path2(root, k):
    return list(reversed(path(root, k, [])))

… and then get rid of the default value on path.

However, you might want to consider starting over with an easier-to-understand version:

def path(root, k):
    if not root:
        return []
    if root.val == k:
        return [root.val]
    res = path(root.left, k)
    if res:
        return [root.val] + res
    res = path(root.right, k)
    if res:
        return [root.val] + res
    return []

(You can make this is a bit shorter; I went out of my way to make everything explicit here.)

For many recursive problems, inverting them and passing up an accumulator is an important optimization, because tail-call elimination can remove one of the branches from the stack. Even though Python doesn't do TCE, it's still worth learning how to do things the tail-calling way, just for your own understanding (and in case you ever write code in another language, of course). But learn how to do the simpler version first, and only then try to invert it.

来源：https://stackoverflow.com/questions/49227541/find-path-to-specified-node-in-binary-tree-python

标签

Find Path to Specified Node in Binary Tree (Python)

淺唱寂寞╮ — Fri, 12 Jun 2020 14:05:57 +0000

Find Path to Specified Node in Binary Tree (Python) 淺唱寂寞╮ 2020-06-12 22:05:57

问题

I'm having trouble computing the path from the root to a specified node in a binary tree (this is specifically about a Python solution to this problem).

Here's an example. Given the binary tree below, if I specify the node whose value is 4, I want to return [1, 2, 4]. If I specify the node whose value is 5, I want to return [1, 2, 5].

Here's my attemped solution.

class TreeNode:
 def __init__(self, x):
     self.val = x
     self.left = None
     self.right = None

def path(root, k, l=[]):
    if not root:
        return []
    if root.val == k:
        return l

    # Pre-order traversal: Visit root, then left, then right.
    l.append(root.val)
    path(root.left, k, l)
    path(root.right, k, l)
    return l

Now if I run this

>>> a = TreeNode(1)
>>> b = TreeNode(2)
>>> c = TreeNode(3)
>>> d = TreeNode(4)
>>> e = TreeNode(5)
>>> a.left = b
>>> a.right = c
>>> b.left = d
>>> b.right = e
>>> path(a, 4) # should be [1, 2, 4]
[1, 2, 5, 3]

You can see that I don't get the expected. I'm sure it has to do with my traversal algorithm, but I can't figure out where I'm going wrong. Any help is greatly appreciated.

回答1:

The missing 4 is caused by the fact that you never append it. In your success case:

if root.val == k:
    return l

… you need to d this:

if root.val == k:
    l.append(root.val)
    return l

The extra 3 and 5 are caused by the fact that you always append the value in the intermediate case, even for the nodes where you're going to backtrack.

# Pre-order traversal: Visit root, then left, then right.
if path(root.left, k, l) or path(root.right, k, l):
    l.append(root.val)

… and then reverse the list at the end, e.g., in a wrapper function:

def path2(root, k):
    return list(reversed(path(root, k)))

However, there's still one problem left in your code, right here:

def path(root, k, l=[]):

There are a couple idiomatic ways around this, but in our case, since we're already using that path2 wrapper function, we might as well just fix it there:

def path2(root, k):
    return list(reversed(path(root, k, [])))

… and then get rid of the default value on path.

However, you might want to consider starting over with an easier-to-understand version:

def path(root, k):
    if not root:
        return []
    if root.val == k:
        return [root.val]
    res = path(root.left, k)
    if res:
        return [root.val] + res
    res = path(root.right, k)
    if res:
        return [root.val] + res
    return []

(You can make this is a bit shorter; I went out of my way to make everything explicit here.)

来源：https://stackoverflow.com/questions/49227541/find-path-to-specified-node-in-binary-tree-python

标签

How to print a binary tree in as a structure of nodes in Python

倾然丶夕夏残阳落幕 — Wed, 13 May 2020 23:25:17 +0000

How to print a binary tree in as a structure of nodes in Python 倾然丶夕夏残阳落幕 2020-05-14 07:25:17

问题

I have a python code to convert a string mathematical expression into a binary tree and order the nodes of the tree so the left child will be always smaller than the right child. I want to print the binary tree in the following order.

For example consider the mathematical expression ((2 * 75) / 4). buildParseTree() converts the string expression into a tree and printNodeInLevels() rearranges the nodes so left child is smaller than the right right child at each level. Operands < operators and operators are orders as '+' < '-' < '*' < '/'. If the structure of the tree is like this

I want to print it as follows. How should I go about this? Because the length of the mathematical expressions vary all the time e.g (24 * 2), ((5 - 1) * (2 / 3)), (20 - (5 + 4)) etc

Node("+") #root
    .addkid(Node("*") #right child at level 1
        .addkid(Node("75")) #right child at level 2
        .addkid(Node("2")) #left child at level 2
            )
    .addkid(Node("4")) #left child at level 1

I have worked out the method to print nodes by their levels as in an in-order traversal pattern.If I call the method as follows it will print the following:

pt = buildParseTree("( ( 2 * 74 ) / 4 )")

printNodesInLevels(pt)

output:

/ 
4 * 
2 74

回答1:

Here is a function I created to print any binary tree structure.

It is very generic and only needs a starting node (root) and a function (or lambda) to obtain a label and the left/right children nodes:

You would typically use it like this on your Node class:

printBTree(rootNode,lambda n: (n.operand, n.left, n.right) )

# assuming the Node class has a string property named operand
# and left,right properties that return a Node or None

A quadratic equation (-b +/- sqrt(b**2 - 4*a*c))/(2*a) could then print like this:

#         /
#     ___/ \__
#  +/-        *
#  / \       / \
# -   sqrt  2   a
#  \     \
#   b    -
#     __/ \_
#   **      *
#  /  \    / \
# b    2  4   *
#            / \
#           a   c

Here is the printBTree function :

import functools as fn

def printBTree(node, nodeInfo=None, inverted=False, isTop=True):

   # node value string and sub nodes
   stringValue, leftNode, rightNode = nodeInfo(node)

   stringValueWidth  = len(stringValue)

   # recurse to sub nodes to obtain line blocks on left and right
   leftTextBlock     = [] if not leftNode else printBTree(leftNode,nodeInfo,inverted,False)

   rightTextBlock    = [] if not rightNode else printBTree(rightNode,nodeInfo,inverted,False)

   # count common and maximum number of sub node lines
   commonLines       = min(len(leftTextBlock),len(rightTextBlock))
   subLevelLines     = max(len(rightTextBlock),len(leftTextBlock))

   # extend lines on shallower side to get same number of lines on both sides
   leftSubLines      = leftTextBlock  + [""] *  (subLevelLines - len(leftTextBlock))
   rightSubLines     = rightTextBlock + [""] *  (subLevelLines - len(rightTextBlock))

   # compute location of value or link bar for all left and right sub nodes
   #   * left node's value ends at line's width
   #   * right node's value starts after initial spaces
   leftLineWidths    = [ len(line) for line in leftSubLines  ]                            
   rightLineIndents  = [ len(line)-len(line.lstrip(" ")) for line in rightSubLines ]

   # top line value locations, will be used to determine position of current node & link bars
   firstLeftWidth    = (leftLineWidths   + [0])[0]  
   firstRightIndent  = (rightLineIndents + [0])[0] 

   # width of sub node link under node value (i.e. with slashes if any)
   # aims to center link bars under the value if value is wide enough
   # 
   # ValueLine:    v     vv    vvvvvv   vvvvv
   # LinkLine:    / \   /  \    /  \     / \ 
   #
   linkSpacing       = min(stringValueWidth, 2 - stringValueWidth % 2)
   leftLinkBar       = 1 if leftNode  else 0
   rightLinkBar      = 1 if rightNode else 0
   minLinkWidth      = leftLinkBar + linkSpacing + rightLinkBar
   valueOffset       = (stringValueWidth - linkSpacing) // 2

   # find optimal position for right side top node
   #   * must allow room for link bars above and between left and right top nodes
   #   * must not overlap lower level nodes on any given line (allow gap of minSpacing)
   #   * can be offset to the left if lower subNodes of right node 
   #     have no overlap with subNodes of left node                                                                                                                                 
   minSpacing        = 2
   rightNodePosition = fn.reduce(lambda r,i: max(r,i[0] + minSpacing + firstRightIndent - i[1]), \
                                 zip(leftLineWidths,rightLineIndents[0:commonLines]), \
                                 firstLeftWidth + minLinkWidth)

   # extend basic link bars (slashes) with underlines to reach left and right
   # top nodes.  
   #
   #        vvvvv
   #       __/ \__
   #      L       R
   #
   linkExtraWidth    = max(0, rightNodePosition - firstLeftWidth - minLinkWidth )
   rightLinkExtra    = linkExtraWidth // 2
   leftLinkExtra     = linkExtraWidth - rightLinkExtra

   # build value line taking into account left indent and link bar extension (on left side)
   valueIndent       = max(0, firstLeftWidth + leftLinkExtra + leftLinkBar - valueOffset)
   valueLine         = " " * max(0,valueIndent) + stringValue
   slash             = "\\" if inverted else  "/"
   backslash         = "/" if inverted else  "\\"
   uLine             = "¯" if inverted else  "_"

   # build left side of link line
   leftLink          = "" if not leftNode else ( " " * firstLeftWidth + uLine * leftLinkExtra + slash)

   # build right side of link line (includes blank spaces under top node value) 
   rightLinkOffset   = linkSpacing + valueOffset * (1 - leftLinkBar)                      
   rightLink         = "" if not rightNode else ( " " * rightLinkOffset + backslash + uLine * rightLinkExtra )

   # full link line (will be empty if there are no sub nodes)                                                                                                    
   linkLine          = leftLink + rightLink

   # will need to offset left side lines if right side sub nodes extend beyond left margin
   # can happen if left subtree is shorter (in height) than right side subtree                                                
   leftIndentWidth   = max(0,firstRightIndent - rightNodePosition) 
   leftIndent        = " " * leftIndentWidth
   indentedLeftLines = [ (leftIndent if line else "") + line for line in leftSubLines ]

   # compute distance between left and right sublines based on their value position
   # can be negative if leading spaces need to be removed from right side
   mergeOffsets      = [ len(line) for line in indentedLeftLines ]
   mergeOffsets      = [ leftIndentWidth + rightNodePosition - firstRightIndent - w for w in mergeOffsets ]
   mergeOffsets      = [ p if rightSubLines[i] else 0 for i,p in enumerate(mergeOffsets) ]

   # combine left and right lines using computed offsets
   #   * indented left sub lines
   #   * spaces between left and right lines
   #   * right sub line with extra leading blanks removed.
   mergedSubLines    = zip(range(len(mergeOffsets)), mergeOffsets, indentedLeftLines)
   mergedSubLines    = [ (i,p,line + (" " * max(0,p)) )       for i,p,line in mergedSubLines ]
   mergedSubLines    = [ line + rightSubLines[i][max(0,-p):]  for i,p,line in mergedSubLines ]                        

   # Assemble final result combining
   #  * node value string
   #  * link line (if any)
   #  * merged lines from left and right sub trees (if any)
   treeLines = [leftIndent + valueLine] + ( [] if not linkLine else [leftIndent + linkLine] ) + mergedSubLines

   # invert final result if requested
   treeLines = reversed(treeLines) if inverted and isTop else treeLines

   # return intermediate tree lines or print final result
   if isTop : print("\n".join(treeLines))
   else     : return treeLines

Here's an example of the kind of output it produces, using a simple TreeNode class.

class TreeNode:

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

   def addValue(self,newValue):
      if newValue == self.value: return self
      if newValue < self.value:
         if self.left : return self.left.addValue(newValue)
         self.left = TreeNode(newValue)
         return self.left
      if self.right : return self.right.addValue(newValue)
      self.right = TreeNode(newValue)
      return self.right

   def printTree(self):
      printBTree(self,lambda n:(str(n.value),n.left,n.right))      

root = TreeNode(80)

root.addValue(50)
root.addValue(90)
root.addValue(10)
root.addValue(60)
root.addValue(30)
root.addValue(70)
root.addValue(55)
root.addValue(5)
root.addValue(35)
root.addValue(85)

root.printTree()

This produces the following output:

#              80
#          ___/  \___
#        50          90
#     __/  \__      /
#   10        60  85
#  /  \      /  \
# 5    30  55    70
#        \
#         35

The function is generic enough to process binary tree structures that are not stored in an object hierarchy. Here's an example of how it can be used to print from a list containing a heap tree:

def printHeapTree(tree, inverted=False):

    def getNode(index):
        left  = index * 2 + 1
        right = index * 2 + 2
        left  = left  if left  < len(tree) and tree[left]  else None
        right = right if right < len(tree) and tree[right] else None
        return (str(tree[index]), left, right)

    printBTree(0,getNode,inverted)


formula = ["+","4","*",None,None,"2","75"]
printHeapTree(formula)

#   +
#  / \
# 4   *
#    / \
#   2   75

The function will automatically adjust the indentations for wider labels :

family = [ "Me","Paul","Rosa","Vincent","Jody","John","Kate"]
printHeapTree(family)

#                Me
#            ___/  \___
#        Paul          Rosa
#        /  \          /  \
# Vincent    Jody  John    Kate

It can also print the tree upside down (as would be appropriate for a family tree):

printHeapTree(family,inverted=True)

# Vincent    Jody  John    Kate
#        \  /          \  /
#        Paul          Rosa
#            ¯¯¯\  /¯¯¯
#                Me

回答2:

Well to begin with you should read PEP8 code convention for python, as it says function, attributes and variables should be in snake_case.

You are printing in an iterative way so that means you just can't print it in an isosceles triangle because you cannot know what is the size of the base (the lowest part of the tree), in an iterative way you should print it like a triangle with 90 degrees angle.

Or you could gather all of the information into a lists or a strings and format that later and print it. Think about the head and then the children with lines between them.

回答3:

A simple and rough one:

from collections import deque
def print_tree(root):
    res = []
    q = deque([root])
    while q:
        row = []
        for _ in range(len(q)):
            node = q.popleft()
            if not node:
                row.append("#")
                continue
            row.append(node.val)
            q.append(node.left)
            q.append(node.right)
        res.append(row)
    rows = len(res)
    base = 2**(rows)
    for r in range(rows):
        for v in res[r]:
            print("." * (base), end = "")
            print(v, end = "")
            print("." * (base - 1), end = "")
        print("|")
        base //= 2

print_tree(root)

来源：https://stackoverflow.com/questions/48850446/how-to-print-a-binary-tree-in-as-a-structure-of-nodes-in-python

标签

python

binary-tree

tree-traversal

How to print a binary tree in as a structure of nodes in Python

这一生的挚爱 — Wed, 13 May 2020 23:19:31 +0000

How to print a binary tree in as a structure of nodes in Python 这一生的挚爱 2020-05-14 07:19:31

问题

I want to print it as follows. How should I go about this? Because the length of the mathematical expressions vary all the time e.g (24 * 2), ((5 - 1) * (2 / 3)), (20 - (5 + 4)) etc

Node("+") #root
    .addkid(Node("*") #right child at level 1
        .addkid(Node("75")) #right child at level 2
        .addkid(Node("2")) #left child at level 2
            )
    .addkid(Node("4")) #left child at level 1

I have worked out the method to print nodes by their levels as in an in-order traversal pattern.If I call the method as follows it will print the following:

pt = buildParseTree("( ( 2 * 74 ) / 4 )")

printNodesInLevels(pt)

output:

/ 
4 * 
2 74

回答1:

Here is a function I created to print any binary tree structure.

It is very generic and only needs a starting node (root) and a function (or lambda) to obtain a label and the left/right children nodes:

You would typically use it like this on your Node class:

printBTree(rootNode,lambda n: (n.operand, n.left, n.right) )

# assuming the Node class has a string property named operand
# and left,right properties that return a Node or None

A quadratic equation (-b +/- sqrt(b**2 - 4*a*c))/(2*a) could then print like this:

#         /
#     ___/ \__
#  +/-        *
#  / \       / \
# -   sqrt  2   a
#  \     \
#   b    -
#     __/ \_
#   **      *
#  /  \    / \
# b    2  4   *
#            / \
#           a   c

Here is the printBTree function :

import functools as fn

def printBTree(node, nodeInfo=None, inverted=False, isTop=True):

   # node value string and sub nodes
   stringValue, leftNode, rightNode = nodeInfo(node)

   stringValueWidth  = len(stringValue)

   # recurse to sub nodes to obtain line blocks on left and right
   leftTextBlock     = [] if not leftNode else printBTree(leftNode,nodeInfo,inverted,False)

   rightTextBlock    = [] if not rightNode else printBTree(rightNode,nodeInfo,inverted,False)

   # count common and maximum number of sub node lines
   commonLines       = min(len(leftTextBlock),len(rightTextBlock))
   subLevelLines     = max(len(rightTextBlock),len(leftTextBlock))

   # extend lines on shallower side to get same number of lines on both sides
   leftSubLines      = leftTextBlock  + [""] *  (subLevelLines - len(leftTextBlock))
   rightSubLines     = rightTextBlock + [""] *  (subLevelLines - len(rightTextBlock))

   # compute location of value or link bar for all left and right sub nodes
   #   * left node's value ends at line's width
   #   * right node's value starts after initial spaces
   leftLineWidths    = [ len(line) for line in leftSubLines  ]                            
   rightLineIndents  = [ len(line)-len(line.lstrip(" ")) for line in rightSubLines ]

   # top line value locations, will be used to determine position of current node & link bars
   firstLeftWidth    = (leftLineWidths   + [0])[0]  
   firstRightIndent  = (rightLineIndents + [0])[0] 

   # width of sub node link under node value (i.e. with slashes if any)
   # aims to center link bars under the value if value is wide enough
   # 
   # ValueLine:    v     vv    vvvvvv   vvvvv
   # LinkLine:    / \   /  \    /  \     / \ 
   #
   linkSpacing       = min(stringValueWidth, 2 - stringValueWidth % 2)
   leftLinkBar       = 1 if leftNode  else 0
   rightLinkBar      = 1 if rightNode else 0
   minLinkWidth      = leftLinkBar + linkSpacing + rightLinkBar
   valueOffset       = (stringValueWidth - linkSpacing) // 2

   # find optimal position for right side top node
   #   * must allow room for link bars above and between left and right top nodes
   #   * must not overlap lower level nodes on any given line (allow gap of minSpacing)
   #   * can be offset to the left if lower subNodes of right node 
   #     have no overlap with subNodes of left node                                                                                                                                 
   minSpacing        = 2
   rightNodePosition = fn.reduce(lambda r,i: max(r,i[0] + minSpacing + firstRightIndent - i[1]), \
                                 zip(leftLineWidths,rightLineIndents[0:commonLines]), \
                                 firstLeftWidth + minLinkWidth)

   # extend basic link bars (slashes) with underlines to reach left and right
   # top nodes.  
   #
   #        vvvvv
   #       __/ \__
   #      L       R
   #
   linkExtraWidth    = max(0, rightNodePosition - firstLeftWidth - minLinkWidth )
   rightLinkExtra    = linkExtraWidth // 2
   leftLinkExtra     = linkExtraWidth - rightLinkExtra

   # build value line taking into account left indent and link bar extension (on left side)
   valueIndent       = max(0, firstLeftWidth + leftLinkExtra + leftLinkBar - valueOffset)
   valueLine         = " " * max(0,valueIndent) + stringValue
   slash             = "\\" if inverted else  "/"
   backslash         = "/" if inverted else  "\\"
   uLine             = "¯" if inverted else  "_"

   # build left side of link line
   leftLink          = "" if not leftNode else ( " " * firstLeftWidth + uLine * leftLinkExtra + slash)

   # build right side of link line (includes blank spaces under top node value) 
   rightLinkOffset   = linkSpacing + valueOffset * (1 - leftLinkBar)                      
   rightLink         = "" if not rightNode else ( " " * rightLinkOffset + backslash + uLine * rightLinkExtra )

   # full link line (will be empty if there are no sub nodes)                                                                                                    
   linkLine          = leftLink + rightLink

   # will need to offset left side lines if right side sub nodes extend beyond left margin
   # can happen if left subtree is shorter (in height) than right side subtree                                                
   leftIndentWidth   = max(0,firstRightIndent - rightNodePosition) 
   leftIndent        = " " * leftIndentWidth
   indentedLeftLines = [ (leftIndent if line else "") + line for line in leftSubLines ]

   # compute distance between left and right sublines based on their value position
   # can be negative if leading spaces need to be removed from right side
   mergeOffsets      = [ len(line) for line in indentedLeftLines ]
   mergeOffsets      = [ leftIndentWidth + rightNodePosition - firstRightIndent - w for w in mergeOffsets ]
   mergeOffsets      = [ p if rightSubLines[i] else 0 for i,p in enumerate(mergeOffsets) ]

   # combine left and right lines using computed offsets
   #   * indented left sub lines
   #   * spaces between left and right lines
   #   * right sub line with extra leading blanks removed.
   mergedSubLines    = zip(range(len(mergeOffsets)), mergeOffsets, indentedLeftLines)
   mergedSubLines    = [ (i,p,line + (" " * max(0,p)) )       for i,p,line in mergedSubLines ]
   mergedSubLines    = [ line + rightSubLines[i][max(0,-p):]  for i,p,line in mergedSubLines ]                        

   # Assemble final result combining
   #  * node value string
   #  * link line (if any)
   #  * merged lines from left and right sub trees (if any)
   treeLines = [leftIndent + valueLine] + ( [] if not linkLine else [leftIndent + linkLine] ) + mergedSubLines

   # invert final result if requested
   treeLines = reversed(treeLines) if inverted and isTop else treeLines

   # return intermediate tree lines or print final result
   if isTop : print("\n".join(treeLines))
   else     : return treeLines

Here's an example of the kind of output it produces, using a simple TreeNode class.

class TreeNode:

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

   def addValue(self,newValue):
      if newValue == self.value: return self
      if newValue < self.value:
         if self.left : return self.left.addValue(newValue)
         self.left = TreeNode(newValue)
         return self.left
      if self.right : return self.right.addValue(newValue)
      self.right = TreeNode(newValue)
      return self.right

   def printTree(self):
      printBTree(self,lambda n:(str(n.value),n.left,n.right))      

root = TreeNode(80)

root.addValue(50)
root.addValue(90)
root.addValue(10)
root.addValue(60)
root.addValue(30)
root.addValue(70)
root.addValue(55)
root.addValue(5)
root.addValue(35)
root.addValue(85)

root.printTree()

This produces the following output:

#              80
#          ___/  \___
#        50          90
#     __/  \__      /
#   10        60  85
#  /  \      /  \
# 5    30  55    70
#        \
#         35

The function is generic enough to process binary tree structures that are not stored in an object hierarchy. Here's an example of how it can be used to print from a list containing a heap tree:

def printHeapTree(tree, inverted=False):

    def getNode(index):
        left  = index * 2 + 1
        right = index * 2 + 2
        left  = left  if left  < len(tree) and tree[left]  else None
        right = right if right < len(tree) and tree[right] else None
        return (str(tree[index]), left, right)

    printBTree(0,getNode,inverted)


formula = ["+","4","*",None,None,"2","75"]
printHeapTree(formula)

#   +
#  / \
# 4   *
#    / \
#   2   75

The function will automatically adjust the indentations for wider labels :

family = [ "Me","Paul","Rosa","Vincent","Jody","John","Kate"]
printHeapTree(family)

#                Me
#            ___/  \___
#        Paul          Rosa
#        /  \          /  \
# Vincent    Jody  John    Kate

It can also print the tree upside down (as would be appropriate for a family tree):

printHeapTree(family,inverted=True)

# Vincent    Jody  John    Kate
#        \  /          \  /
#        Paul          Rosa
#            ¯¯¯\  /¯¯¯
#                Me

回答2:

Well to begin with you should read PEP8 code convention for python, as it says function, attributes and variables should be in snake_case.

Or you could gather all of the information into a lists or a strings and format that later and print it. Think about the head and then the children with lines between them.

回答3:

A simple and rough one:

from collections import deque
def print_tree(root):
    res = []
    q = deque([root])
    while q:
        row = []
        for _ in range(len(q)):
            node = q.popleft()
            if not node:
                row.append("#")
                continue
            row.append(node.val)
            q.append(node.left)
            q.append(node.right)
        res.append(row)
    rows = len(res)
    base = 2**(rows)
    for r in range(rows):
        for v in res[r]:
            print("." * (base), end = "")
            print(v, end = "")
            print("." * (base - 1), end = "")
        print("|")
        base //= 2

print_tree(root)

来源：https://stackoverflow.com/questions/48850446/how-to-print-a-binary-tree-in-as-a-structure-of-nodes-in-python

标签

python

binary-tree

tree-traversal

How to detect circular reference in a Tree?

我的梦境 — Mon, 23 Mar 2020 00:18:05 +0000

How to detect circular reference in a Tree? 我的梦境 2020-03-23 08:18:05

问题

I have a Node class as follows:

public class Node{
    Object data;
    List<Node> children;
}

I need to traverse this tree in post order and I am using Guava TreeTraverser for for the same.

    TreeTraverser<Node> treeTraverser = new TreeTraverser<Node>() {
                @Override
                public Iterable<Node> children(Node node) {
                    return node.children;
                }
            };

treeTraverser.postOrderTraversal(node);

The catch is that there chances that the given tree could have circular dependencies(means it could be a cyclic graph). What would be an efficient way to detect circular dependencies?

回答1:

By definition, a tree is an acyclic connected graph. Therefore, there is no such thing as a tree with circular dependencies.

You can find cycles in a graph by applying depth-first traversal, and looking for nodes that have been visited the way down. If you visit a node that you have seen during prior steps of DFS, the graph is not a tree.

See this Q&A for advanced cycle detection algorithms.

回答2:

In simple words Tree is a non cyclic data structure and when there are cycles then it becomes a Graph.

Above is an example of a graph. You can represent it using Adjacency list or adjacency matrix. You can refer to http://krishnalearnings.blogspot.in/2015/11/basics-of-graph-in-computer-science.html for basics of Graphs.

In the picture above we can represent it as below (In your question, you have used an adjacency list kind of representation).

int[][] graph = {   {0,1,0,0,0,0},
                    {0,0,1,0,0,0},
                    {0,0,0,1,1,0},
                    {0,0,0,0,0,0},
                    {0,0,0,0,0,1},
                    {0,1,0,0,0,0},
                };

1 represents an edge from corresponding row numbered vertex to column numbered vertex.

We can write a simple method to detect the presence of cycle and also print any one cycle in the graph.

static int[] cycleElements;
static int cycleElementIndex = 0;
static boolean cycleFound = false;
static final int NEW = 0;
static final int PUSHED = 1;
static final int POPPED = 2;
public static int findCycle(int[][] graph,int N, int u, int[] states){
    for(int v = 0; v < N; v++){
        if(graph[u][v] == 1){
            if(states[v] == PUSHED){
                // cycle found
                cycleFound = true;
                return v;
            }else if(states[v] == NEW){
                states[v] = PUSHED;
                int poppedVertex = findCycle(graph, N, v, states);
                states[v] = POPPED;
                if(cycleFound){
                    if(poppedVertex == u){
                        cycleElements[cycleElementIndex++] = v;
                        cycleElements[cycleElementIndex++] = u;
                        cycleFound = false;
                    }else{
                        cycleElements[cycleElementIndex++] = v;
                        return poppedVertex;
                    }
                }
            }
        }
    }
    return -1;
}
public static void main(String[] args) {
    int N = 6;
    int[][] graph = {   {0,1,0,0,0,0},
                        {0,0,1,0,0,0},
                        {0,0,0,1,1,0},
                        {0,0,0,0,0,0},
                        {0,0,0,0,0,1},
                        {0,1,0,0,0,0},
                    };
    cycleElements = new int[N];
    int[] states = new int[N];
    states[0] = PUSHED;
    findCycle(graph,N,0,states);
    for(int i = 0; i < cycleElementIndex; i++){
        System.out.println(cycleElements[i]);
    }
}

You can easily transform above approach to adjacency list if you wish, though representation does not matter much ( only adjacency list may save your space as compared to adjacency matrix)

来源：https://stackoverflow.com/questions/37907339/how-to-detect-circular-reference-in-a-tree

标签

How to detect circular reference in a Tree?

人走茶凉 — Mon, 23 Mar 2020 00:18:02 +0000

How to detect circular reference in a Tree? 人走茶凉 2020-03-23 08:18:02

问题

I have a Node class as follows:

public class Node{
    Object data;
    List<Node> children;
}

I need to traverse this tree in post order and I am using Guava TreeTraverser for for the same.

    TreeTraverser<Node> treeTraverser = new TreeTraverser<Node>() {
                @Override
                public Iterable<Node> children(Node node) {
                    return node.children;
                }
            };

treeTraverser.postOrderTraversal(node);

The catch is that there chances that the given tree could have circular dependencies(means it could be a cyclic graph). What would be an efficient way to detect circular dependencies?

回答1:

By definition, a tree is an acyclic connected graph. Therefore, there is no such thing as a tree with circular dependencies.

See this Q&A for advanced cycle detection algorithms.

回答2:

In simple words Tree is a non cyclic data structure and when there are cycles then it becomes a Graph.

In the picture above we can represent it as below (In your question, you have used an adjacency list kind of representation).

int[][] graph = {   {0,1,0,0,0,0},
                    {0,0,1,0,0,0},
                    {0,0,0,1,1,0},
                    {0,0,0,0,0,0},
                    {0,0,0,0,0,1},
                    {0,1,0,0,0,0},
                };

1 represents an edge from corresponding row numbered vertex to column numbered vertex.

We can write a simple method to detect the presence of cycle and also print any one cycle in the graph.

static int[] cycleElements;
static int cycleElementIndex = 0;
static boolean cycleFound = false;
static final int NEW = 0;
static final int PUSHED = 1;
static final int POPPED = 2;
public static int findCycle(int[][] graph,int N, int u, int[] states){
    for(int v = 0; v < N; v++){
        if(graph[u][v] == 1){
            if(states[v] == PUSHED){
                // cycle found
                cycleFound = true;
                return v;
            }else if(states[v] == NEW){
                states[v] = PUSHED;
                int poppedVertex = findCycle(graph, N, v, states);
                states[v] = POPPED;
                if(cycleFound){
                    if(poppedVertex == u){
                        cycleElements[cycleElementIndex++] = v;
                        cycleElements[cycleElementIndex++] = u;
                        cycleFound = false;
                    }else{
                        cycleElements[cycleElementIndex++] = v;
                        return poppedVertex;
                    }
                }
            }
        }
    }
    return -1;
}
public static void main(String[] args) {
    int N = 6;
    int[][] graph = {   {0,1,0,0,0,0},
                        {0,0,1,0,0,0},
                        {0,0,0,1,1,0},
                        {0,0,0,0,0,0},
                        {0,0,0,0,0,1},
                        {0,1,0,0,0,0},
                    };
    cycleElements = new int[N];
    int[] states = new int[N];
    states[0] = PUSHED;
    findCycle(graph,N,0,states);
    for(int i = 0; i < cycleElementIndex; i++){
        System.out.println(cycleElements[i]);
    }
}

You can easily transform above approach to adjacency list if you wish, though representation does not matter much ( only adjacency list may save your space as compared to adjacency matrix)

来源：https://stackoverflow.com/questions/37907339/how-to-detect-circular-reference-in-a-tree

标签

Inorder tree traversal: Which definition is correct?

假装没事ソ — Mon, 20 Jan 2020 06:22:42 +0000

Inorder tree traversal: Which definition is correct? 假装没事ソ 2020-01-20 14:22:42

问题

I have the following text from an academic course I took a while ago about inorder traversal (they also call it pancaking) of a binary tree (not BST):

Inorder tree traversal

Draw a line around the outside of the tree. Start to the left of the root, and go around the outside of the tree, to end up to the right of the root. Stay as close to the tree as possible, but do not cross the tree. (Think of the tree — its branches and nodes — as a solid barrier.) The order of the nodes is the order in which this line passes underneath them. If you are unsure as to when you go “underneath” a node, remember that a node “to the left” always comes first.

Here's the example used (slightly different tree from below)

However when I do a search on google, I get a conflicting definition. For example the wikipedia example:

Inorder traversal sequence: A, B, C, D, E, F, G, H, I (leftchild,rootnode,right node)

But according to (my understanding of) definition #1, this should be

A, B, D, C, E, F, G, I, H

Can anyone clarify which definition is correct? They might be both describing different traversal methods, but happen to be using the same name. I'm having trouble believing the peer-reviewed academic text is wrong, but can't be certain.

回答1:

In my bad attempt at the drawing here's the order that shows how they should be picked.

pretty much pick the node that is directly above the line being drawn,.

回答2:

Forget the definitions, it's so much easier to just apply the algorithm:

void inOrderPrint(Node root)
{
  if (root.left != null) inOrderPrint(root.left);
  print(root.name);
  if (root.right != null) inOrderPrint(root.right);
}

It's just three lines. Rearrange the order for pre- and post- order.

回答3:

If you read carefully you see that the first "definition" says to start left of the root and that the order of the nodes is determined by when you pass under them. So B is not the first node, as you pass it from the left on the way to A, then first pass under A after which you go up and pass under B. Therefore it seems that both definitions give the same result.

回答4:

I personally found this lecture quite helpful.

回答5:

Both definitions give the same result. Don't be fooled by the letters in the first example - look at the numbers along the path. The second example does use letters to denote the path - perhaps that is what is throwing you off.

For example, in your example order showing how you thought the second tree would be traversed using the algorithm of the first one, you place "D" after "B" but you shouldn't because there is still a left-hand child node of D available (that's why the first item says "the order in which this line passes underneath them."

回答6:

this may be late but it could be useful for anyone later .. u just need not to ignore the dummy or null nodes e.g the Node G has a left null node .. considering this null node will make every thing alright ..

回答7:

The proper traversal would be: as far left as possible with leaf nodes (not root nodes)

Left Root Right

A B NULL

C D E

Null F G

H I NULL

F is root or left, i am not sure

回答8:

I think the first binary tree with the root of a is a Binary tree which is not correctly constructed.

Try to implement so that all the left side of the tree is less than the root and all the right side of the tree is greater than or equal to the root.

回答9:

But according to (my understanding of) definition #1, this should be
A, B, D, C, E, F, G, I, H

Unfortunately, your understanding is wrong.

Whenever you arrive at a node, you must descend to an available left node, before you look at the current node, then you look at an available right node. When you chose D before C, you didn't descend to the left node first.

回答10:

Hey according to me as mentioned in wiki is correct the sequence for a inorder traversal is left-root-right.

Till A, B, C, D, E, F i think you have understood already. Now after root F the next node is G that doesn't hav a left node but a right node so as per the rule (left-root-right) its null-g-right. Now I is the right node of G but I has a left node hence the traversal would be GHI. This is correct.

Hope this helps.

回答11:

For an inline tree traversal you have to keep in mind that the order of traversal is left-node-right. For the above diagram that you are conflicted on, your error occurs when you read a parent node before reading any leaf(children) nodes to the left.

The proper traversal would be: as far left as possible with leaf nodes(A), return to parent node(B), move to the right, but since D has a child to its left you move down again(C), back up to C's parent(D), to D's right child(E), reverse back to the root(F), move to the right leaf(G), move to G's leaf but since it has a left leaf node move there(H), return to parent(I).

the above traversal reads the node when I have it listed in parenthesis.

回答12:

package datastructure;

public class BinaryTreeTraversal {

public static Node<Integer> node;

public static Node<Integer> sortedArrayToBST(int arr[], int start, int end) {
    if (start > end)
        return null;

    int mid = start + (end - start) / 2;
    Node<Integer> node = new Node<Integer>();
    node.setValue(arr[mid]);

    node.left = sortedArrayToBST(arr, start, mid - 1);
    node.right = sortedArrayToBST(arr, mid + 1, end);
    return node;
}

public static void main(String[] args) {

    int[] test = new int[] { 1, 2, 3, 4, 5, 6, 7 };
    Node<Integer> node = sortedArrayToBST(test, 0, test.length - 1);

    System.out.println("preOrderTraversal >> ");

    preOrderTraversal(node);

    System.out.println("");

    System.out.println("inOrderTraversal >> ");

    inOrderTraversal(node);

    System.out.println("");

    System.out.println("postOrderTraversal >> ");

    postOrderTraversal(node);

}

public static void preOrderTraversal(Node<Integer> node) {

    if (node != null) {

        System.out.print(" " + node.toString());
        preOrderTraversal(node.left);
        preOrderTraversal(node.right);
    }

}

public static void inOrderTraversal(Node<Integer> node) {

    if (node != null) {

        inOrderTraversal(node.left);
        System.out.print(" " + node.toString());
        inOrderTraversal(node.right);
    }

}

public static void postOrderTraversal(Node<Integer> node) {

    if (node != null) {

        postOrderTraversal(node.left);

        postOrderTraversal(node.right);

        System.out.print(" " + node.toString());
    }

}

}

package datastructure;

public class Node {

E value = null;
Node<E> left;
Node<E> right;

public E getValue() {
    return value;
}

public void setValue(E value) {
    this.value = value;
}

public Node<E> getLeft() {
    return left;
}

public void setLeft(Node<E> left) {
    this.left = left;
}

public Node<E> getRight() {
    return right;
}

public void setRight(Node<E> right) {
    this.right = right;
}

@Override
public String toString() {
    return " " +value;
}

}

preOrderTraversal >> 4 2 1 3 6 5 7 inOrderTraversal >> 1 2 3 4 5 6 7 postOrderTraversal >> 1 3 2 5 7 6 4

回答13:

void
inorder (NODE root)
{
  if (root != NULL)
    {
      inorder (root->llink);
      printf ("%d\t", root->info);
      inorder (root->rlink);
    }
}

This the most simplest approach to recursive definition of in-order traversal, just call this function in the main function to get the in-order traversal of a given binary tree.

回答14:

It is correct for preorder,nt for inorder

来源：https://stackoverflow.com/questions/486039/inorder-tree-traversal-which-definition-is-correct

标签

data-structures

binary-tree

tree-traversal

Inorder tree traversal: Which definition is correct?

。_饼干妹妹 — Mon, 20 Jan 2020 06:22:19 +0000

Inorder tree traversal: Which definition is correct? 。_饼干妹妹 2020-01-20 14:22:19

问题

I have the following text from an academic course I took a while ago about inorder traversal (they also call it pancaking) of a binary tree (not BST):

Inorder tree traversal

Draw a line around the outside of the tree. Start to the left of the root, and go around the outside of the tree, to end up to the right of the root. Stay as close to the tree as possible, but do not cross the tree. (Think of the tree — its branches and nodes — as a solid barrier.) The order of the nodes is the order in which this line passes underneath them. If you are unsure as to when you go “underneath” a node, remember that a node “to the left” always comes first.

Here's the example used (slightly different tree from below)

However when I do a search on google, I get a conflicting definition. For example the wikipedia example:

Inorder traversal sequence: A, B, C, D, E, F, G, H, I (leftchild,rootnode,right node)

But according to (my understanding of) definition #1, this should be

A, B, D, C, E, F, G, I, H

回答1:

In my bad attempt at the drawing here's the order that shows how they should be picked.

pretty much pick the node that is directly above the line being drawn,.

回答2:

Forget the definitions, it's so much easier to just apply the algorithm:

void inOrderPrint(Node root)
{
  if (root.left != null) inOrderPrint(root.left);
  print(root.name);
  if (root.right != null) inOrderPrint(root.right);
}

It's just three lines. Rearrange the order for pre- and post- order.

回答3:

回答4:

I personally found this lecture quite helpful.

回答5:

回答6:

回答7:

The proper traversal would be: as far left as possible with leaf nodes (not root nodes)

Left Root Right

A B NULL

C D E

Null F G

H I NULL

F is root or left, i am not sure

回答8:

I think the first binary tree with the root of a is a Binary tree which is not correctly constructed.

Try to implement so that all the left side of the tree is less than the root and all the right side of the tree is greater than or equal to the root.

回答9:

But according to (my understanding of) definition #1, this should be
A, B, D, C, E, F, G, I, H

Unfortunately, your understanding is wrong.

回答10:

Hey according to me as mentioned in wiki is correct the sequence for a inorder traversal is left-root-right.

Hope this helps.

回答11:

the above traversal reads the node when I have it listed in parenthesis.

回答12:

package datastructure;

public class BinaryTreeTraversal {

public static Node<Integer> node;

public static Node<Integer> sortedArrayToBST(int arr[], int start, int end) {
    if (start > end)
        return null;

    int mid = start + (end - start) / 2;
    Node<Integer> node = new Node<Integer>();
    node.setValue(arr[mid]);

    node.left = sortedArrayToBST(arr, start, mid - 1);
    node.right = sortedArrayToBST(arr, mid + 1, end);
    return node;
}

public static void main(String[] args) {

    int[] test = new int[] { 1, 2, 3, 4, 5, 6, 7 };
    Node<Integer> node = sortedArrayToBST(test, 0, test.length - 1);

    System.out.println("preOrderTraversal >> ");

    preOrderTraversal(node);

    System.out.println("");

    System.out.println("inOrderTraversal >> ");

    inOrderTraversal(node);

    System.out.println("");

    System.out.println("postOrderTraversal >> ");

    postOrderTraversal(node);

}

public static void preOrderTraversal(Node<Integer> node) {

    if (node != null) {

        System.out.print(" " + node.toString());
        preOrderTraversal(node.left);
        preOrderTraversal(node.right);
    }

}

public static void inOrderTraversal(Node<Integer> node) {

    if (node != null) {

        inOrderTraversal(node.left);
        System.out.print(" " + node.toString());
        inOrderTraversal(node.right);
    }

}

public static void postOrderTraversal(Node<Integer> node) {

    if (node != null) {

        postOrderTraversal(node.left);

        postOrderTraversal(node.right);

        System.out.print(" " + node.toString());
    }

}

}

package datastructure;

public class Node {

E value = null;
Node<E> left;
Node<E> right;

public E getValue() {
    return value;
}

public void setValue(E value) {
    this.value = value;
}

public Node<E> getLeft() {
    return left;
}

public void setLeft(Node<E> left) {
    this.left = left;
}

public Node<E> getRight() {
    return right;
}

public void setRight(Node<E> right) {
    this.right = right;
}

@Override
public String toString() {
    return " " +value;
}

}

preOrderTraversal >> 4 2 1 3 6 5 7 inOrderTraversal >> 1 2 3 4 5 6 7 postOrderTraversal >> 1 3 2 5 7 6 4

回答13:

void
inorder (NODE root)
{
  if (root != NULL)
    {
      inorder (root->llink);
      printf ("%d\t", root->info);
      inorder (root->rlink);
    }
}

This the most simplest approach to recursive definition of in-order traversal, just call this function in the main function to get the in-order traversal of a given binary tree.

回答14:

It is correct for preorder,nt for inorder

来源：https://stackoverflow.com/questions/486039/inorder-tree-traversal-which-definition-is-correct

标签

data-structures

binary-tree

tree-traversal