Postfix calculator

Author: geeknat

3_double_linkedlists.go

@@ -0,0 +1,83 @@
+// Implementing a DoubleLinkedList data structure in go
+// We'll implement Append, Prepend and Remove methods
+// of a typical DoubleLinkedList
+
+
+package main
+
+import (
+"errors"
+)
+
+// LinkedList represents our list with it's properties
+type DoubleLinkedList struct {
+Head *DoubleNode
+Tail *DoubleNode
+Length int
+}
+
+// Append adds a node to the end of the list
+func (list *DoubleLinkedList) Append(newNode *DoubleNode) {
+
+if list.Length == 0 {
+list.Head = newNode
+list.Tail = newNode
+} else {
+lastNode := list.Tail
+
+lastNode.Next = newNode
+newNode.Before = lastNode
+
+list.Tail = newNode
+}
+
+list.Length++
+
+}
+
+// Prepend adds a node to the start of the list
+func (list *DoubleLinkedList) Prepend(newNode *DoubleNode) {
+
+if list.Length == 0 {
+list.Head = newNode
+list.Tail = newNode
+} else {
+firstNode := list.Head
+list.Head = newNode
+newNode.Next = firstNode
+}
+
+list.Length++
+
+}
+
+// Remove removes a node from the list
+// This has to iterate through the whole list
+// to try find the node to remove
+// Can be performance costly with large lists
+// You might choose to use Arrays in this case
+// where we can identify an element by Index
+
+func (list *DoubleLinkedList) Remove(node *DoubleNode) {
+
+if list.Length == 0 {
+panic(errors.New("cannot remove element on an empty list"))
+}
+
+var previousPost *DoubleNode
+currentPost := list.Head
+
+for currentPost.Value != node.Value {
+if currentPost.Next == nil {
+panic(errors.New("no such element found with value"))
+}
+
+previousPost = currentPost
+currentPost = currentPost.Next
+}
+
+previousPost.Next = currentPost.Next
+
+list.Length--
+
+}

3_postfix_calculator.go

@@ -0,0 +1,64 @@
+package main
+
+import "C"
+import (
+"fmt"
+"time"
+)
+
+// Implementing a PostFix calculator in Go
+
+func PostFixCalculator(container Container) int {
+
+var emptyStack Container
+
+t1 := time.Now().Unix()
+
+for _, item := range container.items {
+
+switch v := item.(type) {
+default:
+fmt.Printf("unexpected type %T", v)
+case int:
+
+//push it into the stack
+emptyStack.Push(item)
+
+case string:
+
+rightValue := emptyStack.Pop()
+leftValue := emptyStack.Pop()
+
+result := 0
+
+if item.(string) == "+" {
+result = leftValue.(int) + rightValue.(int)
+}
+
+if item.(string) == "*" {
+result = leftValue.(int) * rightValue.(int)
+}
+
+if item.(string) == "-" {
+result = leftValue.(int) - rightValue.(int)
+}
+
+if item.(string) == "%" {
+result = leftValue.(int) % rightValue.(int)
+}
+
+fmt.Println(leftValue, rightValue, item, result)
+
+emptyStack.Push(result)
+}
+
+}
+
+t2 := time.Now().Unix()
+
+elapsedTime := t2 - t1
+
+fmt.Println("Finished in seconds", elapsedTime)
+
+return emptyStack.Peek().(int)
+}

main.go

@@ -1,12 +1,23 @@
 // Run examples here
 package main
 
-import "fmt"
+import (
+"fmt"
+)
 
 func main() {
 
-stackExample()
+container := Container{}
+stack := container.NewContainer()
+stack.Push(5)
+stack.Push(6)
+stack.Push(7)
+stack.Push("*")
+stack.Push("+")
+stack.Push(1)
+stack.Push("-")
 
+fmt.Println(PostFixCalculator(container))
 }
 
 func stackExample() {