From ce7b0267c3bac5674395b9a74feb11f83fd0e111 Mon Sep 17 00:00:00 2001 From: Adriana Date: Fri, 24 Jun 2016 12:49:05 -0700 Subject: [PATCH 1/6] updated readme --- README.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index 26e9c38..de2a21d 100644 --- a/README.md +++ b/README.md @@ -1,11 +1,11 @@ # Tree Practice ## Creating a binary tree on paper -On paper, create a binary search tree to represent the expressions below. -1. `3 + 2` -2. `3 + 2 - 10` -3. `4 * 3 + 2` -4. `4 * 3 + 2 - 10 % 5` +On paper, create a binary expression tree to represent the expressions below. +1. `3 + 2` +2. `3 + 2 - 10` +3. `4 * 3 + 2` +4. `4 * 3 + 2 - 10 % 5` ## Creating a binary manually tree with nodes 1. Take a look at [`tree-practice.rb`](tree-practice.rb) From 98fa7228f6882fc9202b61df3d9d7ff201d5895e Mon Sep 17 00:00:00 2001 From: Adriana Date: Fri, 24 Jun 2016 12:49:29 -0700 Subject: [PATCH 2/6] updated readme --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index de2a21d..d9dc757 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,7 @@ # Tree Practice ## Creating a binary tree on paper -On paper, create a binary expression tree to represent the expressions below. +On paper, create a binary expression tree to represent the expressions below. 1. `3 + 2` 2. `3 + 2 - 10` 3. `4 * 3 + 2` From b5632f1556eb9432af31c2328dd28015dd987134 Mon Sep 17 00:00:00 2001 From: Adriana Date: Sat, 25 Jun 2016 13:32:59 -0700 Subject: [PATCH 3/6] Added operators print and did all the infix print --- tree-practice.rb | 55 +++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 54 insertions(+), 1 deletion(-) diff --git a/tree-practice.rb b/tree-practice.rb index 6b10248..63538da 100644 --- a/tree-practice.rb +++ b/tree-practice.rb @@ -15,7 +15,60 @@ def print_infix(node) print_infix(node.right) end +def operators(node) + return if node == nil + operators(node.left) + if node.left != nil && node.right != nil + print node.value + " " + end + operators(node.right) +end + root = TreeNode.new("+") root.left = TreeNode.new("3") root.right = TreeNode.new("2") -print_infix(root) +puts print_infix(root) +puts operators(root) + +root2 = TreeNode.new("-") +root2.left = TreeNode.new("+") +root2.left.left = TreeNode.new("3") +root2.left.right = TreeNode.new("2") +root2.right = TreeNode.new("10") +puts print_infix(root2) +puts operators(root2) + +root3 = TreeNode.new("+") +root3.left = TreeNode.new("*") +root3.left.left = TreeNode.new("4") +root3.left.right = TreeNode.new("3") +root3.right = TreeNode.new("2") +puts print_infix(root3) +puts operators(root3) + +root4 = TreeNode.new("-") +root4.left = TreeNode.new("+") +root4.left.right = TreeNode.new("2") +root4.left.left = TreeNode.new("*") +root4.left.left.left = TreeNode.new("4") +root4.left.left.right = TreeNode.new("3") +root4.right = TreeNode.new("%") +root4.right.left = TreeNode.new("10") +root4.right.right = TreeNode.new("5") +puts print_infix(root4) +puts operators(root4) + + + + + + + + + + + + + + +# From 39c2739e11aaec690f9d0b3ce9517fb67dd3cf90 Mon Sep 17 00:00:00 2001 From: Adriana Date: Sun, 26 Jun 2016 20:55:14 -0700 Subject: [PATCH 4/6] Added in some leaf methods and started on prefix and postfix --- tree-practice.rb | 75 +++++++++++++++++++++++++++++++++++++----------- 1 file changed, 59 insertions(+), 16 deletions(-) diff --git a/tree-practice.rb b/tree-practice.rb index 63538da..be00b68 100644 --- a/tree-practice.rb +++ b/tree-practice.rb @@ -15,20 +15,61 @@ def print_infix(node) print_infix(node.right) end +def print_postfix(node) + return if node == nil + print_postfix(node.left) + if node.left == nil || node.right == nil + print node.value + " " + end + if node.left != nil || node.right != nil + print node.value + " " + end + print_postfix(node.right) +end + +def print_prefix(node) + return if node == nil + print_prefix(node.left) + print node.value + " " + print_prefix(node.right) +end + def operators(node) return if node == nil operators(node.left) - if node.left != nil && node.right != nil + if node.left != nil || node.right != nil print node.value + " " end operators(node.right) end +def operator_2(node, operands = nil) + return if node == nil + operands = [] + operator_2(node.left, operands) + if node.left != nil || node.right != nil + operands << node.value + print operands.join + " " + end + operator_2(node.right, operands) +end + +def leaf(node, counter = 0) + return counter if node == nil + counter = leaf(node.left, counter) + if node.left == nil && node.right == nil + counter += 1 + end + leaf(node.right, counter) +end + root = TreeNode.new("+") root.left = TreeNode.new("3") root.right = TreeNode.new("2") puts print_infix(root) puts operators(root) +puts leaf(root) +puts print_postfix(root) root2 = TreeNode.new("-") root2.left = TreeNode.new("+") @@ -37,6 +78,8 @@ def operators(node) root2.right = TreeNode.new("10") puts print_infix(root2) puts operators(root2) +puts leaf(root2) +puts print_postfix(root) root3 = TreeNode.new("+") root3.left = TreeNode.new("*") @@ -45,6 +88,7 @@ def operators(node) root3.right = TreeNode.new("2") puts print_infix(root3) puts operators(root3) +puts leaf(root3) root4 = TreeNode.new("-") root4.left = TreeNode.new("+") @@ -57,18 +101,17 @@ def operators(node) root4.right.right = TreeNode.new("5") puts print_infix(root4) puts operators(root4) - - - - - - - - - - - - - - -# +puts leaf(root4) + +root5 = TreeNode.new("-") +root5.left = TreeNode.new("-") +root5.left.right = TreeNode.new("2") +root5.left.left = TreeNode.new("*") +root5.left.left.left = TreeNode.new("4") +root5.left.left.right = TreeNode.new("3") +root5.right = TreeNode.new("*") +root5.right.left = TreeNode.new("10") +root5.right.right = TreeNode.new("5") +puts print_infix(root5) +puts operator_2(root5) +puts leaf(root5) From b22fda9b827c850958da83c3293883411480d668 Mon Sep 17 00:00:00 2001 From: Adriana Date: Sun, 26 Jun 2016 21:08:05 -0700 Subject: [PATCH 5/6] finished postfix and prefix methods --- tree-practice.rb | 33 +++++++++++++++------------------ 1 file changed, 15 insertions(+), 18 deletions(-) diff --git a/tree-practice.rb b/tree-practice.rb index be00b68..ae43522 100644 --- a/tree-practice.rb +++ b/tree-practice.rb @@ -18,19 +18,14 @@ def print_infix(node) def print_postfix(node) return if node == nil print_postfix(node.left) - if node.left == nil || node.right == nil - print node.value + " " - end - if node.left != nil || node.right != nil - print node.value + " " - end print_postfix(node.right) + print node.value + " " end def print_prefix(node) return if node == nil - print_prefix(node.left) print node.value + " " + print_prefix(node.left) print_prefix(node.right) end @@ -43,16 +38,16 @@ def operators(node) operators(node.right) end -def operator_2(node, operands = nil) - return if node == nil - operands = [] - operator_2(node.left, operands) - if node.left != nil || node.right != nil - operands << node.value - print operands.join + " " - end - operator_2(node.right, operands) -end +# def operator_2(node, operands = nil) +# return if node == nil +# operands = [] +# operator_2(node.left, operands) +# if node.left != nil || node.right != nil +# operands << node.value +# print operands.join + " " +# end +# operator_2(node.right, operands) +# end def leaf(node, counter = 0) return counter if node == nil @@ -70,6 +65,7 @@ def leaf(node, counter = 0) puts operators(root) puts leaf(root) puts print_postfix(root) +puts print_prefix(root) root2 = TreeNode.new("-") root2.left = TreeNode.new("+") @@ -79,7 +75,8 @@ def leaf(node, counter = 0) puts print_infix(root2) puts operators(root2) puts leaf(root2) -puts print_postfix(root) +puts print_postfix(root2) +puts print_prefix(root2) root3 = TreeNode.new("+") root3.left = TreeNode.new("*") From f07b803b91c3a3a30d4ef30bdef8a1cc854471e3 Mon Sep 17 00:00:00 2001 From: Adriana Date: Sun, 26 Jun 2016 21:20:18 -0700 Subject: [PATCH 6/6] Added a counter for the 4th problem to return how many times a certain operator is found in a method --- tree-practice.rb | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/tree-practice.rb b/tree-practice.rb index ae43522..25f1415 100644 --- a/tree-practice.rb +++ b/tree-practice.rb @@ -49,6 +49,15 @@ def operators(node) # operator_2(node.right, operands) # end +def exist(node, operator, counter = 0) + return counter if node == nil + counter = exist(node.left, operator, counter) + if node.value == operator + counter += 1 + end + exist(node.right, operator, counter) +end + def leaf(node, counter = 0) return counter if node == nil counter = leaf(node.left, counter) @@ -66,6 +75,7 @@ def leaf(node, counter = 0) puts leaf(root) puts print_postfix(root) puts print_prefix(root) +puts "exist for root" + exist(root, "+").to_s root2 = TreeNode.new("-") root2.left = TreeNode.new("+") @@ -77,6 +87,7 @@ def leaf(node, counter = 0) puts leaf(root2) puts print_postfix(root2) puts print_prefix(root2) +puts "exist for root" + exist(root2, "+").to_s root3 = TreeNode.new("+") root3.left = TreeNode.new("*") @@ -110,5 +121,6 @@ def leaf(node, counter = 0) root5.right.left = TreeNode.new("10") root5.right.right = TreeNode.new("5") puts print_infix(root5) -puts operator_2(root5) +# puts operator_2(root5) puts leaf(root5) +puts exist(root5, "-")