LectureNotes-06-DSA

Chapter 5

Stacks and Queues

5.1 Introduction
Data organize naturally as lists. We have already used the Array and Ar-
rayList classes for handling data organized as a list. Although those data
structures helped us group the data in a convenient form for processing,
neither structure provides a real abstraction for actually designing and im-
plementing problem solutions. Two list-oriented data structures that provide
easy-to-understand abstractions are stacks and queues. Data in a stack are
added and removed from only one end of the list, whereas data in a queue
are added at one end and removed from the other end of a list. Stacks are
used extensively in programming language implementations, from everything
from expression evaluation to handling function calls. Queues are used to
prioritize operating system processes and to simulate events in the real world,
such as teller lines at banks and the operation of elevators in buildings. C#
provides two classes for using these data structures: the Stack class and the
Queue class.

5.2 Stacks
The stack is one of the most frequently used data structures, as we just men-
tioned. We deﬁne a stack as a list of items that are accessible only from the
end of the list, which is called the top of the stack. The standard model for a
stack is the stack of trays at a cafeteria. Trays are always removed from the
top, and the when the dishwasher or busboy puts a tray back on the stack,
it is placed on the top also. A stack is known as a Last-in, First-out (LIFO)
data structure.

83

84 CHAPTER 5. STACKS AND QUEUES

Figure 5.1: Stack Two Main Operations: Push, and Pop

5.2.1 Stack Operations
The two primary operations of a stack are adding items to the stack and
taking items o↵ the stack. The Push operation adds an item to a stack.
We take an item o↵ the stack with a Pop operation. These operations are
illustrated in Figure 5.1 presented in 84. The other primary operation to
perform on a stack is viewing the top item. The Pop operation returns the top
item, but the operation also removes it from the stack. We want to just view
the top item without actually removing it. This operation is named Peek in
C#, though it goes by other names in other languages and implementations
(such as Top). Pushing, popping, and peeking are the primary operations
we perform when using a stack; however, there are other operations we need
to perform and properties we need to examine. It is useful to be able to
remove all the items from a stack at one time. A stack is completed emptied
by calling the Clear operation. It is also useful to know how many items
are in a stack at any one time. We do this by calling the Count property.
Many implementations have a StackEmpty method that returns a true or
false value depending on the state of the stack, but we can use the Count
property for the same purposes. The Stack class of the .NET Framework
implements all of these operations and properties and more, but before we
examine how to use them, let’s look at how you would have to implement a
stack if there wasn’t a Stack class.

5.2.2 Stack Constructors
• Stack(): Initializes a new instance of the Stack class that is empty and
has the default initial capacity.

• Stack(ICollection): Initializes a new instance of the Stack class that

5.2. STACKS 85

contains elements copied from the specified collection and has the same
initial capacity as the number of elements copied.

• Stack(Int32): Initializes a new instance of the Stack class that is empty
and has the specified initial capacity or the default initial capacity,
whichever is greater.

5.2.3 Stack Properties
• Count: Gets the number of elements contained in the Stack.

• IsSynchronized: Gets a value indicating whether access to the Stack is
synchronized (thread safe).

• SyncRoot: Gets an object that can be used to synchronize access to
the Stack.

5.2.4 Stack Methos
• Clear: Removes all objects from the Stack.

• Clone: Creates a shallow copy of the Stack.

• Contains: Determines whether an element is in the Stack.

• CopyTo: Copies the Stack to an existing one-dimensional Array, start-
ing at the specified array index.

• Equals(Object): Determines whether the specified object is equal to
the current object. (Inherited from Object.)

• Finalize: Allows an object to try to free resources and perform other
cleanup operations before it is reclaimed by garbage collection. (Inher-
ited from Object.)

• GetEnumerator: Returns an IEnumerator for the Stack.

• GetHashCode: Serves as a hash function for a particular type. (Inher-
ited from Object.)

• GetType: Gets the Type of the current instance. (Inherited from Ob-
ject.)

• MemberwiseClone: Creates a shallow copy of the current Object. (In-
herited from Object.)


• Peek: Returns the object at the top of the Stack without removing it.

• Pop: Removes and returns the object at the top of the Stack.

• Push: Inserts an object at the top of the Stack.

• Synchronized: Returns a synchronized (thread safe) wrapper for the
Stack.

• ToArray: Copies the Stack to a new array.

• ToString: Returns a string that represents the current object. (Inher-
ited from Object.)

5.2.5 Stack Remarks
• Stack is implemented as a circular bu↵er.

• The capacity of a Stack is the number of elements the Stack can hold.
As elements are added to a Stack, the capacity is automatically in-
creased as required through reallocation.

• If Count is less than the capacity of the stack, Push is an O(1) oper-
ation. If the capacity needs to be increased to accommodate the new
element, Push becomes an O(n) operation, where n is Count. Pop is
an O(1) operation.

• Stack accepts null as a valid value and allows duplicate elements.

5.2.6 Stack Example
The following example shows how to create and add values to a Stack and
how to print out its values.

using System ;
using System . Collections ;
public class SamplesStack {
public static void Main ( ) {
// Creates and initializes a new Stack .
Stack myStack = new Stack ( ) ;
myStack . Push ( ” H e l l o ” ) ;
myStack . Push ( ”World” ) ;
myStack . Push ( ” ! ” ) ;

// Displays the properties and values of the Stack .
Console . WriteLine ( ” myStack ” ) ;
Console . WriteLine ( ” tCount : {0} ” , myStack . Count ) ;
Console . Write ( ” t V a l u e s : ” ) ;

5.2. STACKS 87

PrintValues ( myStack ) ;
}

public static void PrintValues ( IEnumerable myCollection ) {
f o r e a c h ( Object obj in myCollection )
Console . Write ( ” {0} ” , obj ) ;
Console . WriteLine ( ) ;
}
}

/∗
This code produces the following output .

myStack
Count : 3
Values : ! World Hello
∗/

5.2.7 Building Our Own Stack
A Stack implementation has to use an underlying structure to hold data.
We’ll choose an ArrayList since we don’t have to worry about resizing the
list when new items are pushed onto the stack. Since C# has such great
object-oriented programming features, we’ll implement the stack as a class,
called CStack. We’ll include a constructor method and methods for the above
mentioned operations. The Count property is implemented as a property in
order to demonstrate how that’s done in C#. Let’s start by examining the
private data we need in the class. The most important variable we need is
an ArrayList object to store the stack items. The only other data we need
to keep track o↵ is the top of the stack, which we’ll do with a simple Integer
variable that functions as an index. The variable is initially set to -1 when a
new CStack object is instantiated. Every time a new item is pushed onto the
stack, the variable is incremented by 1. The constructor method does nothing
except initialize the index variable to -1. The ﬁrst method to implement is
Push. The code calls the ArrayList Add method and adds the value passed to
it to the ArrayList. The Pop method does three things: calls the RemoveAt
method to take the top item o↵ the stack (out of the ArrayList), decrements
the index variable by 1, and, ﬁnally, returns the object popped o↵ the stack.
The Peek method is implemented by calling the Item method with the index
variable as the argument. The Clear method simply calls an identical method
in the ArrayList class. The Count property is written as a read-only property
since we don’t want to accidentally change the number of items on the stack.
Here’s the code:

class CStack {


private int p_index ;
private ArrayList list ;
public CStack ( ) {
list = new ArrayList ( ) ;
p_index = 1;
}
public int count {
get {
return list . Count ;
}
}
public void push ( object item ) {
list . Add ( item ) ;
p_index++;
}
public object pop ( ) {
object obj = list [ p_index ] ;
list . RemoveAt ( p_index ) ;
p_index ;
return obj ;
}
public void clear ( ) {
list . Clear ( ) ;
p_index = 1;
}
public object peek ( ) {
return list [ p_index ] ;
}
}

Now let’s use this code to write a program that uses a stack to solve a prob-
lem. A palindrome is a string that is spelled the same forward and backward.
For example, “dad”, “madam”, and “sees” are palindromes, whereas “hello”
is not a palindrome. One way to check strings to see if they’re palindromes is
to use a stack. The general algorithm is to read the string character by char-
acter, pushing each character onto a stack when it’s read. This has the e↵ect
of storing the string backwards. The next step is to pop each character o↵
the stack, comparing it to the corresponding letter starting at the beginning
of the original string. If at any point the two characters are not the same,
the string is not a palindrome and we can stop the program. If we get all
the way through the comparison, then the string is a palindrome. Here’s the
program, starting at Sub Main since we’ve already deﬁned the CStack class:

static void Main ( string [ ] args ) {
CStack alist = new CStack ( ) ;
string ch ;
string word = ” s e e s ” ;
bool isPalindrome = true ;
for ( int x = 0 ; x < word . Length ; x++)
alist . push ( word . Substring ( x , 1 ) ) ;
int pos = 0 ;
w h i l e ( alist . count > 0 ) {
ch = alist . pop ( ) . ToString ( ) ;
i f ( ch != word . Substring ( pos , 1 ) ) {

5.2. STACKS 89

isPalindrome = false ;
break ;
}
pos++;
}
i f ( isPalindrome )
Console . WriteLine ( word + ” i s a p a l i n d r o m e . ” ) ;
else
Console . WriteLine ( word + ” i s not a p a l i n d r o m e . ” ) ;
Console . Read ( ) ;
}

5.2.8 Decimal to Multiple-Base Conversion
Although decimal numbers are used in most business applications, some sci-
entiﬁc and technical applications require numbers to be presented in other
bases. Many computer system applications require numbers to be in either
octal or binary format. One algorithm that we can use to convert numbers
from decimal to octal or binary makes use of a stack. The steps of the
algorithm are listed as follows:
Data: Number, Base
Result: Converted Number to Required Base
initialization;
read number;
read base;
while number not equal to 0 do
Push the number mod base onto the stack;
Number becomes the number integer-divided by the base;
end
Algorithm 1: How to Convert Decimal to Multi-Base Numbers
Once the loop ﬁnishes, you have the converted number, and you can
simply pop the individual digits o↵ the stack to see the results. Here’s one
implementation of the program:

using System ;
namespace csstack {
class Class1 {
int num , baseNum ;
Console . Write ( ” Enter a d e c i m a l number : ” ) ;
num = Convert . ToInt32 ( Console . ReadLine ( ) ) ;
Console . Write ( ” Enter a b a s e : ” ) ;
baseNum = Convert . ToInt32 ( Console . ReadLine ( ) ) ;
Console . Write ( num + ” c o n v e r t s t o ” ) ;
MulBase ( num , baseNum ) ;
Console . WriteLine ( ” Base ” + baseNum ) ;


}

static void MulBase ( int n , int b ) {
Stack Digits = new Stack ( ) ;
do {
Digits . Push ( n % b ) ;
n /= b ;
} w h i l e ( n != 0 ) ;
w h i l e ( Digits . Count > 0 )
Console . Write ( Digits . Pop ( ) ) ;
}
}
}

This program illustrates why a stack is a useful data structure for many com-
putational problems. When we convert a decimal number to another form,
we start with the right-most digits and work our way to the left. Pushing
each digit on the stack as we go works perfectly because when we finish, the
converted digits are in the correct order. Although a stack is a useful data
structure, some applications lend themselves to being modeled using another
list-based data structure. Take, for example, the lines that form at the gro-
cery store or your local video rental store. Unlike a stack, where the last one
in is the first one out, in these lines the first one in should be the last one out
(FIFO). Another example is the list of print jobs sent to a network (or local)
printer. The first job sent to the printer should be the first job handled by
the printer.

5.3 Queues
A queue is a data structure where data enters at the rear of a list and is
removed from the front of the list. Queues are used to store items in the
order in which they occur. Queues are an example of a first-in, first-out
(FIFO) data structure. Queues are used to order processes submitted to an
operating system or a print spooler, and simulation applications use queues
to model customers waiting in a line.

5.3.1 Queue Constructors
• Queue( ): Initializes a new instance of the Queue class that is empty,
has the default initial capacity, and uses the default growth factor.

• Queue(ICollection): Initializes a new instance of the Queue class that
contains elements copied from the specified collection, has the same
initial capacity as the number of elements copied, and uses the default
growth factor.

5.3. QUEUES 91

• Queue(Int32): Initializes a new instance of the Queue class that is
empty, has the specified initial capacity, and uses the default growth
factor.

• Queue(Int32, Single): Initializes a new instance of the Queue class that
is empty, has the specified initial capacity, and uses the specified growth
factor.

5.3.2 Queue Properties
• Count: Gets the number of elements contained in the Queue.

• IsSynchronized: Gets a value indicating whether access to the Queue
is synchronized (thread safe).

• SyncRoot: Gets an object that can be used to synchronize access to
the Queue.

5.3.3 Queue Methods
• Clear: Removes all objects from the Queue.

• Clone: Creates a shallow copy of the Queue.

• Contains: Determines whether an element is in the Queue.

• CopyTo: Copies the Queue elements to an existing one-dimensional
Array, starting at the specified array index.

• Dequeue: Removes and returns the object at the beginning of the
Queue.

• Enqueue: Adds an object to the end of the Queue.

• Equals(Object): Determines whether the specified object is equal to
the current object. (Inherited from Object.)

• Finalize: Allows an object to try to free resources and perform other
cleanup operations before it is reclaimed by garbage collection. (Inher-
ited from Object.)

• GetEnumerator: Returns an enumerator that iterates through the Queue.

• GetHashCode: Serves as a hash function for a particular type. (Inher-
ited from Object.)


• GetType: Gets the Type of the current instance. (Inherited from Ob-
ject.)

• MemberwiseClone: Creates a shallow copy of the current Object. (In-
herited from Object.)

• Peek: Returns the object at the beginning of the Queue without re-
moving it.

• Synchronized: Returns a Queue wrapper that is synchronized (thread
safe).

• ToArray: Copies the Queue elements to a new array.

• ToString: Returns a string that represents the current object. (Inher-
ited from Object.)

• TrimToSize Sets the capacity to the actual number of elements in the
Queue.

5.3.4 Queues Remarks
• Queues are useful for storing messages in the order they were received
for sequential processing. This class implements a queue as a circular
array. Objects stored in a Queue are inserted at one end and removed
from the other.

• The capacity of a Queue is the number of elements the Queue can
hold. As elements are added to a Queue, the capacity is automati-
cally increased as required through reallocation. The capacity can be
decreased by calling TrimToSize.

• The growth factor is the number by which the current capacity is mul-
tiplied when a greater capacity is required. The growth factor is deter-
mined when the Queue is constructed. The default growth factor is 2.0.
The capacity of the Queue will always increase by at least a minimum
of four, regardless of the growth factor. For example, a Queue with
a growth factor of 1.0 will always increase in capacity by four when a
greater capacity is required.

• Queue accepts null as a valid value and allows duplicate elements.

5.3. QUEUES 93

5.3.5 Queue Example

using System ;
public class SamplesQueue {

public static void Main ( ) {

// Creates and initializes a new Queue .
Queue myQ = new Queue ( ) ;
myQ . Enqueue ( ” H e l l o ” ) ;
myQ . Enqueue ( ”World” ) ;
myQ . Enqueue ( ” ! ” ) ;

// Displays the properties and values of the Queue .
Console . WriteLine ( ”myQ” ) ;
Console . WriteLine ( ” tCount : {0} ” , myQ . Count ) ;
Console . Write ( ” t V a l u e s : ” ) ;
PrintValues ( myQ ) ;
}

public static void PrintValues ( IEnumerable myCollection ) {
f o r e a c h ( Object obj in myCollection )
Console . Write ( ” {0} ” , obj ) ;
}
}
/∗
This code produces the following output .

myQ
Count : 3
Values : Hello World !
∗/

5.3.6 Need for Queues
If you are creating any kind of computer service—that is, a computer program
that can receive multiple requests from multiple sources for some task to be
completed—then part of the challenge of creating the service is deciding
the order with which the incoming requests will be handled. The two most
common approaches used are:
• First come, first served
• Priority-based processing
First come, first served is the job-scheduling task you’ll find at your grocery
store, the bank, and the DMV. Those waiting for service stand in a line. The
people in front of you are served before you, while the people behind you will
be served after. Priority-based processing serves those with a higher priority


before those with a lesser priority. For example, a hospital emergency room
uses this strategy, opting to help someone with a potentially fatal wound
before someone with a less threatening wound, regardless of who arrived
ﬁrst.
Imagine that you need to build a computer service and that you want to
handle requests in the order in which they were received. Since the number
of incoming requests might happen quicker than you can process them, you’ll
need to place the requests in some sort of bu↵er that can reserve the order
with which they have arrived.
One option is to use an ArrayList and an integer variable called nextJob-
Pos to indicate the array position of the next job to be completed. When
each new job request comes in, simply use the ArrayList’s Add() method to
add it to the end of the ArrayList. Whenever you are ready to process a job
in the bu↵er, grab the job at the nextJobPos position in the ArrayList and
increment nextJobPos. The following program illustrates this algorithm:

using System ;

public class JobProcessing
{
private static ArrayList jobs = new ArrayList ( ) ;
private static int nextJobPos = 0 ;

public static void AddJob ( string jobName )
{
jobs . Add ( jobName ) ;
}

public static string GetNextJob ( )
{
i f ( nextJobPos > jobs . Count 1)
return ”NO JOBS IN BUFFER” ;
else
{
string jobName = ( string ) jobs [ nextJobPos ] ;
nextJobPos++;
return jobName ;
}
}

public static void Main ( )
{
AddJob ( ” 1 ” ) ;
AddJob ( ” 2 ” ) ;
Console . WriteLine ( GetNextJob ( ) ) ;
AddJob ( ” 3 ” ) ;
AddJob ( ” 4 ” ) ;
AddJob ( ” 5 ” ) ;

5.3. QUEUES 95

Figure 5.2: The ArrayList after the first two lines of code

}
}

The output of this program is as follows:

1
2
3
NO JOBS IN BUFFER
NO JOBS IN BUFFER
4

While this approach is fairly simple and straightforward, it is horribly ine -
cient. For starters, the ArrayList continues to grow unabated with each job
that’s added to the bu↵er, even if the jobs are processed immediately after
being added to the bu↵er. Consider the case where every second a new job
is added to the bu↵er and a job is removed from the bu↵er. This means that
once a second the AddJob() method is called, which calls the ArrayList’s
Add() method. As the Add() method is continually called, the ArrayList’s
internal array’s size is continually redoubled as needed. After five minutes
(300 seconds) the ArrayList’s internal array is dimensioned for 512 elements,
even though there has never been more than one job in the bu↵er at a time!
This trend, of course, continues so long as the program continues to run and
the jobs continue to come in.
The reason the ArrayList grows to such ridiculous proportion is because
the bu↵er locations used for old jobs is not reclaimed. That is, when the
first job is added to the bu↵er, and then processed, the first spot in the
ArrayList is ready to be reused again. Consider the job schedule presented
in the previous code sample. After the first two lines—AddJob(”1”) and
AddJob(”2”)—the ArrayList will look Figure 5.2 presented in page 95. Note
that there are 16 elements in the ArrayList at this point because, by de-
fault, the ArrayList, when initialized, creates its internal object array with
16 elements. Next, the GetNextJob() method is invoked, which removes the


Figure 5.3: Program after the GetNextJob() method is invoked

Figure 5.4: Issue Created by placing jobs in the 0 index

first job, resulting in something like Figure 5.3 presented in page 96. When
AddJob(”3”) executes, we need to add another job to the bu↵er. Clearly
the first ArrayList element (index 0) is available for reuse. Initially it might
make sense to put the third job in the 0 index. However, this approach can
be forgotten by considering what would happen if after AddJob(”3”) we did
AddJob(”4”), followed by two calls to GetNextJob(). If we placed the third
job in the 0 index and then the fourth job in the 2 index, we’d have the
problem demonstrated in Figure 5.4 presented in page 96. Now, when Get-
NextJob() was called, the second job would be removed from the bu↵er, and
nextJobPos would be incremented to point to index 2. Therefore, when Get-
NextJob() was called again, the fourth job would be removed and processed
prior to the third job, thereby violating the first come, first served order we
need to maintain. The crux of this problem arises because the ArrayList
represents the list of jobs in a linear ordering. That is, we need to keep
adding the new jobs to the right of the old jobs to guarantee that the correct
processing order is maintained. Whenever we hit the end of the ArrayList,
the ArrayList is doubled, even if there are unused ArrayList elements due to
calls to GetNextJob(). To fix this problem, we need to make our ArrayList
circular. A circular array is one that has no definite start or end. Rather,
we have to use variables to maintain the beginning and end of the array. A
graphical representation of a circular array is shown in Figure 5.5 presented

5.3. QUEUES 97

Figure 5.5: Example of a Circular Array

in page 97. With a circular array, the AddJob() method adds the new job
in index endPos and then ”increments” endPos. The GetNextJob() method
plucks the job from startPos, sets the element at the startPos index to null,
and ”increments” startPos. I put the word increments in quotation marks
because here incrementing is a triﬂe more complex than simply adding one
to the variable’s current value. To see why we can’t just add 1, consider the
case when endPos equals 15. If we increment endPos by adding 1, endPos
equals 16. In the next AddJob() call, the index 16 will attempt to be ac-
cessed, which will result in an IndexOutOfRangeException. Rather, when
endPos equals 15, we want to increment endPos by resetting it to 0. This
can either be done by creating an increment(variable) function that checks
to see if the passed-in variable equals the array’s size and, if so, reset it to
0. Alternatively, the variable can have its value incremented by 1 and then
moded by the size of the array. In such a case, the code for increment()
would look like:

int increment ( int variable )


{
return ( variable + 1 ) % theArray . Length ;
}

The modulus operator, %, when used like x% y, calculates the remainder of
x divided by y. The remainder is always between 0 and y – 1. This approach
works well if our bu↵er never has more than 16 elements, but what happens
if we want to add a new job to the bu↵er when there are already 16 jobs
present? Like with the ArrayList’s Add() method, we’ll need to redimension
the circular array appropriately, by, say, doubling the size of the array.

5.3.7 Queue Operations
The two primary operations involving queues are adding a new item to the
queue and removing an item from the queue. The operation for adding a
new item is called Enqueue, and the operation for removing an item from a
queue is called Dequeue. The Enqueue operation adds an item at the end
of the queue and the Dequeue operation removes an item from the front (or
beginning) of the queue. Figure 5.3.7 presented in page 99 illustrates these
operations. The other primary operation to perform on a queue is viewing
the beginning item. The Peek method, like its counterpoint in the Stack
class, is used to view the beginning item. This method simply returns the
item without actually removing it from the queue. There are other properties
of the Queue class we can use to aid in our programming. However, before
we discuss them let’s look at how we can implement a Queue class.

5.3.8 Building Our Own Queue
Implementing the Queue class using an ArrayList is practically a no-brainer,
as was our implementation of the Stack class. ArrayLists are excellent imple-
mentation choices for these types of data structures because of their built-in
dynamics. When we need to insert an item into our queue, the Arraylist Add
method places the item in the next free element of the list. When we need to
remove the front item from the queue, the ArrayList moves each remaining
item in the list up one element. We don’t have to maintain a placeholder,
which can lead to subtle errors in your code. The following Queue class imple-
mentation includes methods for EnQueue, DeQueue, ClearQueue (clearing
the queue), Peek, and Count, as well as a default constructor for the class:

public class CQueue {
private ArrayList pqueue ;
public CQueue ( ) {
pqueue = new ArrayList ( ) ;

5.3. QUEUES 99

Figure 5.6: Queue Operations

}
public void EnQueue ( object item ) {
pqueue . Add ( item ) ;
}
public void DeQueue ( ) {
pqueue . RemoveAt ( 0 ) ;
}
public object Peek ( ) {
return pqueue [ 0 ] ;
}
public void ClearQueue ( ) {
pqueue . Clear ( ) ;
}
public int Count ( ) {
return pqueue . Count ;
}
}

5.3.9 Sorting Data wih Queues
Back in the old days of computing, programs were entered into a mainframe
computer via punch cards, where each card held a single program statement.
Cards were sorted using a mechanical sorter that utilized bin-like structures.
We can simulate this process by sorting data using queues. This sorting
technique is called a radix sort. It will not be the fastest sort in your pro-
gramming repertoire, but the radix sort does demonstrate another interesting
use of queues. The radix sort works by making two passes over a set of data,
in this case integers in the range 0–99. The ﬁrst pass sorts the numbers


based on the 1’s digit and the second pass sorts the numbers based on the
10’s digit. Each number is then placed in a bin based on the digit in each of
these places. Given these numbers:
91 46 85 15 92 35 31 22
The ﬁrst pass results in this bin conﬁguration:
Bin 0:
Bin 1: 91 31
Bin 2: 92 22
Bin 3:
Bin 4:
Bin 5: 85 15 35
Bin 6: 46
Bin 7:
Bin 8:
Bin 9: Now put the numbers in order based on which bin they’re in:
91 31 92 22 85 15 35 46
Next, take the list and sort by the 10’s digit into the appropriate bins:
Bin 0:
Bin 1: 15
Bin 2: 22
Bin 3: 31 35
Bin 4: 46
Bin 5:
Bin 6:
Bin 7:
Bin 8: 85
Bin 9: 91 92 Take the numbers from the bins and put them back into a
list, which results in a sorted set of integers:
15 22 31 35 46 85 91 92
We can implement this algorithm by using queues to represent the bins. We
need nine queues, one for each digit. We use modulus and integer division for
determining the 1’s and 10’s digits. The rest is a matter of adding numbers
to their appropriate queues, taking them out of the queues to resort based
on the 1’s digit, and then repeating the process for the 10’s digit. The result
is a sorted list of integers. Here’s the code:

using System ;
using System . IO ;
namespace csqueue {
class Class1 {
enum DigitType { ones = 1 , tens = 10}

5.3. QUEUES 101

static void DisplayArray ( int [ ] n ) {
for ( int x = 0 ; x <= n . GetUpperBound ( 0 ) ; x++)
Console . Write ( n [ x ] + ” ” ) ;
}
static void RSort ( Queue [ ] que , int [ ] n , DigitType digit ) {
int snum ;
for ( int x = 0 ; x <= n . GetUpperBound ( 0 ) ; x++){
i f ( digit == DigitType . ones )
snum = n [ x ] % 1 0 ;
else
snum = n [ x ] / 1 0 ;
que [ snum ] . Enqueue ( n [ x ] ) ;
}
}
static void BuildArray ( Queue [ ] que , int [ ] n ) {
int y = 0 ;
for ( int x = 0 ; x >= 9 ; x++)
w h i l e ( que [ x ] . Count > 0 ) {
n [ y ] = Int32 . Parse ( que [ x ] . Dequeue ( ) . ToString ( ) ) ;
y++;
}
}
Queue [ ] numQueue = new Queue [ 1 0 ] ;
int [ ] nums = new int [ ] { 9 1 , 4 6 , 8 5 , 1 5 , 9 2 , 3 5 , 3 1 , 2 2 } ;
int [ ] random = new Int32 [ 9 9 ] ;
// Display original list
for ( int i = 0 ; i < 1 0 ; i++)
numQueue [ i ] = new Queue ( ) ;
RSort ( numQueue , nums , DigitType . ones ) ;
// numQueue , nums , 1
BuildArray ( numQueue , nums ) ;
Console . WriteLine ( ” F i r s t p a s s r e s u l t s : ” ) ;
DisplayArray ( nums ) ;
// Second pass sort
RSort ( numQueue , nums , DigitType . tens ) ;
BuildArray ( numQueue , nums ) ;
Console . WriteLine ( ” Second p a s s r e s u l t s : ” ) ;
// Display final results
DisplayArray ( nums ) ;
Console . Write ( ” P r e s s e n t e r t o q u i t ” ) ;
}
}
}

The RSort subroutine is passed the array of queues, the number array, and
a descriptor telling the subroutine whether to sort the 1’s digit or the 10’s
digit. If the sort is on the 1’s digit, the program calculates the digit by
taking the remainder of the number modulus 10. If the sort is on the 10’s
digit, the program calculates the digit by taking the number and dividing (in
an integer-based manner) by 10. To rebuild the list of numbers, each queue is
emptied by performing successive Dequeue operations while there are items
in the queue. This is performed in the BuildArray subroutine. Since we start


with the array that is holding the smallest numbers, the number list is built
“in order.”

5.3.10 Priority Queues
Queue is a data structure where the first item placed in the structure is
the first item taken out of the structure. The e↵ect of the behavior is the
oldest item in the structure that is removed first. For many applications,
though, a data structure is needed where an item with the highest priority
is removed first, even if it isn’t the “oldest” item in the structure. There is
a special case of the Queue made for this type of application—the priority
queue. There are many applications that utilize priority queues in their
operations. A good example is process handling in a computer operating
system. Certain processes have a higher priority than other processes, such as
printing processes, which typically have a low priority. Processes (or tasks)
are usually numbered by their priority, with a Priority 0 process having a
higher priority than a Priority 20 task. Items stored in a priority queue are
normally constructed as key–value pairs, where the key is the priority level
and the value identifies the item. For example, an operating system process
might be defined like this:

struct Process {
int priority ;
string name ;
}

We cannot use an unmodified Queue object for a priority queue. The De-
Queue method simply removes the first item in the queue when it is called.
We can, though, derive our own priority queue class from the Queue class,
overriding Dequeue to make it do our bidding. We’ll call the class PQueue.
We can use all of the Queue methods as is, and override the Dequeue method
to remove the item that has the highest priority. To remove an item from a
queue that is not at the front of the queue, we have to first write the queue
items to an array. Then we can iterate through the array to find the highest
priority item. Finally, with that item marked, we can rebuild the queue,
leaving out the marked item. Here’s the code for the PQueue class:

public struct pqItem {
public int priority ;
public string name ;
}
public class PQueue : Queue {
public PQueue {
base ( ) ;

5.4. SUMMARY 103

}
public override object Dequeue ( ) {
object [ ] items ;
int x , min , minindex ;
items = this . ToArray ( ) ;
min = ( pqItem ) items [ 0 ] . priority ;
for ( int x = 1 ; x <= items . GetUpperbound ( 0 ) ; x++)
i f ( ( pqItem ) items [ x ] . Priority < min ) {
min = ( pqItem ) items [ x ] . Priority ; minindex = x ;
}
this . Clear ( ) ;
for ( int x = 0 ; x <= items . GetUpperBound ( 0 ) ; x++)
i f ( x != minindex && ( pqItem ) items [ x ] . name != ” ” )
this . Enqueue ( items [ x ] ) ;
return items [ minindex ] ;
}
}

The following code demonstrates a simple use of the PQueue class. An emer-
gency waiting room assigns a priority to patients who come in for treatment.
A patient presenting symptoms of a heart attack is going to be treated be-
fore a patient who has a bad cut. The following program simulates three
patients entering an emergency room at approximately the same time. Each
patient is seen by the triage nurse, assigned a priority, and added to the
queue. The ﬁrst patient to be treated is the patient removed from the queue
by the Dequeue method.

static void Main ( ) {
PQueue erwait = new PQueue ( ) ;
pqItem [ ] erPatient = new pqItem [ 4 ] ;
pqItem nextPatient ;
erPatient [ 0 ] . name = ” Joe Smith ” ; erPatient [ 0 ] . priority = 1 ;
erPatient [ 1 ] . name = ”Mary Brown” ; erPatient [ 1 ] . priority = 0 ;
erPatient [ 2 ] . name = ”Sam J o n e s ” ; erPatient [ 2 ] . priority = 3 ;
for ( int x = 0 ; x <= erPatient . GetUpperbound ( 0 ) ; x++)
erwait . Enqueue ( erPatient [ x ] ) ;
nextPatient = erwait . Dequeue ( ) ;
Console . WriteLine ( nextPatient . name ) ;
}

The output of this program is “Mary Brown”, since she has a higher priority
than the other patients.

5.4 Summary
Learning to use data structures appropriately and e ciently is one of the
skills that separates the expert programmer from the average programmer.
The expert programmer recognizes that organizing a program’s data into an
appropriate data structure makes it easier to work with the data. In fact,
thinking through a computer programming problem using data abstraction


makes it easier to come up with a good solution to the problem in the first
place. We discussed using two very common data structures in this chapter:
the stack and the queue. Stacks are used for solving many di↵erent types
of problems in computer programming, especially in systems’ programming
areas such as interpreters and compilers. We also saw how we can use stacks
to solve more generic problems, such as determining if a word is a palin-
drome. Queues also have many applications. Operating systems use queues
for ordering processes (via priority queues) and queues are used quite often
for simulating real world processes. Finally, we used the Queue class to de-
rive a class for implementing a priority queue. The ability to derive new
classes from classes in the .NET Framework class library is one of the major
strengths of the .NET version of C#.

5.5 Labs
1. You can use a Stack to check if a programming statement or a formula
has balanced parentheses. Write a Windows application that provides a
text box for the user to enter an expression with parenthesis. Provide a
Check Parens button that, when clicked, runs a program that checks the
number of parentheses in the expression and highlights a parenthesis
that is unbalanced.

2. A postfix expression evaluator works on arithmetic statements that
take this form: op1 op2 operator . . . Using two stacks, one for the
operands and one for the operators, design and implement a Calculator
class that converts infix expressions to postfix expressions and then uses
the stacks to evaluate the expressions.

3. This exercise involves designing a help-desk priority manager. Help
requests are stored in a text file with the following structure: priority,
id of requesting party, time of request The priority is an integer in
the range 1–5 with 1 being the least important and 5 being the most
important. The id is a four-digit employee identification number and
the time is in TimeSpan.Hours, TimeSpan.Minutes, TimeSpan.Seconds
format. Write a Windows application that, during the Form Load
event, reads five records from the data file containing help requests,
prioritizes the list using a priority queue, and displays the list in a list
box. Each time a job is completed, the user can click on the job in the
list box to remove it. When all five jobs are completed, the application
should automatically read five more data records, prioritize them, and
display them in the list box.

LectureNotes-06-DSA

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to LectureNotes-06-DSA (20)

More from Haitham El-Ghareeb (20)

Recently uploaded (20)

LectureNotes-06-DSA