Data Structures
Chapter II:
Data Structures
FAP:UC-BCF 1
Terminologies
Data Types:
Refer to the different kinds of data that a variable may hold in a
programming languages
Examples:
integer
real
float
char
string
FAP:UC-BCF 2
Terminologies
Data Objects:
Refer to the set of elements
Example: data object integer refers to
D = {0, ±1, ±2, ±3, … }
FAP:UC-BCF 3
Terminologies
Data Structures:
Describe the set of objects and how they are related.
Describe the set of operations that can be applied on the
elements of a data object.
Typically this describe the more complex data types such as
arrays, stacks, queues, trees, graphs and operations of how
to manipulate these.
FAP:UC-BCF 4
Records
A structure that can have a number of heterogeneous
elements.
Declaration: RecordType
typedef struct field1
{
field2
<data type1> field1;
<data type2> field2; field3
<data type3> field3; .
<data typeN> fieldN;
.
}RecordType;
fieldN
FAP:UC-BCF 5
Records
Field1, field2, field3 … fieldN can be of any data type (i.e. integer,
float, real, record)
To define a variable for the record:
RecordType A;
Assigning a value to a record field:
A.field1 = <value>;
A.field2 = <value>;
To retrieve a value from a record field:
printf(“%d”, A.field1);
printf(“%c”, A.field2);
printf(“%d:4:2”, A.field3);
FAP:UC-BCF 6
Arrays
Consecutive set of memory locations is a set of pairs –
index and a value finite, ordered set of homogeneous
elements.
Forms:
- one-dimensional array
- n-dimensional array
FAP:UC-BCF 7
Arrays
2 data types
Base type of component type
Index type
Declaration
int A[10]; char B[45];
2 basic operations
Extraction
Storing
FAP:UC-BCF 8
Arrays
If an array is declared to be A[n], then:
n = number of elements
If an array is declared to be A[n][m], then
n*m = number of elements
if given n-dimensional array declaration
A[b][c][d]…[n] = Πb,c, … n
FAP:UC-BCF 9
Arrays
To determine the ith element of a Single-dimension
array:
A[i] = α + (i) * esize
where:
α - base or starting address
i – element
esize – element size in bytes
Example: Determine the address of 5th element of an
integer array A with a starting address of 2000
FAP:UC-BCF 10
Arrays
To determine the ith element of a Two-
dimension array:
A[i][j] = α + [(i)*(UB2)+(j)] * esize
where:
UB2 – upper bound of the 2nd dimension
α - base or starting address
esize – element size in bytes
FAP:UC-BCF 11
Arrays
To determine the ith element of a Three-
dimension array:
A[i][j][k]= α +[(i)*(UB2)*(UB3)+(j)*(UB3)+(k)]*esize
where:
UB3 – upper bound of the 3rd dimension
UB2 – upper bound of the 2nd dimension
α - base or starting address
esize – element size in bytes
FAP:UC-BCF 12
Arrays
Exercises:
1. Given A[10][3][3][6], α =2000, esize=4 bytes:
a.find the formula to represent an element in a 4-
dimensional array.
b.find the total number of elements
c. find the address of A[2][2][0][4]
2. Given X[8][3][6][2][3], α =3000, esize=3 bytes:
a.find the total number of elements
b.find the address of X[0][2][5][1][2]
FAP:UC-BCF 13
Arrays
3. Consider the following declaration:
typedef struct{
int A;
char B[10];
float C;
char D;
}rectype;
typedef rectype matrix[121][4][5];
matrix A1;
a. compute the address of element A1[120][3][3] given the
base address at 2000.
b. Assume that we do not know the size of RECTYPE in
number of bytes but we know that the address of
A1[20][2][3] is 2160. Give the size of RECTYPE in
bytes. Assume the base address is at 2000.
FAP:UC-BCF 14
Stacks
An ordered list in which all insertions and deletions are
made at one end called the TOP.
LIFO (Last In First Out)
G
A B C D E F
TOP
A B C D E F G
TOP
FAP:UC-BCF 15
Stacks
Operations:
Create(top) – Create an empty stack
Push(Stack, top, item) – Inserts an element item into the stack
Pop(Stack, top, item) – Removes the top element of the stack
and stores the value in item
S_top(Stack, top) – Returns the top element of the stack
Empty(top) – Determines whether the stack is empty or not.
Stack full: Top = n-1
Stack empty: Top = -1
FAP:UC-BCF 16
Stacks
Representation:
One-dimensional array
A B C D E F
TOP
Singly linked-list
A B C D
TOP
FAP:UC-BCF 17
Stacks
Declaration
#define n <constant value>
typedef <data type> elementtype;
typedef elementtype Stack[n];
Example:
Processing of procedure calls and their terminations
FAP:UC-BCF 18
Stacks
Procedures for Stack Operations:
void create(int *top)
{*top = -1;}
void push(stack S; int *top;elementtype item)
{
if(top==n-1)
stackfull;
else {
*top++;
S[*top] = item;
}
}
FAP:UC-BCF 19
Stacks
void pop(stack S; int *top; elementtype *item)
{ if(top==1) stackempty;
else{ *item = S[top];
*top--;}
}
elementtype s_top(stack S; int top)
{ if(top==-1) error_routine;
else return S[top];
}
int empty(int top)
{ if(top == 1) return 1;
else return 0;
}
FAP:UC-BCF 20
Stacks
void main()
{ create(&top1); create(&top2);
s_empty = empty(top1);
printf(“%d”, s_empty);
push(s1, &top1, 16);
s_empty = empty(top1);
printf(“%d”, s_empty);
push(s1, &top1, 10); push(s1, &top1, 9);
push(s1, &top1, 8); push(s1, &top1, 7);
j=s_top(s1, top1);
printf(“Top is %d”, j);
printf(“%d\n”, top1);
FAP:UC-BCF 21
Stacks
s_empty = empty(top2);
printf(“%d”, s_empty);
push(s2, &top2, 10); push(s2, &top2, 9);
push(s2, &top2, 8); push(s2, &top2, 7);
push(s2, &top2, 12); push(s2, &top2, 4);
pop(s1, &top1, &item);
pop(s2, &top2, &item);
j=s_top(s2, top2); printf(“Top is %d”, j);
printf(“%d\n”, top2);
}
FAP:UC-BCF 22
Evaluation of Expressions
Expression is made up of operands, operators and
delimiters.
Operands can be any legal variable names or constants
in programming languages.
Operations are described by operators:
Basic arithmetic operators: + - * /
Unary operators: - +
Relational operators: ==, >, <, >=, <=
FAP:UC-BCF 23
Evaluation of Expressions
Our concern: how the expressions are evaluated
The compiler accepts expressions and produce correct result by
reworking the expressions into postfix form. Other forms include
infix and prefix.
Prefix : <Operator> <Operand1> <Operand2>
Postfix : <Operand1> <Operand2> <Operator>
Infix : <Operand1> <Operator> <Operand2>
FAP:UC-BCF 24
Evaluation of Expressions
Expression: A + B
Prefix : +AB
Postfix: AB+
Expression: (A+B*C)/D
Prefix : /+A*BCD
Postfix: ABC*+D/
FAP:UC-BCF 25
Conversion from Infix to Postfix
using Stacks
IN-Stack Priority (ISP) – The priority of the operator as
an element of the stack.
IN-Coming Priority (ICP) – The priority of the operator
as current token.
SYMBOL ISP ICP
) -- --
^ 3 4
*, / 2 2
+,- 1 1
( 0 4
FAP:UC-BCF 26
Conversion from Infix to Postfix
using Stacks
Rule:
Operators are taken out of the stack (POP) as long as
their ISP is greater than or equal to the ICP of the new
operator.
Note: ISP and ICP of # sign = -1
FAP:UC-BCF 27
Conversion from Infix to Postfix
using Stacks
Algorithm:
void POSTFIX(expression E)
token x,y;
stack[0] = ‘#’; top = 0;
x = nexttoken(E); //takes the first token and remove it
from the original expression.
while x != ‘#’
{ if x is an operand printf(x);
else if x ==‘)’ {//unstack until ‘(’
while stack[top] != ‘(’
{ pop(y); printf(y);}
pop(y); //delete ‘(’
FAP:UC-BCF } 28
Conversion from Infix to Postfix
using Stacks
else{ while isp[stack[top]] >= icp[x]
{ pop(y); printf(y); }
push(x);
}
x = nexttoken(E);
}
if(!empty(stack))
{ while stack[top] != ‘#’
{ pop(y);
printf(y);
}
}
FAP:UC-BCF 29
Conversion from Infix to Postfix
using Stacks
Algorithm:
Do steps 1-3 while x is not #, else do step 4
1. Get the token from E and save it as X
2. If X is an operand, immediately print in the output
else check if X == ‘)’ pop operators in the stack and print in the output.
delete ‘)’
else while ISP of top of stack (Y) >= ICP of X,
Pop and print in the output.
Push X
3. Process the next token
4. If stack is not empty, pop and print until not #.
FAP:UC-BCF 30
Queues
An ordered list which all insertions take place at one
end, called the REAR, while all deletions take place at
the other end, called the FRONT.
FIFO (First-In-First-Out)
Elements are processed in the same order as they were
received. The first element inserted in the queue will be
the first one to be removed.
FAP:UC-BCF 31
Queues
Conventions for FRONT and REAR:
Front is always 1 less than the actual front of the queue.
Rear always points to the last element in the queue.
Initial value: Front = Rear = -1
Operations:
Createq(Front, Rear) – creates an empty queue
Insert(Queue, Rear, Item) – inserts the element item to the rear
of the queue.
Delete(Queue, Front, Rear, Item) – removes the front element
from the queue and assigns is to variable item.
Qfront(Queue, Front, Rear) – returns the front element of the
queue
FAP:UC-BCF 32
Queues
Qempty(Front, Rear) – determines if the queue is empty or not
Returns 1 if true
Otherwise return 0
Front = Rear means queue is empty.
FAP:UC-BCF 33
Queues
Representation
One-dimensional Array
A B C D E F G
Front Rear
Singly linked-list
A B C D
Rear Front
FAP:UC-BCF 34
Queues
Declaration:
#define n <constant value>
typedef <data type> elementtype;
typedef elementtype Queue[n];
typedef int FR
FR front, rear;
Queue Q;
FAP:UC-BCF 35
Queues
Example:
Processing of customers’ transactions (i.e. cashiers, bank-related)
Procedures for Queue Operations:
void createq(FR *front, FR *rear)
{ *front = *rear = -1 }
void insert(queue Q, FR *rear, elementtype item)
{ if(rear == n-1) queuefull;
else { (*rear)++;
Q[*rear] = item; }
}
FAP:UC-BCF 36
Queues
void delete(queue Q, FR *front, FR *rear, elementtype
*item)
{ if(*front == rear) queueempty;
else { (*front)++;
item = Q[front];}
}
elementtype qfront(queue Q, FR front, FR rear)
{ if(front == rear) errorroutine;
else return(Q[front + 1])
}
int quempty()
{ if(front == rear) return 1;
else return 0;
}
FAP:UC-BCF 37
Queues
Notes:
QUEUEFULL signal does not necessary imply that
there are N elements in the queue.
To solve this, move the entire queue to the left so that
the first element is again at Q[0] and front = -1.
FAP:UC-BCF 38
Circular Queues
.. n-1
.. 0
4 1
3 2
FAP:UC-BCF 39
Circular Queues
void insert(queue *Q, FR front, FR *rear, elementtype
item)
{ if(front == (rear+1)%n) queuefull;
else { *rear = (*rear+1)%n;
Q[*rear] = item;}
}
void delete(queue Q, FR *front, FR rear, elementtype
*item)
{ if(front == rear) then cqueueempty;
else { *front = (*front+1)%n;
*item = Q[front]; }
}
FAP:UC-BCF 40
Circular Queues
elementtype cqfront(queue Q, FR front, FR rear)
{ if(front == rear) errorrouting;
else return(Q[front+1]%n);
}
int cquempty()
{ if(front == rear) return 1;
else return 0;
}
FAP:UC-BCF 41
Exercises
Convert the following infix expressions to postfix and
prefix:
1. A+B*C/D
2. A/B^C+D*E-A*C
3. (A+B)*D+E/(F+A*D)+C
4. A+B*D^E^F^G/H^J*K-L
5. !(A&&!(B<C)||(C>D))||(C<E)
FAP:UC-BCF 42
Exercises
Convert the following prefix expressions to infix:
6. -+-^ABC*D^EFG
7. ^+-ABC+D-EF
8. || || &&ABC!<=EF
Convert the following postfix expressions to infix:
9. AB+CDE-F+*G-/
10. AB-C+DEF-+^
11. AB&&C||EF<=!||
FAP:UC-BCF 43
Exercises
Convert the following infix expressions to postfix
using stack:
12. B+C^(E+F*G^H)/(K-L/M)+N
13. B+C/D^(E+F*G^H)+Z
14. A+B-C*D*(E+F-G*H^I^J)+L/M+(N*O/P+
(Q^R^S^T))+U
FAP:UC-BCF 44
