Simon Wacker

Inspired by a tutorial about datastructures on javarworld.com from Jeff Friesen (good tutorial, worth reading), I wrote this little piece of code.
It isn’t useful at all because flash already has an Array class. But I think it’s interesting to see how these things, I expected always as normal, really work.

What you need are 4 classes named: ArrayStack, Node, EmptyStackException, FullStackException and 1 interface class named: Stack.

The ArrayStack.as file must be in one folder together with the Node.as file. That folder must contain two other folders named: Exception and SuperClasses.
The Exception folder contains the EmptyStackException.as file and the FullStackException.as file.
The SuperClasses folder contains the Stack.as file.

interface SuperClasses.Stack{
        public function isEmpty():Boolean;
        public function peek():Node;
        public function push(anObject:Node):Void;
        public function pop():Node;
        public function shift():Node;
        public function unshift(aNode:Node):Void;
        public function getNodeByNumber(aNumber:Number):Node
}

class Node{
        public var name:String;
        public var next:Node;
        public var prev:Node;

        public function Node(aName:String){
                name = aName;
        }
}

import SuperClasses.*
import Exceptions.*

class ArrayStack implements Stack{
        private var numbersOfElements:Number = -1;
        private var maxElements:Number = -1;
        private var topForward:Node;
        private var topBackward:Node;

        public function ArrayStack(mElements:Number){
                maxElements = mElements;
        }
        public function isEmpty():Boolean{
                return numbersOfElements < 0;
        }
        public function peek():Node{
                if(numbersOfElements < 0){
                        throw new EmptyStackException();
                }
                return topBackward;
        }
        public function push(aNode:Node):Void{
                if(numbersOfElements >= maxElements){
                        throw new FullStackException();
                }
                if(numbersOfElements == -1){
                        topForward = aNode;
                } else {
                        aNode.next = null;
                        aNode.prev = topBackward;
                        topBackward.next = aNode;
                }
                topBackward = aNode;
                numbersOfElements++;
        }
        public function pop():Node{
                if(numbersOfElements < 0){
                        throw new EmptyStackException();
                }
                numbersOfElements–;
                var temp:Node = topBackward;
                topBackward = topBackward.prev;
                return temp;
        }
        public function unshift(aNode:Node):Void{
                if(numbersOfElements >= maxElements){
                        throw new FullStackException();
                }
                if(numbersOfElements == -1){
                        topBackward = aNode;
                } else {
                        aNode.next = topForward;
                        aNode.prev = null;
                        topForward.prev = aNode;
                }
                topForward = aNode;
                numbersOfElements++;
        }
        public function shift():Node{
                if(numbersOfElements < 0){
                        throw new EmptyStackException();
                }
                numbersOfElements–;
                var temp:Node = topForward;
                topForward = topForward.next;
                return temp;
        }
        public function getNodeByNumber(aNumber:Number):Node{
                if(numbersOfElements < 0){
                        throw new EmptyStackException();
                }
                if(maxElements < aNumber){
                        throw new Error(”The number passed as an argument is too big!“);
                }
                var i:Number = 0;
                var temp:Node = topForward;
                while(i++ < aNumber){
                        temp = temp.next;
                }
                return temp;
        }
}

class Exceptions.EmptyStackException extends Error{
        var message = “The stack is already empty!“;
}

class Exceptions.FullStackException extends Error{
        var message = “The stack is already full!“;
}

// usage:
var arr:ArrayStack = new ArrayStack(3);
arr.push(new Node(”A“));
arr.push(new Node(”B“));
arr.push(new Node(”C“));
arr.push(new Node(”D“));
// arr.push(new Node(”E”));
// This additional function call would end the script because of an error.
// The ArrayStack is full.

trace(”function: getNodeByNumber“);

trace(arr.getNodeByNumber(0).name);
trace(arr.getNodeByNumber(1).name);
trace(arr.getNodeByNumber(2).name);
trace(arr.getNodeByNumber(3).name);
// trace(arr.getNodeByNumber(4).name);
// This additional function call would force the script to stop.
// The number is bigger than the maxElements number.

trace(”——————————“);
trace(”function: pop“);

trace(arr.pop().name);
trace(arr.pop().name);
trace(arr.pop().name);
trace(arr.pop().name);

// trace(arr.pop());
// This additional function call would end the script because of an error.
// The ArrayStack is empty.

arr.unshift(new Node(”A“));
arr.unshift(new Node(”B“));
arr.unshift(new Node(”C“));

trace(”——————————“);
trace(”function: getNodeByNumber“);

trace(arr.getNodeByNumber(0).name);
trace(arr.getNodeByNumber(1).name);
trace(arr.getNodeByNumber(2).name);

trace(”——————————“);
trace(”function: shift“);

trace(arr.shift().name);
trace(arr.shift().name);
trace(arr.shift().name);

/*
output:
function: getNodeByNumber
A
B
C
D
——————————
function: pop
D
C
B
A
——————————
function: getNodeByNumber
C
B
A
——————————
function: shift
C
B
A
*/

That’s it.
btw. the links to the tutorial are:
http://www.javaworld.com/javaworld/jw-05-2003/jw-0502-java101.html?
and
http://www.javaworld.com/javaworld/jw-06-2003/jw-0613-java101.html?

Posted in Flash