public void SortByType()
{
//Bucket Sort
/*
A arry to be sorted
n is length of A
for i = 1 to n
insert A[i] into B bucket (queue)
for i = 0 to n-1
sort B
*/
//Generic Stack for each droid type
Stack<Droid> protocolStack = new Stack<Droid>();
Stack<Droid> utilityStack = new Stack<Droid>();
Stack<Droid> janitorStack = new Stack<Droid>();
Stack<Droid> astromechStack = new Stack<Droid>();
//Create a Queue for Droids
Queue<Droid> droidQueue = new Queue<Droid>();
//Create a linked list for the droids
LinkedList<Droid> droidLinkedList = new LinkedList<Droid>();
int n = droidCollection.Length;
//Move droid type into the bucket
foreach (int i in droidCollection)
{
//check if value is not null
if(droidCollection[i] != null)
{
//Add a droid to the linked list
droidLinkedList.AddLast(droidCollection);
}
//Add a new node for the data in the linked list
GenericNode<Droid> node = new GenericNode<Droid>();
node.Next;
droidQueue.enqueue(droidLinkedList);
}
//Push the droids into the queue(enqueue) and sort by pushing into their respected stacks
foreach (int i in droidQueue)
{
switch (droidQueue.Equals)
{
case "Protocol":
//take out of queue
//Add to the respected stack
protocolStack.push(droidQueue.dequeue());
break;
case "Utility":
utilityStack.push(droidQueue.dequeue());
break;
case "Janitor":
droidQueue.dequeue();
janitorStack.push(droidQueue.dequeue());
break;
case "Astromech":
droidQueue.dequeue();
astromechStack.push(droidQueue.dequeue());
break;
}
}
}
//Constructor. It will set the Head to null because there is nothing in the list yet.
public LinkedList()
{
Head = null;
}
public bool Delete(int Position)
{
//Set current to Head. Need to walk through it from the beginning
current = Head;
//If the position is the very first node in the list
if (Position == 1)
{
//Set the Head to the next node in the list. This will be the 2nd one.
Head = current.Next;
//Delete the current.Next pointer so there is no reference from current to
//another node
current.Next = null;
//current = null because we want the garbage collector to come pick it up.
current = null;
//it was successfull so, return true;
return(true);
}
//Check to make sure that at least a positive number was entered.
//Should also check to make sure that the position is less than the
//size of the array so that we aren't looking for something that doesn't
//exist. Adding a size property will be more work.
//TODO: Add a size property
if (Position > 1)
{
//Make a temp node that starts at the Head. This way we don't need to actually
//move the Head pointer. We can just use the temp node
GenericNode <T> tempNode = Head;
//Set a previous node to null. It will be used for the delete
GenericNode <T> previousTempNode = null;
//Start a counter to know if we have reached the position yet or not.
int count = 0;
//while the tempNode is NOT null, we can continue to walk through the
//linked list. If it is null, then we have reached the end.
while (tempNode != null)
{
//If the count is the same as the position entered - 1, then we have found
//the one we would like to delete.
if (count == Position - 1)
{
//Set the last node's Next property to the TempNodes Next Property
//Jumping over the tempNode. The previous node's next will now point
//to the node AFTER the tempNode
previousTempNode.Next = tempNode.Next;
if (tempNode.Next == null)
{
last = previousTempNode;
}
//Remove the next pointer of the tempnode
tempNode.Next = null;
//Return True because it was successfull
return(true);
}
//Increment the counter since we are going to move forward in the list
count++;
//Set the lastNode equal to the tempNode. Now both variables are pointing to
//the exact same node.
previousTempNode = tempNode;
//Now set the tempNode to tempNodes Next node. This will move tempNode
//one more location forward in the list.
tempNode = tempNode.Next;
}
}
//tempNode became null, so apparently we did not find it. Return false.
return(false);
}
public GenericQueue()
{
Head = null;
}