optimizing the array stack to shrink array by factor of 1.5, now array stack is faster than linked list stack

stacks/arraystack/arraystack.go

@@ -17,7 +17,6 @@ with this distribution for more information.
 */
 
 // Implementation of stack using a slice.
-// Use LinkedListStack rather than this Arraystack, because LinkedListStack is a lot faster more memory efficient.
 // Structure is not thread safe.
 // References: http://en.wikipedia.org/wiki/Stack_%28abstract_data_type%29
 
@@ -35,26 +34,37 @@ func assertInterfaceImplementation() {
 
 type Stack struct {
 	items []interface{}
+	top   int
 }
 
 // Instantiates a new empty stack
 func New() *Stack {
-	return &Stack{}
+	return &Stack{top: -1}
 }
 
 // Pushes a value onto the top of the stack
 func (stack *Stack) Push(value interface{}) {
-	stack.items = append(stack.items, value)
+	// Increase when capacity is reached by a factor of 1.5 and add one so it grows when size is zero
+	if stack.top+1 >= cap(stack.items) {
+		currentSize := len(stack.items)
+		sizeIncrease := int(1.5*float32(currentSize) + 1.0)
+		newSize := currentSize + sizeIncrease
+		newItems := make([]interface{}, newSize, newSize)
+		copy(newItems, stack.items)
+		stack.items = newItems
+	}
+	stack.top += 1
+	stack.items[stack.top] = value
 }
 
 // Pops (removes) top element on stack and returns it, or nil if stack is empty.
 // Second return parameter is true, unless the stack was empty and there was nothing to pop.
 func (stack *Stack) Pop() (value interface{}, ok bool) {
-	size := len(stack.items)
-	if size > 0 {
-		value = stack.items[size-1]
-		stack.items = append([]interface{}(nil), stack.items[:size-1]...)
-		return value, true
+	if stack.top >= 0 {
+		value, ok = stack.items[stack.top], true
+		// TODO shrink slice at some point
+		stack.top -= 1
+		return
 	}
 	return nil, false
 }
@@ -62,21 +72,20 @@ func (stack *Stack) Pop() (value interface{}, ok bool) {
 // Returns top element on the stack without removing it, or nil if stack is empty.
 // Second return parameter is true, unless the stack was empty and there was nothing to peek.
 func (stack *Stack) Peek() (value interface{}, ok bool) {
-	size := len(stack.items)
-	if size > 0 {
-		return stack.items[size-1], true
+	if stack.top >= 0 {
+		return stack.items[stack.top], true
 	}
 	return nil, false
 }
 
 // Returns true if stack does not contain any elements.
 func (stack *Stack) Empty() bool {
-	return len(stack.items) == 0
+	return stack.Size() == 0
 }
 
 // Returns number of elements within the stack.
 func (stack *Stack) Size() int {
-	return len(stack.items)
+	return stack.top + 1
 }
 
 func (stack *Stack) String() string {