arrays, lists, stacks, queues, trees - school of computing
TRANSCRIPT
![Page 1: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/1.jpg)
Arrays, Lists, Stacks, Queues,Trees
Chionh Eng WeeComputer Science Department
School of [email protected]
May 22, 2004
AbstractIn C and Pascal, arrays and records are
the simplest aggregating mechanisms. Morecomplicated data structures such as lists, stacks,queues, and trees can be built on top of (1)arrays whose elements can be records, or (2)records with pointers, or (3) both arrays andrecords.
This talk is mainly about implementation andis based on C.
NUS
![Page 2: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/2.jpg)
Overview of Data Structures 2004/05/15
Arrays
• The simplest aggregating mechanism in C and Pascal.
• An array has two parts: indices and elements.
• The disadvantage of arrays.
An array has a fixed size (number of elements).
• The advantage of arrays.
Its elements can be accessed directly and simply when the index value ofan element is known.
NUS 1
![Page 3: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/3.jpg)
Overview of Data Structures 2004/05/15
Using Arrays
When using arrays in a programming language, we need to know thefollowing:
• What are the allowable types for the index and the element?
• How is an array defined and initialized?
• Can the size of an array be determined at execution time?
• Are out of range indices caught at run-time?
NUS 2
![Page 4: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/4.jpg)
Overview of Data Structures 2004/05/15
C Arrays
• The size must be either declared/allocated explicitly or implied byinitialization.
• The index expression must evaluate to an integer and is expected to bein the range 0..size−1 inclusively.
• Define using either [] or dynamic allocation.
• Some C compilers support variable-size arrays defined with [] but this isnot ANSI. Find out using “gcc -ansi -pedantic”.
• No range checking during both compile time and run time.
NUS 3
![Page 5: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/5.jpg)
Overview of Data Structures 2004/05/15
Example: Variable-Size Arrays with []
$ cat 3.csee( int s ){char a, b[s], c;
printf( "%4d %08x %08x %08x\n", s, &a, &b[0], &c );}
main( int ac, char *av[] ){see( 1 ); see( 10 ); see( 100 ); see( 1000 );
}
NUS 4
![Page 6: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/6.jpg)
Overview of Data Structures 2004/05/15
Example: Compile and Execute
$ gcc -ansi -pedantic 3.c3.c: In function ‘see’:3.c:3: warning: ANSI C forbids variable-size array ‘b’
$ a.out1 ffbef7c7 ffbef7b8 ffbef7c6
10 ffbef7c7 ffbef7b0 ffbef7c6100 ffbef7c7 ffbef758 ffbef7c61000 ffbef7c7 ffbef3d8 ffbef7c6
NUS 5
![Page 7: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/7.jpg)
Overview of Data Structures 2004/05/15
Multi-Dimensional Variable-Size C Arrays
• Use #define for multiple indices.
• Use calloc() to allocate storage and initialize it to zero.
• We still think in terms of the indices, how the indices affect the actualstorage location does not affect the application logic.
NUS 6
![Page 8: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/8.jpg)
Overview of Data Structures 2004/05/15
Example: 2-Dimensional Variable-Size Arrays
$ cat 4.c#include <stdlib.h>
#define IDX(i,j) ((i)*n + (j))
main( int ac, char *av[] ){int *x, m, n, i, j, k;
if( ac < 3 ) {printf( "a.out m n\n" );return -1;
}
NUS 7
![Page 9: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/9.jpg)
Overview of Data Structures 2004/05/15
m = atoi( av[1] );n = atoi( av[2] );
x = calloc( m*n, sizeof(int) );
for( k = i = 0; i < m; i++ )for( j = 0; j < n; j++ )x[IDX(i,j)] = k++;
for( k = 0; k < m*n; k++ ) {if( !(k % n) ) printf( "\n" );printf( " %d", x[k] );
}printf( "\n" );
}
NUS 8
![Page 10: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/10.jpg)
Overview of Data Structures 2004/05/15
$ cc 4.c$ a.out 2 3
0 1 23 4 5$ a.out 3 2
0 12 34 5
NUS 9
![Page 11: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/11.jpg)
Overview of Data Structures 2004/05/15
Another Example
$ cat 4a.c#include <stdlib.h>
#define IDX(i,j) ((i) + (j)*m)
main( int ac, char *av[] ){int *x, m, n, i, j, k;
if( ac < 3 ) {printf( "a.out m n\n" );return -1;
}
NUS 10
![Page 12: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/12.jpg)
Overview of Data Structures 2004/05/15
m = atoi( av[1] );n = atoi( av[2] );
x = calloc( m*n, sizeof(int) );
for( k = i = 0; i < m; i++ )for( j = 0; j < n; j++ )x[IDX(i,j)] = k++;
for( k = 0; k < m*n; k++ ) {if( !(k % m) ) printf( "\n" );printf( " %d", x[k] );
}printf( "\n" );
}
NUS 11
![Page 13: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/13.jpg)
Overview of Data Structures 2004/05/15
$ cc 4a.c$ a.out 2 3
0 31 42 5$ a.out 3 2
0 2 41 3 5
NUS 12
![Page 14: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/14.jpg)
Overview of Data Structures 2004/05/15
Variable-Size 3-Dimensional Arrays
Let the indices be i, j, k and
i = 0, · · · , l − 1
j = 0, · · · ,m− 1
k = 0, · · · , n− 1
The storage for an element indexed by (i, j, k) withinan area for lmn elements can be allocated as any of:
imn+ jn+ kimn+ j + kmin+ jln+ ki+ jln+ kli+ jl + klmim+ j + klm
NUS 13
![Page 15: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/15.jpg)
Overview of Data Structures 2004/05/15
Example: Variable-Size 3-Dimensional Arrays
#include <stdlib.h>
#define Xijk(i,j,k) ((i)*m*n+(j)*n+(k))#define Xikj(i,j,k) ((i)*m*n+(k)*m+(j))#define Xjik(i,j,k) ((j)*l*n+(i)*n+(k))#define Xjki(i,j,k) ((j)*l*n+(k)*l+(i))#define Xkij(i,j,k) ((k)*l*m+(i)*m+(j))#define Xkji(i,j,k) ((k)*l*m+(j)*l+(i))
NUS 14
![Page 16: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/16.jpg)
Overview of Data Structures 2004/05/15
main( int ac, char *av[] ){int i, j, k, l, m, n, *A, cnt;
if( ac < 4 ) {printf( "a.out l m n\n" );return -1;
}
l = atoi( av[1] );m = atoi( av[2] );n = atoi( av[3] );
A = calloc( l*m*n, sizeof(int) );
NUS 15
![Page 17: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/17.jpg)
Overview of Data Structures 2004/05/15
cnt = 0;for( i = 0; i < l; i++ )for( j = 0; j < m; j++ )for( k = 0; k < n; k++ )
A[Xijk(i,j,k)] = cnt++;for(cnt = 0; cnt < l*m*n; cnt++) printf( " %d", A[cnt] );printf( "\n" );
cnt = 0;for( i = 0; i < l; i++ )for( j = 0; j < m; j++ )for( k = 0; k < n; k++ )
A[Xikj(i,j,k)] = cnt++;for(cnt = 0; cnt < l*m*n; cnt++) printf( " %d", A[cnt] );printf( "\n" );
NUS 16
![Page 18: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/18.jpg)
Overview of Data Structures 2004/05/15
cnt = 0;for( i = 0; i < l; i++ )for( j = 0; j < m; j++ )for( k = 0; k < n; k++ )
A[Xjik(i,j,k)] = cnt++;for(cnt = 0; cnt < l*m*n; cnt++) printf( " %d", A[cnt] );printf( "\n" );
cnt = 0;for( i = 0; i < l; i++ )for( j = 0; j < m; j++ )for( k = 0; k < n; k++ )
A[Xjki(i,j,k)] = cnt++;for(cnt = 0; cnt < l*m*n; cnt++) printf( " %d", A[cnt] );printf( "\n" );
NUS 17
![Page 19: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/19.jpg)
Overview of Data Structures 2004/05/15
cnt = 0;for( i = 0; i < l; i++ )for( j = 0; j < m; j++ )for( k = 0; k < n; k++ )
A[Xkij(i,j,k)] = cnt++;for(cnt = 0; cnt < l*m*n; cnt++) printf( " %d", A[cnt] );printf( "\n" );
cnt = 0;for( i = 0; i < l; i++ )for( j = 0; j < m; j++ )for( k = 0; k < n; k++ )
A[Xkji(i,j,k)] = cnt++;for(cnt = 0; cnt < l*m*n; cnt++) printf( " %d", A[cnt] );printf( "\n" );
}
NUS 18
![Page 20: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/20.jpg)
Overview of Data Structures 2004/05/15
$ a.out 2 2 30 1 2 3 4 5 6 7 8 9 10 110 3 1 4 2 5 6 9 7 10 8 110 1 2 6 7 8 3 4 5 9 10 110 6 1 7 2 8 3 9 4 10 5 110 3 6 9 1 4 7 10 2 5 8 110 6 3 9 1 7 4 10 2 8 5 11
NUS 19
![Page 21: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/21.jpg)
Overview of Data Structures 2004/05/15
Records
• We may say an array is a homogeneous record (treatarray elements as fields within a record) and a recordis a heterogeneous array (treat record fields as arrayelements).
• Record structure is perhaps the next simplestaggregating mechanism in C and Pascal.
• In C, the keyword struct defines a record.
• The member operator “·” or the pointer operator“->” are used to access the fields of a record.
• An element of an array and a field of a record canbe accessed directly. But unlike arrays, there is noway to step through the fields of a record in a loop.
NUS 20
![Page 22: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/22.jpg)
Overview of Data Structures 2004/05/15
Disadvantages of Arrays
Arrays are fixed size. Even with variable-size arrays (not supported inANSI), once created, the size cannot be changed.
Another disadvantage is that elements cannot be inserted or deletedeasily. To insert or delete an element, other elements following the elementhave to be moved.
NUS 21
![Page 23: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/23.jpg)
Overview of Data Structures 2004/05/15
Advantages of Lists
• Lists are a very flexible structure:
• A list grows and shrinks on demand.
• Elements can be inserted or deleted at any position within a list withoutmoving other list elements.
• But unlike arrays, a list element cannot be accessed directly even whenyou know where it is within a list.
NUS 22
![Page 24: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/24.jpg)
Overview of Data Structures 2004/05/15
Lists
Mathematically, a list is a sequence of elements
e1, e2, · · · , en
that supports the following operations, among others:
• Insert an element x at certain list position:
e1, · · · , ei, x, ei+1, · · · , en
• Delete an element:
e1, · · · , ei−1, ei+1, · · · , en
• Find an element ei in the list based on someproperties of ei.
• Print some attributes of each list element in theirlist order.
NUS 23
![Page 25: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/25.jpg)
Overview of Data Structures 2004/05/15
More List Operations
The above operations act on a single list.
For two lists, concatenation of one list to the end of another is also animportant operation.
NUS 24
![Page 26: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/26.jpg)
Overview of Data Structures 2004/05/15
Example: Lists
#include <stdio.h>
struct node {int value;struct node *next;
};
NUS 25
![Page 27: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/27.jpg)
Overview of Data Structures 2004/05/15
struct node * printList( struct node * l ){struct node *t = l;
while( l ) {printf( " %d", l->value );l = l->next;
}printf( "\n" );
return t;}
NUS 26
![Page 28: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/28.jpg)
Overview of Data Structures 2004/05/15
struct node * concatList( struct node * f, struct node * b ){struct node * h = f;
if( !f ) return b;if( !b ) return f;
while( f->next ) f = f->next;f->next = b;
return h;}
NUS 27
![Page 29: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/29.jpg)
Overview of Data Structures 2004/05/15
struct node * deleteList( struct node * l, int v ){struct node *p, *n;
if( !l ) return l;
if( l->value == v ) { n = l->next; free( l ); return n; }
n = l;while( n && n->value != v ) { p = n; n = n->next; }if( n && n->value == v ) {
p->next = n->next; free( n );}return l;
}
NUS 28
![Page 30: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/30.jpg)
Overview of Data Structures 2004/05/15
main( int ac, char *av[] ){struct node *a, *b, *t;
/* a single element list: 1 */a = (struct node *) calloc( 1, sizeof(struct node) );a->value = 1;
/* another single element list: 9 */b = (struct node *) calloc( 1, sizeof(struct node) );b->value = 9;
printList( a );
NUS 29
![Page 31: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/31.jpg)
Overview of Data Structures 2004/05/15
/* a 2-element list: 1, 9 */a->next = b;
printList( a );
b = (struct node *) calloc( 1, sizeof(struct node) );b->value = 5;
/* a 3-element list: 1, 5, 9 */t = a->next;a->next = b;b->next = t;printList( a );
NUS 30
![Page 32: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/32.jpg)
Overview of Data Structures 2004/05/15
/* a 2-element list: 13, 19 */b = (struct node *) calloc( 1, sizeof(struct node) );b->value = 13;b->next = (struct node *) calloc(1,sizeof(struct node));b->next->value = 19;printList( b );
/* a 5-element list: 1, 5, 9, 13, 19 */a = concatList( a, b );printList( a );
a = printList( deleteList( a, 13 ) );a = printList( deleteList( deleteList( a, 1 ), 19 ) );a = printList( deleteList( a, 5 ) );
}
NUS 31
![Page 33: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/33.jpg)
Overview of Data Structures 2004/05/15
$ cc 5.c
$ a.out11 91 5 913 191 5 9 13 191 5 9 195 99
NUS 32
![Page 34: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/34.jpg)
Overview of Data Structures 2004/05/15
List Variants
The above list is known as a singly linked list.
A singly link list can also be given by two pointers, head and tail, sothat both the first and the last elements can be accessed immediately.
If it is important to traverse the list both forward and backward, thedoubly linked list should be used.
NUS 33
![Page 35: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/35.jpg)
Overview of Data Structures 2004/05/15
Stacks
Mathematically a stack is a list with a restricted insert (push) and arestricted delete (pop). An element can only be inserted to become thefirst (top) element and only the first (top) element can be deleted. Thus astack has only one end, the top of the stack, and enforces a last-in-first-outdiscipline.
For example, the stack is initially empty, after the following operations:
push(1), push(2), pop(), push(3), push(4), pop(), pop(), push(5)
NUS 34
![Page 36: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/36.jpg)
Overview of Data Structures 2004/05/15
the stack contents are
21 ⇒
431
⇒ 51
NUS 35
![Page 37: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/37.jpg)
Overview of Data Structures 2004/05/15
Postfix Expressions
A postfix expression has the wonderful propertythat its order of evaluation is completely determinedby the expression itself without the need of parenthesesand rules of precedence and association.
Formally, postfix expressions are expressionsgenerated by the rules:
E → EEO
E → number
O → + | − | ∗ | /
For example,
E0∗⇒ E1E2 +∗⇒ E1E5E6 ∗+∗⇒ E3E4 + E5E6 ∗+∗⇒ E7E8 ∗ E4 + E5E6 ∗+
NUS 36
![Page 38: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/38.jpg)
Overview of Data Structures 2004/05/15
Evaluating Postfix Expressions
Postfix expressions can be easily evaluated by a stack:
1. Read next symbol X.
2. If X is EOF then return pop().
3. If X is an operator then L = pop(), R = pop(), push( L X R ); else push(X ).
4. Goto 1.
NUS 37
![Page 39: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/39.jpg)
Overview of Data Structures 2004/05/15
Example: Evaluating Postfix Expressions
#include <stdio.h>#include <stdlib.h>#include <strings.h>
struct node {int value;struct node *next;
};
NUS 38
![Page 40: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/40.jpg)
Overview of Data Structures 2004/05/15
struct node * push( struct node **stack, int value ){struct node *s;
s = (struct node *)calloc( 1, sizeof(struct node) );
s->value = value;s->next = *stack;*stack = s;return s;
}
NUS 39
![Page 41: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/41.jpg)
Overview of Data Structures 2004/05/15
int pop( struct node ** stack ){int v;struct node *s;
if( ! *stack ) {printf( "poping empty stack\n" );exit( -1 );
}
s= *stack;v = s->value;*stack = s->next;free(s);return v;
}
NUS 40
![Page 42: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/42.jpg)
Overview of Data Structures 2004/05/15
void print( struct node * stack ){while( stack ) {
printf( " %d", stack->value );stack = stack->next;
}printf( "\n" );
}
NUS 41
![Page 43: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/43.jpg)
Overview of Data Structures 2004/05/15
main( int ac, char *av[] ){struct node *s = NULL;int i, result, left, rite;char *c;
if( ac < 2 ) {printf( "a.out strings\n" );return -1;
}
NUS 42
![Page 44: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/44.jpg)
Overview of Data Structures 2004/05/15
for( i = 1; i <= ac-1; i++ ) {
if( strcmp( av[i], "+" ) == 0 ) {push( &s, pop(&s) + pop(&s) );print( s );continue;
}
if( strcmp( av[i], "x" ) == 0 ) {push( &s, pop(&s) * pop(&s) );print( s );continue;
}
NUS 43
![Page 45: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/45.jpg)
Overview of Data Structures 2004/05/15
if( strcmp( av[i], "-" ) == 0 ) {rite = pop( &s );left = pop( &s );push( &s, left - rite );print( s );continue;
}
if( strcmp( av[i], "/" ) == 0 ) {rite = pop( &s );left = pop( &s );push( &s, left / rite );print( s );continue;
}
NUS 44
![Page 46: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/46.jpg)
Overview of Data Structures 2004/05/15
push( &s, atoi( av[i] ) );print( s );
}printf( "%d\n", pop(&s) );
}
NUS 45
![Page 47: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/47.jpg)
Overview of Data Structures 2004/05/15
$ cc 7.c
$ a.out 6 5 2 3 + 8 x + 3 + x65 62 5 63 2 5 65 5 68 5 5 640 5 645 63 45 648 6288288
NUS 46
![Page 48: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/48.jpg)
Overview of Data Structures 2004/05/15
Implementing Stacks Using Arrays
Depending on the problem, sometimes it is very convenient to implementstacks using arrays. In order to do this the array must be large enough tohold the highest possible stack.
The following example checks if a sequence of (, ), [, ], {, }, isbalanced. Such a sequence is balanced if after repeatedly canceling pairs of( ), [ ], { }, there are no symbols left.
NUS 47
![Page 49: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/49.jpg)
Overview of Data Structures 2004/05/15
Example: Stacks by Arrays
char *Stack;int Top = -1;
void push( char value ){Stack[++Top] = value;
}
char pop(){if( Top < 0 ) return -1;return Stack[Top--];
}
NUS 48
![Page 50: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/50.jpg)
Overview of Data Structures 2004/05/15
main( int ac, char *av[] ){int i;char c;
if( ac < 2 ) return 0;
Stack = (char*)calloc(ac-1,sizeof(char));Top = -1;
NUS 49
![Page 51: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/51.jpg)
Overview of Data Structures 2004/05/15
for( i = 1; i <= ac-1; i++ ) {c = av[i][0];switch( c ) {case ’(’: case ’[’: case ’{’:push( c ); break;
case ’)’:if( ’(’ != pop() ) return -1;break;
case ’]’:if( ’[’ != pop() ) return -1;break;
case ’}’:if( ’{’ != pop() ) return -1;break;
default:
NUS 50
![Page 52: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/52.jpg)
Overview of Data Structures 2004/05/15
return -1;}
}
if( Stack[Top] != 0 ) return -1;else return 0;
}
NUS 51
![Page 53: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/53.jpg)
Overview of Data Structures 2004/05/15
$ cc 8.c
$ a.out [$ echo $?255
$ a.out [ ]$ echo $?0
$ a.out [ [ { } ] ] { { ] ]$ echo $?255
$ a.out [ [ { } ] ] { [ ] }$ echo $?
NUS 52
![Page 54: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/54.jpg)
Overview of Data Structures 2004/05/15
0
$ a.out [ { ] }$ echo $?255
NUS 53
![Page 55: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/55.jpg)
Overview of Data Structures 2004/05/15
Queues
Like stacks, mathematically a queue is a list with a restricted insert(enqueue) and a restriced delete (dequeue). An element can only beinserted to become the last element and only the first element can bedeleted. Thus a queue has two ends front and rear (also called head andtail) and enforces a first-in-first-out discipline.
For example, with an initially empty queue, after the operations
enq(1), enq(4), enq(5), deq(), enq(3), deq(), enq(6);
the queue contents are5, 3, 6.
NUS 54
![Page 56: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/56.jpg)
Overview of Data Structures 2004/05/15
Example: A Queue Application
Consider the following cube:
HHHHH
HHHHHHH
HHHHHHH
H
��������
����
HHHHHH
HHHHHHH
HHH
��
��
���
�
HHHHH
HHHHHH
HHHHH
��������HHHHHH
HHHHHH
HHHH
��
��
���
�000
001
100
101
010
011
110
111t
t
t
t
t
t
t
t
List vertices connected to a given vertex by“distance”. (Breadth first search in disguise.)
NUS 55
![Page 57: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/57.jpg)
Overview of Data Structures 2004/05/15
The Program
#define IX(i,j) ((i)*Vertex_Count+(j))
int Vertex_Count;char *Visited;char *Adjacency;
struct node {int value;struct node *next;
};
struct node *Head = 0, *Tail = 0;
NUS 56
![Page 58: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/58.jpg)
Overview of Data Structures 2004/05/15
int empty(){return (Head == 0);
}
NUS 57
![Page 59: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/59.jpg)
Overview of Data Structures 2004/05/15
struct node * enqueue( int v ){struct node *n;
n = (struct node *)calloc( 1, sizeof(struct node) );
n->value = v;if( ! Tail )
Head = Tail = n;else {
Tail->next = n;Tail = n;
}}
NUS 58
![Page 60: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/60.jpg)
Overview of Data Structures 2004/05/15
int dequeue() {int value;struct node *h;
if( !Head ) {printf( "dequeue empty queue\n" );exit( -1 );
}h = Head;value = h->value;Head = h->next;if( ! Head ) Tail = Head;free( h );return value;
}
NUS 59
![Page 61: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/61.jpg)
Overview of Data Structures 2004/05/15
void breadthFirstSearch( int v ){int x, y;
Visited[v] = 1;enqueue( v );
while( ! empty() ) {x = dequeue();for( y = 0; y < Vertex_Count; y++ ) {if( Adjacency[IX(x,y)] ) {
if( ! Visited[y] ) {Visited[y] = 1;enqueue( y );printf( "%d %d\n", x, y );
}
NUS 60
![Page 62: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/62.jpg)
Overview of Data Structures 2004/05/15
}}
}}
NUS 61
![Page 63: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/63.jpg)
Overview of Data Structures 2004/05/15
main( int ac, char *av[] ){int e, i, x, y;
scanf( "%d", &Vertex_Count );
Visited = (char *)calloc(Vertex_Count,sizeof(char));
Adjacency = (char *)calloc( Vertex_Count*Vertex_Count,sizeof(char) );
scanf( "%d", &e );for( i = 0; i < e; i++ ) {
scanf( "%d %d", &x, &y );
NUS 62
![Page 64: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/64.jpg)
Overview of Data Structures 2004/05/15
Adjacency[IX(x,y)] =Adjacency[IX(y,x)] = 1;
}
breadthFirstSearch( atoi( av[1] ) );}
NUS 63
![Page 65: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/65.jpg)
Overview of Data Structures 2004/05/15
Cube Data
8120 10 20 41 31 52 32 63 74 54 65 76 7
$ for i in 0 1 2 3 4 5 6 7> do> echo start at vertex $i> a.out $i < cube> done
NUS 64
![Page 66: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/66.jpg)
Overview of Data Structures 2004/05/15
Output
start at vertex 00 10 20 41 31 52 63 7start at vertex 11 01 31 50 20 43 72 6
NUS 65
![Page 67: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/67.jpg)
Overview of Data Structures 2004/05/15
start at vertex 22 02 32 60 10 43 71 5start at vertex 33 13 23 71 01 52 60 4
NUS 66
![Page 68: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/68.jpg)
Overview of Data Structures 2004/05/15
start at vertex 44 04 54 60 10 25 71 3start at vertex 55 15 45 71 01 34 60 2
NUS 67
![Page 69: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/69.jpg)
Overview of Data Structures 2004/05/15
start at vertex 66 26 46 72 02 34 50 1start at vertex 77 37 57 63 13 25 41 0
NUS 68
![Page 70: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/70.jpg)
Overview of Data Structures 2004/05/15
Trees
Arrays, lists, stacks, queues represent linear structures. To representnon-linear hierarchical structures, trees are used.
In computing, a tree is a collection of nodes with some parent-childrelationship. This relationship can be defined recursively as follows:
1. A single node is a tree with itself as the root of the tree.
2. If n is a node and T1, · · ·, Tk are trees with roots n1, · · ·, nk respectively.A new tree can be constructed with n as the root and T1, · · ·, Tk assubtrees of the root. In this new tree, nodes n1, · · ·, nk are called thechildren of node n. Node n is known as the parent of nodes n1, · · ·, nk.
NUS 69
![Page 71: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/71.jpg)
Overview of Data Structures 2004/05/15
Representing Trees
• By one parent array.
n nodes are identified with integers 0, · · ·, n−1. The parent of i is givenby the array P [i].
• By child/sibling lists.
Each node is represented as a record which includes two fields FirstChildand NextSibling.
• By an array of child lists.
n nodes are identified with integers 0, · · ·, n− 1. Array element C[i] isa list of the children of node i
NUS 70
![Page 72: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/72.jpg)
Overview of Data Structures 2004/05/15
Example: Representing Trees
5 6 7 10
3 4 8 9
1 2
0����
����
HHHH
HHHH
���
@@@
���
@@@
���
@@@
The parent-of array:
−1 0 0 1 1 4 4 4 2 2 9
NUS 71
![Page 73: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/73.jpg)
Overview of Data Structures 2004/05/15
Example: Representing Trees
5 6 7 10
3 4 8 9
1 2
0����
����
HHHH
HHHH
���
@@@
���
@@@
���
@@@
The children-of array/lists:
L0 L1 L2 0 L4 0 0 0 0 L9 0
L0 → 1, 2. L1 → 4, 5. L2 → 8, 9. L4 → 6, 7, 8.
NUS 72
![Page 74: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/74.jpg)
Overview of Data Structures 2004/05/15
Example: Representing Trees
A possible list node structure:
struct FirstSibling {int element;struct FirstSibling *first;struct FirstSibling *sibling;
};
NUS 73
![Page 75: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/75.jpg)
Overview of Data Structures 2004/05/15
Use horizontal line and vertical line to represent first and sibling listrespectively, the tree in the previous example is
0|1 ---- 2| || 8 ---- 9| |3 ---- 4 10
|5 ---- 6 ---- 7
NUS 74
![Page 76: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/76.jpg)
Overview of Data Structures 2004/05/15
Tree Traversal
One of the important tree operations is treetraversal. There are three ways (orders) to traverse atree: preorder, inorder, postorder. These orderings aredefined recursively as follows:
1. If a tree has only the root, the root by itself is thepreorder, inorder, postorder traversal of the tree.
2. If a tree has root n and subtrees T1, · · ·, Tk.
The preorder traversal of the tree is
n, preorder(T1), · · · , preorder(Tk)
The inorder traversal of the tree is
inorder(T1), n, inorder(T2), · · · , inorder(Tk)
The postorder traversal of the tree is
postorder(T1), · · · , postorder(Tk), n
NUS 75
![Page 77: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/77.jpg)
Overview of Data Structures 2004/05/15
Example: Preorder Traversal
• The given tree:
0|1 ---- 2| || 8 ---- 9| |3 ---- 4 10
|5 ---- 6 ---- 7
NUS 76
![Page 78: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/78.jpg)
Overview of Data Structures 2004/05/15
• 0, subtree with root 1, subtree with root 2:
0 1 2| || 8 ---- 9| |3 ---- 4 10
|5 ---- 6 ---- 7
• 0, 1, subtree with roots 3, 4; 2, subtrees of roots 8,9:
0 1 3 4 2 8 9| |5 ---- 6 ---- 7 10
• The inorder traversal of the given tree:
0 1 3 4 5 6 7 2 8 9 10
NUS 77
![Page 79: Arrays, Lists, Stacks, Queues, Trees - School of Computing](https://reader031.vdocuments.site/reader031/viewer/2022021006/62038812da24ad121e4a8060/html5/thumbnails/79.jpg)
Overview of Data Structures 2004/05/15
Example: Inorder and Postorder
Similarly, the inorder traversal of the given tree is:
3 1 5 4 6 7 0 8 2 10 9
The postorder traversal of the given tree is:
3 5 6 7 4 1 8 10 9 2 0
NUS 78