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?
