0% found this document useful (0 votes)

532 views

DSC Notes

This document outlines the topics and units covered in the course "Data Structures with C". The course is divided into 8 units that cover fundamental data structures like arrays, stacks, queues, linked lists, trees, graphs, and priority queues. Specific topics include pointers, dynamic memory allocation, binary trees, binary search trees, disjoint sets, binomial heaps, and efficient binary search trees like AVL trees and red-black trees. The course aims to teach how to represent and implement these common data structures in the C programming language.

Uploaded by

Azeez Mysore

Available Formats

Download as PDF, TXT or read online on Scribd

0% found this document useful (0 votes)

532 views

DSC Notes

Uploaded by

Azeez Mysore

Available Formats

Download as PDF, TXT or read online on Scribd

You are on page 1/ 119

DATA STRUCTERS WITH C DATA STRUCTURES WITH C (Common to CSE & ISE)

10CS35

Subject Code: 10CS35 Hours/Week : 04 Total Hours : 52

UNIT - 1 8 Hours BASIC CONCEPTS: Pointers and Dynamic Memory Allocation, Algorithm Specification, Data Abstraction, Performance Analysis, Performance Measurement UNIT -2 6 Hours ARRAYS and STRUCTURES: Arrays, Dynamically Allocated Arrays, Structures and Unions, Polynomials, sparse Matrices, Representation of Multidimensional Arrays UNIT - 3 6 Hours STACKS AND QUEUES: Stacks, Stacks Using Dynamic Arrays, Queues, Circular Queues Using Dynamic Arrays, Evaluation of Expressions, Multiple Stacks and Queues. UNIT - 4 6 Hours LINKED LISTS: Singly Linked lists and Chains, Representing Chains in C, Linked Stacks and Queues, Polynomials, Additional List operations, Sparse Matrices, Doubly Linked Lists PART - B UNIT - 5 6 Hours TREES 1: Introduction, Binary Trees, Binary Tree Traversals, Threaded Binary Trees, Heaps. UNIT 6 6 Hours TREES 2, GRAPHS: Binary Search Trees, Selection Trees, Forests, Representation of Disjoint Sets, Counting Binary Trees, The Graph Abstract Data Type. UNIT - 7 6 Hours PRIORITY QUEUES Single- and Double-Ended Priority Queues, Leftist Trees, Binomial Heaps, Fibonacci Heaps, Pairing Heaps. UNIT - 8 8 Hours EFFICIENT BINARY SEARCH TREES: Optimal Binary Search Trees, AVL Trees, Red-Black Trees, Splay Trees.
Text Book: 1. Horowitz, Sahni, Anderson-Freed: Fundamentals of Data Structures in C, 2nd Edition, Universities Press, 2007. (Chapters 1, 2.1 to 2.6, 3, 4, 5.1 to 5.3, 5.5 to 5.11, 6.1, 9.1 to 9.5, 10) Reference Books: 1. Yedidyah, Augenstein, Tannenbaum: Data Structures Using C and C++, 2nd Edition, Pearson Education, 2003. 2. Debasis Samanta: Classic Data Structures, 2nd Edition, PHI, 2009. 3. Richard F. Gilberg and Behrouz A. Forouzan: Data Structures A Pseudocode Approach with C, Cengage Learning, 2005. 4. Robert Kruse & Bruce Leung: Data Structures & Program Design in C, Pearson Education, 2007.

PART A

I.A. Marks : 25 Exam Hours: 03 Exam Marks: 100

DEPT OF CSE, SJBIT

Page 1

DATA STRUCTERS WITH C

10CS35

printf ("\n p = %d", *p); //Display 100 ofcourse. return 0; }

1.5. Performance Measurement:

Performance measurement is the process whereby an organization establishes the parameters within which programs, investments, and acquisitions are reaching the desired results. Good Performance Measures: Provide a way to see if our strategy is working Focus employees' attention on what matters most to success DEPT OF CSE, SJBIT Page 11

DATA STRUCTERS WITH C

Allow measurement of accomplishments, not just of the work that is performed Provide a common language for communication

10CS35

Are explicitly defined in terms of owner, unit of measure, collection frequency, data quality, expected value(targets), and thresholds Are valid, to ensure measurement of the right things Are verifiable, to ensure data collection accuracy EX-

Performance Reference Model of the Federal Enterprise Architecture, This process of measuring performance often requires the use of statistical evidence to determine progress toward specific defined organizational objectives. Performance measurement is a fundamental building block of TQM and a total quality organization. Historically, organisations have always measured performance in some way through the financial performance, be this success by profit or failure through liquidation. However, traditional performance measures, based on cost accounting information, provide little to support organizations on their quality journey, because they do not map process performance and improvements seen by the customer. In a successful total quality organisation, performance will be measured by the improvements seen by the customer as well as by the results delivered to other stakeholders, such as the shareholders. This section covers why measuring performance is important. This is followed by a description of cost of quality measurement, which has been used for many years to drive improvement activities and raise awareness of the effect of quality problems in an organisation.

DEPT OF CSE, SJBIT

Page 12

DATA STRUCTERS WITH C

10CS35

A simple performance measurement framework is outlined, which includes more than just measuring, but also defining and understanding metrics, collecting and analysing data, then prioritising and taking improvement actions. A description of the balanced scorecard approach is also covered. Why measure performance? When you can measure what you are speaking about and express it in numbers, you know something about it. You cannot manage what you cannot measure. These are two often-quoted statements that demonstrate why measurement is important. Yet it is surprising that organisations find the area of measurement so difficult to manage. In the cycle of never-ending improvement, performance measurement plays an important role in: Identifying and tracking progress against organisational goals Identifying opportunities for improvement Comparing performance against both internal and external standards Reviewing the performance of an organisation is also an important step when formulating the direction of the strategic activities. It is important to know where the strengths and weaknesses of the organisation lie, and as part of the Plan Do Check Act cycle, measurement plays a key role in quality and productivity improvement activities. The main reasons it is needed are: To ensure customer requirements have been met To be able to set sensible objectives and comply with them To provide standards for establishing comparisons To provide visibility and a scoreboard for people to monitor their own performance level To highlight quality problems and determine areas for priority attention To provide feedback for driving the improvement effort It is also important to understand the impact of TQM on improvements in business performance, on sustaining current performance and reducing any possible decline in performance.

1.6 RECOMMENDED QUESTIONS

1. Define Data Structures? 2.What is a pointer variable? 3. Difference between Abstract Data Type, Data Type and Data Structure? 4. Define an Abstract Data Type (ADT)? 5. Give any 2 advantages and disadvantages of using pointers? DEPT OF CSE, SJBIT Page 13

DATA STRUCTERS WITH C

10CS35

2.1 ARRAY:
Declaring Arrays :

UNIT -2 : ARRAYS and STRUCTURES

Definition :Array by definition is a variable that hold multiple elements which has the same data type.

We can declare an array by specify its data type, name and the number of elements the array holds between square brackets immediately following the array name. Here is the syntax:

data_type array_name[size];

For example, to declare an integer array which contains 100 elements we can do as follows:

int a[100];

There are some rules on array declaration. The data type can be any valid C data types including structure and union. The array name has to follow the rule of variable and the size of array has to be a positive constant integer.We can access array elements via indexes array_name[index]. Indexes of array starts from 0 not 1 so the highest elements of an array is array_name[size-1] Initializing Arrays : It is like a variable, an array can be initialized. To initialize an array, you provide initializing values which are enclosed within curly braces in the declaration and placed following an equals sign after the array name. Here is an example of initializing an integer array.

int list[5] = {2,1,3,7,8};

Array Representation

Operations require simple implementations. Insert, delete, and search, require linear time Inefficient use of space
It is appropriate that we begin our study of data structures with the array. The array is often the only means for structuring data which is provided in a programming language. Therefore it deserves a significant amount of attention. If one asks a group of programmers to define an array, the most often quoted saying is: a consecutive set of memory locations. This is unfortunate because it clearly reveals a common point of confusion, namely the distinction between a data structure and its representation. It is true that arrays are almost always implemented by using consecutive memory, but not always. Intuitively, an array is a set of pairs, index and value. For each index which is defined, there is a value DEPT OF CSE, SJBIT

Page 14

DATA STRUCTERS WITH C

10CS35

associated with that index. In mathematical terms we call this a correspondence or a mapping. However, as computer scientists we want to provide a more functional definition by giving the operations which are permitted on this data structure. For arrays this means we are concerned with only two operations which retrieve and store values. Using our notation this object can be defined as: structure ARRAY(value, index) declare CREATE( ) array RETRIEVE(array,index) value STORE(array,index,value) array; for all A array, i,j index, x value let RETRIEVE(CREATE,i) :: = error RETRIEVE(STORE(A,i,x),j) :: = if EQUAL(i,j) then x else RETRIEVE(A,j) end end ARRAY The function CREATE produces a new, empty array. RETRIEVE takes as input an array and an index, and either returns the appropriate value or an error. STORE is used to enter new index-value pairs. The second axiom is read as "to retrieve the j-th item where x has already been stored at index i in A is equivalent to checking if i and j are equal and if so, x, or search for the j-th value in the remaining array, A." This axiom was originally given by J. McCarthy. Notice how the axioms are independent of any representation scheme. Also, i and j need not necessarily be integers, but we assume only that an EQUAL function can be devised. If we restrict the index values to be integers, then assuming a conventional random access memory we can implement STORE and RETRIEVE so that they operate in a constant amount of time. If we interpret the indices to be n-dimensional, (i1,i2, ...,in), then the previous axioms apply immediately and define ndimensional arrays. In section 2.4 we will examine how to implement RETRIEVE and STORE for multidimensional arrays using consecutive memory locations. Array and Pointer: Each array element occupies consecutive memory locations and array name is a pointer that points to the first element. Beside accessing array via index we can use pointer to manipulate array. This program helps you visualize the memory address each array elements and how to access array element using pointer.

01 #include <stdio.h> 02 03 void main() 04 { 05 06 const int size = 5;

Page 15

DEPT OF CSE, SJBIT

DATA STRUCTERS WITH C 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 }

Here is the output DEPT OF CSE, SJBIT

10CS35

int list[size] = {2,1,3,7,8};

int* plist = list;

// print memory address of array elements for(int i = 0; i < size;i++) { printf("list[%d] is in %d\n",i,&list[i]);

// accessing array elements using pointer for(i = 0; i < size;i++) { printf("list[%d] = %d\n",i,*plist);

/* increase memory address of pointer so it go to the next element of the array */ plist++; }

Page 16

DATA STRUCTERS WITH C

list[0] list[1] list[2] list[3] list[4] list[0] list[1] list[2] list[3] list[4] = 8 is is is is is in in in in in

10CS35
1310568 1310572 1310576 1310580 1310584 2 1 3 7

= = = =

You can store pointers in an array and in this case we have an array of pointers. This code snippet uses an array to store integer pointer.

1 int *ap[10];
Multidimensional Arrays: An array with more than one index value is called a multidimensional array. The entire array above is called single-dimensional array. To declare a multidimensional array you can do follow syntax

1 data_type array_name[][][];
The number of square brackets specifies the dimension of the array. For example to declare two dimensions integer array we can do as follows:

1 int matrix[3][3];
Initializing Multidimensional Arrays : You can initialize an array as a single-dimension array. Here is an example of initialize an two dimensions integer array:

1 int matrix[3][3] = 2{ 3 {11,12,13}, 4 {21,22,23}, 5 {32,31,33}, 6 };

Dynamically Allocated Arrays: One-Dimensional Arrays In C, arrays must have their extents defined at compile-time. There's no way to postpone the definition of the size of an array until runtime. Luckily, with pointers and malloc, we can work around this limitation. DEPT OF CSE, SJBIT Page 17

DATA STRUCTERS WITH C

10CS35

To allocate a one-dimensional array of length N of some particular type, simply use malloc to allocate enough memory to hold N elements of the particular type, and then use the resulting pointer as if it were an array. For example, the following code snippet allocates a block of N ints, and then, using array notation, fills it with the values 0 through N-1: int *A = malloc (sizeof (int) * N); int i;

for (i = 0; i < N; i++) A[i] = i; This idea is very useful for dealing with strings, which in C are represented by arrays of chars, terminated with a '\0' character. These arrays are nearly always expressed as pointers in the declaration of functions, but accessed via C's array notation. For example, here is a function that implements strlen: int strlen (char *s) { int i;

for (i = 0; s[i] != '\0'; i++) ; return (i) }

2.2. Dynamically Allocating Multidimensional Arrays

We've seen that it's straightforward to call malloc to allocate a block of memory which can simulate an array, but with a size which we get to pick at run-time. Can we do the same sort of thing to simulate multidimensional arrays? We can, but we'll end up using pointers to pointers. If we don't know how many columns the array will have, we'll clearly allocate memory for each row (as many columns wide as we like) by calling malloc, and each row will therefore be represented by a pointer. How will we keep track of those pointers? There are, after all, many of them, one for each row. So we want to simulate an array of pointers, but we don't know how many rows there will be, either, so we'll have to simulate that array (of pointers) with another pointer, and this will be a pointer to a pointer. This is best illustrated with an example: #include <stdlib.h> int **array; DEPT OF CSE, SJBIT array = malloc(nrows * sizeof(int *)); Page 18

DATA STRUCTERS WITH C

if(array == NULL) { fprintf(stderr, "out of memory\n"); exit or return } for(i = 0; i < nrows; i++) { array[i] = malloc(ncolumns * sizeof(int)); if(array[i] == NULL) { fprintf(stderr, "out of memory\n"); exit or return } }

10CS35

of the array. If this isn't quite making sense, a picture should make everything clear:

array is a pointer-to-pointer-to-int: at the first level, it points to a block of pointers, one for each row. That first-level pointer is the first one we allocate; it has n rows elements, with each element big enough to hold a pointer-to-int, or int *. If we successfully allocate it, we then fill in the pointers (all n rows of them) with a pointer (also obtained from malloc) to n columns number of ints, the storage for that row

Fig1: representation of array Once we've done this, we can (just as for the one-dimensional case) use array-like syntax to access our simulated multidimensional array. If we write array[i][j] we're asking for the i'th pointer pointed to by array, and then for the j'th int pointed to by that inner pointer. (This is a pretty nice result: although some completely different machinery, involving two levels of pointer dereferencing, is going on behind the scenes, the simulated, dynamically-allocated twodimensional ``array'' can still be accessed just as if it were an array of arrays, i.e. with the same pair of bracketed subscripts.). If a program uses simulated, dynamically allocated multidimensional arrays, it DEPT OF CSE, SJBIT Page 19

DATA STRUCTERS WITH C

10CS35

becomes possible to write ``heterogeneous'' functions which don't have to know (at compile time) how big the `àrrays'' are. In other words, one function can operate on `àrrays'' of various sizes and shapes. The function will look something like func2(int **array, int nrows, int ncolumns) { } This function does accept a pointer-to-pointer-to-int, on the assumption that we'll only be calling it with simulated, dynamically allocated multidimensional arrays. (We must not call this function on arrays like the ``true'' multidimensional array a2 of the previous sections). The function also accepts the dimensions of the arrays as parameters, so that it will know how many ``rows'' and ``columns'' there are, so that it can iterate over them correctly. Here is a function which zeros out a pointer-to-pointer, two-dimensional `àrray'': void zeroit(int **array, int nrows, int ncolumns) { int i, j; for(i = 0; i < nrows; i++) { for(j = 0; j < ncolumns; j++) array[i][j] = 0; } } Finally, when it comes time to free one of these dynamically allocated multidimensional `àrrays,'' we must remember to free each of the chunks of memory that we've allocated. (Just freeing the top-level pointer, array, wouldn't cut it; if we did, all the second-level pointers would be lost but not freed, and would waste memory.) Here's what the code might look like: for(i = 0; i < nrows; i++) free(array[i]); free(array);

2.3. Structures and Unions:

Structure:
A structure is a user-defined data type. You have the ability to define a new type of data considerably more complex than the types we have been using. A structure is a collection of one or more variables, possibly of different types, grouped together under a single name for convenient handling. Structures are called records in some languages, notably Pascal. Structures help organize complicated data, DEPT OF CSE, SJBIT Page 20

DATA STRUCTERS WITH C

10CS35

particularly in large programs, because they permit a group of related variables to be treated as a unit instead of as separate entities. Todays application requires complex data structures to support them. A structure is a collection of related elements where element belongs to a different type. Another way to look at a structure is a template a pattern. For example graphical user interface found in a window requires structures typical example for the use of structures could be the file table which holds the key data like logical file name, location of the file on disc and so on. The file table in C is a type defined structure - FILE. Each element of a structure is also called as field. A field has a many characteristic similar to that of a normal variable. An array and a structure are slightly different. The former has a collection of homogeneous elements but the latter has a collection of heterogeneous elements. The general format for a structure in C is shown struct {field_list} variable_identifier; struct struct_name { type1 fieldname1; type2 fieldname2; . . . typeN fieldnameN; }; struct struct_name variables; The above format shown is not concrete and can vary, so different ` flavours of structure declaration is as shown. struct { . } variable_identifer; Example struct mob_equip; { long int IMEI; char rel_date[10]; DEPT OF CSE, SJBIT Page 21

DATA STRUCTERS WITH C

char model[10]; char brand[15]; }; The above example can be upgraded with typedef. A program to illustrate the working of the structure is shown in the previous section. typedef struct mob_equip; { long int IMEI; char rel_date[10]; char model[10]; char brand[15]; int count; } MOB; MOB m1; struct tag { . }; struct tag variable_identifers; typedef struct { .. } TYPE_IDENITIFIER; TYPE_IDENTIFIER variable_identifers; Accessing a structure

Page 25

DATA STRUCTERS WITH C

10CS35

How do you remember the names? Think cycles!

Fig 4:(There is also quadrinomial but those names are not often used)

terms)

and

quintinomial

terms),

2.5. Sparse Matrices:

A sparse matrix is a matrix that allows special techniques to take advantage of the large number of zero elements. This definition helps to define "how many" zeros a matrix needs in order to be "sparse." The answer is that it depends on what the structure of the matrix is, and what you want to do with it. For example, a randomly generated sparse matrix with entries scattered randomly throughout the matrix is not sparse in the sense of Wilkinson. Next: Advanced Graphics Up: Sparse matrix computations Previous: Sparse matrix computations Creating a sparse matrix: If a matrix A is stored in ordinary (dense) format, then the command S = sparse(A) creates a copy of the matrix stored in sparse format. For example: >> A = [0 0 1;1 0 2;0 -3 0] A= 0 1 0 0 1 2 0

0 -3

>> S = sparse(A) S= (2,1) (3,2) 1 -3 Page 26

DEPT OF CSE, SJBIT

DATA STRUCTERS WITH C

(1,3) (2,3) >> whos Name Size Bytes Class 1 2

10CS35

A S

3x3 3x3

72 double array 64 sparse array

Grand total is 13 elements using 136 bytes Unfortunately, this form of the sparse command is not particularly useful, since if A is large, it can be very time-consuming to first create it in dense format. The command S = sparse(m,n) creates an zero matrix in sparse format. Entries can then be added one-by-one: >> A = sparse(3,2) A= All zero sparse: 3-by-2 >> A(1,2)=1; >> A(3,1)=4; >> A(3,2)=-1; >> A A= (3,1) (1,2) (3,2) 4 1 -1

(Of course, for this to be truly useful, the nonzeros would be added in a loop.) Another version of the sparse command is S = sparse(I,J,S,m,n,maxnz). This creates an sparse

matrix with entry (I(k),J(k)) equal to . The optional argument maxnz causes Matlab to pre-allocate storage for maxnz nonzero entries, which can increase efficiency in the case when more nonzeros will be added later to S. The most common type of sparse matrix is a banded matrix, that is, a matrix with a few nonzero diagonals. Such a matrix can be created with the spdiags command. Consider the following matrix: >> A A= DEPT OF CSE, SJBIT Page 27

DATA STRUCTERS WITH C

64 -16 0 -16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

10CS35

-16 64 -16 0 -16 64 -16 0

0 -16 0

0 -16

0 64 -16

0 -16

0 -16 0 0 0 0

0 -16 64 -16 0 -16 64 0

0 -16 0

0 -16 0 0 0

0 -16 0

0 -16 0 0

0 64 -16

0 -16 0

0 -16 64 -16 0 -16 64

0 -16

This is a matrix with 5 nonzero diagonals. In Matlab's indexing scheme, the nonzero diagonals of A are numbers -3, -1, 0, 1, and 3 (the main diagonal is number 0, the first subdiagonal is number -1, the first superdiagonal is number 1, and so forth). To create the same matrix in sparse format, it is first necessary to create a matrix containing the nonzero diagonals of A. Of course, the diagonals, regarded as column vectors, have different lengths; only the main diagonal has length 9. In order to gather the various diagonals in a single matrix, the shorter diagonals must be padded with zeros. The rule is that the extra zeros go at the bottom for subdiagonals and at the top for superdiagonals. Thus we create the following matrix: >> B = [ -16 -16 64 0 0 0 0

-16 -16 64 -16 -16 0 64 -16

-16 -16 64

0 -16

-16 -16 64 -16 -16 -16 0 64 -16 -16 0 -16

0 -16 64

DATA STRUCTERS WITH C

The matrix is then created as follows: S = spdiags(B,d,9,9); The last two arguments give the size of S.

10CS35

Perhaps the most common sparse matrix is the identity. Recall that an identity matrix can be created, in dense format, using the command eye. To create the identity matrix in sparse format, use I = speye(n). Another useful command is spy, which creates a graphic displaying the sparsity pattern of a matrix. For example, the above penta-diagonal matrix A can be displayed by the following command; see Figure 6: >> spy(A)

Fig 5: The sparsity pattern of a matrix

2.6. Representation of Multidimensional arrays

For a two-dimensional array, the element with indices i,j would have address B + c i + d j, where the coefficients c and d are the row and column address increments, respectively. More generally, in a k-dimensional array, the address of an element with indices i1, i2, , ik is B + c1 i1 + c2 i2 + + ck ik This formula requires only k multiplications and k1 additions, for any array that can fit in memory. Moreover, if any coefficient is a fixed power of 2, the multiplication can be replaced by bit shifting. The coefficients ck must be chosen so that every valid index tuple maps to the address of a distinct element. If the minimum legal value for every index is 0, then B is the address of the element whose indices are all zero. As in the one-dimensional case, the element indices may be changed by changing the base address B. Thus, if a two-dimensional array has rows and columns indexed from 1 to 10 and 1 to 20, respectively, then replacing B by B + c1 - 3 c1 will cause them to be renumbered from 0 through 9 and 4 through 23, respectively. Taking advantage of this feature, some languages (like FORTRAN 77) specify that array indices begin at 1, as in mathematical tradition; while other languages (like Fortran 90, Pascal and Algol) let the user choose the minimum value for each index. DEPT OF CSE, SJBIT Page 29

DATA STRUCTERS WITH C

10CS35

Compact layouts Often the coefficients are chosen so that the elements occupy a contiguous area of memory. However, that is not necessary. Even if arrays are always created with contiguous elements, some array slicing operations may create non-contiguous sub-arrays from them. There are two systematic compact layouts for a two-dimensional array. For example, consider the matrix

In the row-major order layout (adopted by C for statically declared arrays), the elements of each row are stored in consecutive positions:

In Column-major order (traditionally used by Fortran), the elements of each column are consecutive in memory:

For arrays with three or more indices, "row major order" puts in consecutive positions any two elements whose index tuples differ only by one in the last index. "Column major order" is analogous with respect to the first index. In systems which use processor cache or virtual memory, scanning an array is much faster if successive elements are stored in consecutive positions in memory, rather than sparsely scattered. Many algorithms that use multidimensional arrays will scan them in a predictable order. A programmer (or a sophisticated compiler) may use this information to choose between row- or column-major layout for each array. For example, when computing the product AB of two matrices, it would be best to have A stored in row-major order, and B in column-major order. The Representation of Multidimensional Arrays: N-dimension, A[M0][M2]. . .[Mn-1] Address of any entry A[i0][i1]...[in-1]
base i0 M 1 M 2 i1 M 2 M 3 i2 M 3 M 4 in in base +
2 1 n -1 j= 0

Mn Mn Mn

1 1 1

i ja j ,

a where{ j an

n k 1

1 j

Array resizing: Static arrays have a size that is fixed at allocation time and consequently do not allow elements to be inserted or removed. However, by allocating a new array and copying the contents of the old array to it, it DEPT OF CSE, SJBIT Page 30

DATA STRUCTERS WITH C

10CS35

if(empty(ps)){ printf(%,stack underflow); exit(1); } return(ps->items[ps->top--]); }

10CS35

3.2. Stacks Using Dynamic Arrays:

For example: Typedef struct { char }

*str; words;

main() { words x[100]; // I do not want to use this, I want to dynamic increase the size of the array as data comesin. } For example here is the following array in which i read individual words from a .txt file and save them word by word in the array: Code: char words[1000][15]; Here 1000 defines the number of words the array can save and each word may comprise of not more than 15 characters. Now I want that that program should dynamically allocate the memory for the number of words it counts. For example, a .txt file may contain words greater that 1000. Now I want that the program should count the number of words and allocate the memory accordingly. Since we cannot use a variable in place of [1000], I am completely blank at how to implement my logic. Please help me in this regard.

3.3. Queues:
A queue is like a line of people waiting for a bank teller. The queue has a front and a rear. When we talk of queues we talk about two distinct ends: the front and the rear. Additions to the queue take place at the rear. Deletions are made from the front. So, if a job is submitted for execution, it joins at the rear of the job queue. The job at the front of the queue is the next one to be executed New people must enter the queue at the rear. push, although it is usually called an enqueue operation. DEPT OF CSE, SJBIT Page 34

DATA STRUCTERS WITH C

10CS35

When an item is taken from the queue, it always comes from the front. pop, although it is usually called a dequeue operation. What is Queue? Ordered collection of elements that has two ends as front and rear. Delete from front end Insert from rear end A queue can be implemented with an array, as shown here. For example, this queue contains the integers 4 (at the front), 8 and 6 (at the rear). Queue Operations Queue Overflow Insertion of the element into the queue Queue underflow Deletion of the element from the queue Display of the queue struct Queue { int que [size]; int front; int rear; }Q; Example: #include <stdio.h> #include <stdlib.h> #include <conio.h> #define size 5 struct queue { int que[size]; int front, rear; } Q;

DEPT OF CSE, SJBIT

Page 35

DATA STRUCTERS WITH C

Example: #include <stdio.h> #include <stdlib.h> #include <conio.h> #define size 5 struct queue { int que[size]; int front, rear; } Q; int Qfull ( ){ if (Q.rear >= size-1) return 1; el s e return 0; } int Qempty( ){ if ((Q.front == -1)||(Q.front > Q.rear)) return 1; el s e return 0; } int insert (int item) { if (Q.front == -1) Q.front++; Q.que[++Q.rear] = item; return Q.rear; } Int delete () { Int item; DEPT OF CSE, SJBIT

10CS35

Page 36

DATA STRUCTERS WITH C

Item = Q.que[Q.front]; Q.front++; Return Q.front; } Void display () { Int I; For (i=Q.front;i<=Q.rear;i++) Printf( %d,Q.que[i]); } Void main (void) { Int choice, item; Q.front = -1; Q.Rear = -1; do { Printf(Enter your choice : 1:I, 2:D, 3:Display); Scanf(%d, &choice); Switch(choice){ Case 1: if(Qfull()) printf(Cannt Insert); else scanf(%d,item); insert(item); break; Case 2: if(Qempty()) printf(Underflow); else delete(); break; } } }

10CS35

3.4. Circular Queues Using Dynamic Arrays:

Circular Queue When an element moves past the end of a circular array, it wraps around to the beginning.

A more efficient queue representation is obtained by regarding the array Q(1:n) as circular. It now becomes more convenient to declare the array as Q(0:n - 1). When rear = n - 1, the next element is entered at Q(0) in case that spot is free. Using the same conventions as before, front
DEPT OF CSE, SJBIT

Page 37

DATA STRUCTERS WITH C

10CS35

will always point one position counterclockwise from the first element in the queue. Again, front = rear if and only if the queue is empty. Initially we have front = rear = 1. Figure 3.4 illustrates some of the possible configurations for a circular queue containing the four elements J1-J4 with n > 4. The assumption of circularity changes the ADD and DELETE algorithms slightly. In order to add an element, it will be necessary to move rear one position clockwise, i.e.,
if rear = n - 1 then rear 0 else rear rear + 1.

Figure : Circular queue of n elements

Using the modulo operator which computes remainders, this is just rear (rear + 1)mod n. Similarly, it will be necessary to move front one position clockwise each time a deletion is made. Again, using the modulo operation, this can be accomplished by front (front + l)mod n. An examination of the algorithms indicates that addition and deletion can now be carried out in a fixed amount of time or O(1).
e.g. OOOOO7963 _ 4OOOO7963 (after Enqueue(4)) After Enqueue(4), rear index moves from 3 to 4. Queue Full Condition: if(front == (rear+1)%size) Queue is Full Where do we insert: rear = (rear + 1)%size; queue[rear]=item; After deletion : front = (front+1)%size; Example of a Circular Queue A Circular Q, the size of which is 5 has three elements 20, 40, and 60 where front is 0 and rear is 2. What are the values of after each of these operations: Q = 20, 40, 60, - , - front20[0], rear60[2] Insert item 50: DEPT OF CSE, SJBIT Page 38

DATA STRUCTERS WITH C

Q = 20, 40, 60, 50, - front-20[0], rear-50[3] Insert item 10: Q = 20, 40, 60, 50, 10 front-20[0], rear-10[4] Q = 20, 40, 60, 50, 10 front-20[0], rear-10[4] Insert 30 Rear = (rear + 1)%size = (4+1)%5 = 0, hence overflow. Delete an item delete 20, front = (front+1)%size = (0+1)%5=1 Delete an item delete 40, front = (front+1)%size = (1+1)&5=2 Insert 30 at position 0 Rear = (rear + 1)%size = (4+1)%5 = 0 Similarly Insert 80 at position 1

10CS35

3.5. Evaluation of Expressions: Evaluating a postfix expression:

When pioneering computer scientists conceived the idea of higher level programming languages, they were faced with many technical hurdles. One of the biggest was the question of how to generate machine language instructions which would properly evaluate any arithmetic expression. A complex assignment statement such as X A/B ** C + D* E - A * C (3.1)

might have several meanings; and even if it were uniquely defined, say by a full use of parentheses, it still seemed a formidable task to generate a correct and reasonable instruction sequence. Fortunately the solution we have today is both elegant and simple. Moreover, it is so simple that this aspect of compiler writing is really one of the more minor issues. An expression is made up of operands, operators and delimiters. The expression above has five operands: A,B,C,D, and E. Though these are all one letter variables, operands can be any legal variable name or constant in our programming language. In any expression the values that variables take must be consistent with the operations performed on them. These operations are described by the operators. In most programming languages there are several kinds of operators which correspond to the different kinds of data a variable can hold. First, there are the basic arithmetic operators: plus, minus, times, divide, and exponentiation (+,-,*,/,**). Other arithmetic operators include unary plus, unary minus and mod, ceil, and floor. The latter three may sometimes be library subroutines rather than predefined operators. A second class are the relational operators: . These are usually defined to work for arithmetic operands, but they can just as easily work for character string data. ('CAT' is less than 'DOG' since it precedes 'DOG' in alphabetical order.) The result of an expression which contains relational operators is one of the two DEPT OF CSE, SJBIT Page 39

1. Assume A=1, B=2, C=3. Evaluate the following postfix expressions : a) AB+C-BA+C$b) ABC+*CBA-+* 2. Convert the following infix expression to postfix : ((A-(B+C))*D)$(E+F) 3. Explain the different ways of representing expressions 4. State the advantages of using infix & postfix notations 5. State the rules to be followed during infix to postfix conversions 6. State the rules to be followed during infix to prefix conversions 7. Mention the advantages of representing stacks using linked lists than arrays DEPT OF CSE, SJBIT Page 44

DATA STRUCTERS WITH C

10CS35

UNIT 4 : LINKED LISTS

DATA STRUCTERS WITH C

10CS35

The individual summands with the coefficients (usually) included are called monomials (Becker and Weispfenning 1993, p. 191), whereas the products of the form in the multivariate case, i.e., with the coefficients omitted, are called terms (Becker and Weispfenning 1993, p. 188). However, the term "monomial" is sometimes also used to mean polynomial summands without their coefficients, and in some older works, the definitions of monomial and term are reversed. Care is therefore needed in attempting to distinguish these conflicting usages. The highest power in a univariate polynomial is called its order, or sometimes its degree. Any polynomial with can be expressed as ( 2) where the product runs over the roots of with multiplicity. and it is understood that multiple roots are counted

A polynomial in two variables (i.e., a bivariate polynomial) with constant coefficients is given by ( 3) The sum of two polynomials is obtained by adding together the coefficients sharing the same powers of variables (i.e., the same terms) so, for example, ( 4) and has order less than (in the case of cancellation of leading terms) or equal to the maximum order of the original two polynomials. Similarly, the product of two polynomials is obtained by multiplying term by term and combining the results, for example 5 6 and has order equal to the sum of the orders of the two original polynomials. A polynomial quotient ( 7) of two polynomials and is known as a rational function. The process of performing such a division is called long division, with synthetic division being a simplified method of recording the division. For any polynomial , divides , meaning that the polynomial quotient is a rational polynomial or, in the case of an integer polynomial, another integer polynomial (N. Sato, pers. comm., Nov. 23, 2004). DEPT OF CSE, SJBIT Page 50

DATA STRUCTERS WITH C

Exchanging the coefficients of a univariate polynomial end-to-end produces a polynomial

DATA STRUCTERS WITH C

10CS35

Now we can write procedures which insert a node at the front or at the rear of a circular list and take a fixed amount of time. procedure INSERT__FRONT(A, X) //insert the node pointed at by X to the front of the circular list A, where A points to the last node// if A = 0 then [A X LINK (X) A] else [LINK(X) LINK (A) LINK(A) X] end INSERT--FRONT To insert X at the rear, one only needs to add the additional statement A X to the else clause of INSERT__FRONT. As a last example of a simple procedure for circular lists, we write a function which determines the length of such a list. procedure LENGTH(A) //find the length of the circular list A// i 0 if A 0 then [ptr A repeat i i + 1; ptr LINK(ptr) until ptr = A ] return (i) end LENGTH

4.6. Sparse Matrices:

A sparse matrix is a matrix populated primarily with zeros (Stoer & Bulirsch 2002, p. 619). The term itself was coined by Harry M. Markowitz. Conceptually, sparsity corresponds to systems which are loosely coupled. Consider a line of balls connected by springs from one to the next; this is a sparse system. By contrast, if the same line of balls had springs connecting each ball to all other balls, the system would be represented by a dense matrix. The concept of sparsity is useful in combinatorics and application areas such as network theory, which have a low density of significant data or connections. A sparse matrix is a matrix that allows special techniques to take advantage of the large number of zero elements. This definition helps to define "how many" zeros a matrix needs in order to be "sparse." The answer is that it depends on what the structure of the matrix is, and what you want to do with it. For example, a randomly generated sparse matrix with entries scattered randomly throughout the matrix is not sparse in the sense of Wilkinson (for direct methods) since it takes Creating a sparse matrix DEPT OF CSE, SJBIT Page 54 .

DATA STRUCTERS WITH C

10CS35

If a matrix A is stored in ordinary (dense) format, then the command S = sparse(A) creates a copy of the matrix stored in sparse format. For example: >> A = [0 0 1;1 0 2;0 -3 0] A= 0 1 0 0 1 2 0

0 -3

>> S = sparse(A) S= (2,1) (3,2) (1,3) (2,3) >> whos Name Size Bytes Class 1 -3 1 2

A S

3x3 3x3

72 double array 64 sparse array

DATA STRUCTERS WITH C

>> A(3,2)=-1; >> A A= (3,1) (1,2) (3,2) 4 1 -1

10CS35

(Of course, for this to be truly useful, the nonzeros would be added in a loop.) Another version of the sparse command is S = sparse(I,J,S,m,n,maxnz). This creates an sparse

-16 64 -16 0 -16 64 -16 0

0 -16 0

0 -16

0 64 -16

0 -16

0 -16 0 0 0 0

0 -16 64 -16 0 -16 64 0

0 -16 0

0 -16 0 0 0

0 -16 0

0 -16 0 0

0 64 -16

0 -16 0

0 -16 64 -16 0 -16 64

0 -16

DATA STRUCTERS WITH C

10CS35

diagonals in a single matrix, the shorter diagonals must be padded with zeros. The rule is that the extra zeros go at the bottom for subdiagonals and at the top for superdiagonals. Thus we create the following matrix: >> B = [ -16 -16 64 0 0 0 0

-16 -16 64 -16 -16 0 64 -16

-16 -16 64

0 -16

-16 -16 64 -16 -16 -16 0 64 -16 -16 0 -16

0 -16 64

0 -16 64 -16 -16 0 ]; (notice the technique for entering the rows of a large matrix on several lines). The spdiags command also needs the indices of the diagonals: >> d = [-3,-1,0,1,3]; The matrix is then created as follows: S = spdiags(B,d,9,9); The last two arguments give the size of S. Perhaps the most common sparse matrix is the identity. Recall that an identity matrix can be created, in dense format, using the command eye. To create the identity matrix in sparse format, use I = speye(n). Another useful command is spy, which creates a graphic displaying the sparsity pattern of a matrix. For example, the above penta-diagonal matrix A can be displayed by the following command; see Figure 6: >> spy(A) 0 64 -16 -16

DEPT OF CSE, SJBIT

Page 57

DATA STRUCTERS WITH C

10CS35

Figure 6: The sparsity pattern of a matrix

4.7. Doubly Linked Lists :

Although a circularly linked list has advantages over linear lists, it still has some drawbacks. One cannot traverse such a list backward. Double-linked lists require more space per node , and their elementary operations are more expensive; but they are often easier to manipulate because they allow sequential access to the list in both directions. In particular, one can insert or delete a node in a constant number of operations given only that node's address. (Compared with singly-linked lists, which require the previous node's address in order to correctly insert or delete.) Some algorithms require access in both directions. On the other hand, they do not allow tail-sharing, and cannot be used as persistent data structures. Operations on Doubly Linked Lists One operation that can be performed on doubly linked list but not on ordinary linked list is to delete a given node. The following c routine deletes the node pointed by pfrom a doubly linked list and stores its contents in x. It is called by delete( p). delete( p ) { NODEPTR p, q, r; int *px; if ( p = = NULL ) { printf( Void Deletion \n); DEPT OF CSE, SJBIT Page 58

DATA STRUCTERS WITH C

return; } *px = p -> info; q = p -> left; r = p -> right; q -> right = r; r -> left = q; freenode( p ); return; }

10CS35

A node can be inserted on the right or on the left of a given node. Let us consider insertion at right side of a given node. The routine insert right inserts a node with information field x to right of node(p) in a doubly linked list. insertright( p, x) { NODEPTR p, q, r; int x; if ( p = = NULL ) { printf( Void Insertion \n); return; } q = getnode(); q -> info = x; r = p -> right; r -> left = q; q -> right = r; q -> left = p; p -> left = q; DEPT OF CSE, SJBIT Page 59

DATA STRUCTERS WITH C

return; }

10CS35

4.8. RECOMMENDED QUESTIONS

1.Define Linked Lists 2.List & explain the basic operations carried out in a linked list 3.List out any two applications of linked list and any two advantages of doubly linked list over singly linked list. 4. Write a C program to simulate an ordinary queue using a singly linked list. 5. Give an algorithm to insert a node at a specified position for a given singly linked list. 6. Write a C program to perform the following operations on a doubly linked list: i) To create a list by adding each node at the front. ii) To display all the elements in the reverse order.

DEPT OF CSE, SJBIT

Page 60

DATA STRUCTERS WITH C

DATA STRUCTERS WITH C

10CS35

A Complete Binary Tree.

Not a Complete Binary Tree. The tree above is not a CBT because the deepest level is not filled from left-to-right.

Properties Full tree A tree with all the leaves at the same level, and all the non-leaves having the same degree.

Complete Tree A full tree in which the last elements are deleted.

Level h of a full tree has dh-1 nodes. The first h levels of a full tree have nodes. DEPT OF CSE, SJBIT Page 64

DATA STRUCTERS WITH C

10CS35

A tree of height h and degree d has at most dh - 1 elements

Representations 1. Nodes consisting of a data field and k pointers

2. Nodes consisting of w data field and two pointers: a pointer to the first child, and a

pointer to the next sibling. 3. A tree of degree k assumes an array for holding a complete tree of degree k, with empty cells assigned for missing elements.

5.3 Binary tree Traversals:

There are many operations that we often want to perform on trees. One notion that arises frequently is the idea of traversing a tree or visiting each node in the tree exactly once. A full traversal produces a linear order for the information in a tree. This linear order may be familiar and useful. When traversing a binary tree we want to treat each node and its subtrees in the same fashion. If we let L, D, R stand for moving left, printing the data, and moving right when at a node then there are six possible combinations of traversal: LDR, LRD, DLR, DRL, RDL, and RLD. If we adopt the convention that we traverse left before right then only three traversals remain: LDR, LRD and DLR. To these we assign the names inorder, postorder and preorder because there is a natural correspondence between these traversals and producing the infix, postfix and prefix forms of an expression.

Level order

DEPT OF CSE, SJBIT

Page 65

DATA STRUCTERS WITH C x := root() if( x ) queue (x) while( queue not empty ){ x := dequeue() visit() i=1; while( i <= degree() ){ queue( child(i) ) } } Preorder

10CS35

procedure preorder(x){ visit(x) i=1; while( i <= degree() ){ preorder( child(i) ) } } Postorder

Inorder

procedure postorder(x){ i=1; while( i <= degree() ){ postorder( child(i) ) } visit(x) } Meaningful just for binary trees. procedure inorder(x){ if( left_child_for(x) ) { inorder( left_child(x) ) } visit(x) if( right_child_for(x) ) { inorder( right_child(x) ) } }

DEPT OF CSE, SJBIT

Page 66

DATA STRUCTERS WITH C Usages for visit: determine the height, count the number of elements .

10CS35

5.4. Threaded Binary trees:

If we look carefully at the linked representation of any binary tree, we notice that there are more null links than actual pointers. As we saw before, there are n + 1 null links and 2n total links. A clever way to make use of these null links has been devised by A. J. Perlis and C. Thornton. Their idea is to replace the null links by pointers, called threads, to other nodes in the tree. If the RCHILD(P) is normally equal to zero, we will replace it by a pointer to the node which would be printed after P when traversing the tree in inorder. A null LCHILD link at node P is replaced by a pointer to the node which immediately precedes node P in inorder. The tree T has 9 nodes and 10 null links which have been replaced by threads. If we traverse T in inorder the nodes will be visited in the order H D I B E A F C G. For example node E has a predecessor thread which points to B and a successor thread which points to A. In the memory representation we must be able to distinguish between threads and normal pointers. This is done by adding two extra one bit fields LBIT and RBIT. LBIT(P) =1 LBIT(P) = 0 RBIT(P) = 1 RBIT(P) = 0 if LCHILD(P) is a normal pointer if LCHILD(P) is a thread if RCHILD(P) is a normal pointer if RCHILD(P) is a thread

5.5. Heaps
A heap is a complete tree with an ordering-relation R holding between each node and its descendant. Examples for R: smaller-than, bigger-than Assumption: In what follows, R is the relation bigger-than, and the trees have degree 2. Heap Not a heap

Adding an Element 1. Add a node to the tree DEPT OF CSE, SJBIT Page 67

DATA STRUCTERS WITH C

10CS35

2. Move the elements in the path from the root to the new node one position down, if they are smaller than the new element new element 4 7 9

modified tree

3. Insert the new element to the vacant node

4. A complete tree of n nodes has depth log n , hence the time complexity is O(log n) Deleting an Element 1. Delete the value from the root node, and delete the last node while saving its value.

before

after

DEPT OF CSE, SJBIT

Page 68

DATA STRUCTERS WITH C

10CS35

2. As long as the saved value is smaller than a child of the vacant node, move up into the vacant node the largest value of the children.

3. Insert the saved value into the vacant node

4. The time complexity is O(log n) Initialization: Brute Force

Given a sequence of n values e1, ..., en, repeatedly use the insertion module on the n given values. Level h in a complete tree has at most 2h-1 = O(2n) elements Levels 1, ..., h - 1 have 20 + 21 + + 2h-2 = O(2h) elements Each element requires O(log n) time. Hence, brute force initialization requires O(n log n) time.

Efficient Insert the n elements e1, ..., en into a complete tree

For each node, starting from the last one and ending at the root, reorganize into a heap the subtree whose root node is given. The reorganization is performed by interchanging the new element with the child of greater value, until the new element is greater than its children.

DEPT OF CSE, SJBIT

Page 69

DATA STRUCTERS WITH C

10CS35

The time complexity is O(0 * (n/2) + 1 * (n/4) + 2 * (n/8) + + 2 2-3 + + (log n) 2- log n)) = O(n)
k

+ (log n) * 1) = O(n(0 2-1 + 1 2-2 (k - 1)2-

since the following equalities holds. k = 1 ] =[ k = 1 k2-k] - [ k = 1 (k - 1)2-k] =

(k - 1)2-k =2[ k = 1 (k - 1)2-k] - [ k = 1 [k - (k - 1)]2-k = k = 1 2-k =1 k=1

Applications: Priority Queue A dynamic set in which elements are deleted according to a given ordering-relation. Heap Sort Build a heap from the given set (O(n)) time, then repeatedly remove the elements from the heap (O(n log n)).

5.6. RECOMMENDED QUESTIONS

1. Construct a binary tree for : ((6+(3-2)*5)^2+3) 2. What is threaded binary tree? Explain right in and left in threaded binary trees. 3. Define a tree. Write the procedure to convert general tree to binary tree. 4. Define degree of the node, leaves, root 5. Define internal nodes, parent node, depth and height of a tree 6. State the properties of a binary tree 7. What is meant by binary tree traversal? What are the different binary tree traversal techniques 8. State the merits & demerit of linear representation of binary trees. 9. Define right-in threaded tree & left-in threaded tree DEPT OF CSE, SJBIT Page 70

DATA STRUCTERS WITH C

10CS35

UNIT 6 : TREES 2, GRAPHS

Introduction The first recorded evidence of the use of graphs dates back to 1736 when Euler used them to solve the now classical Koenigsberg bridge problem.Some of the applications of graphs are: analysis of electrical circuits, finding shortest routes, analysis of project planning, identification of chemical compounds, statistical mechanics, genetics, cybernetics, linguistics, social sciences, etc. Indeed, it might well be said that of all mathematical structures, graphs are the most widely used.

Figure 6.1 Section of the river Pregal in Koenigsberg and Euler's graph. Definitions and Terminology A graph, G, consists of two sets V and E. V is a finite non-empty set of vertices. E is a set of pairs of vertices, these pairs are called edges. V(G) and E(G) will represent the sets of vertices and edges of graph G. We will also write G = (V,E) to represent a graph. In an undirected graph the pair of vertices representing any edge is unordered . Thus, the pairs (v1, v2) and (v2, v1) represent the same edge. In a directed graph each edge is represented by a directed pair (v1, v2). v1 is the tail and v2 the head of the edge. Therefore <v2, v1> and <v1, v2> represent two different edges. Figure 6.2 shows three graphs G1, G2 and G3.

DEPT OF CSE, SJBIT

Page 71

DATA STRUCTERS WITH C

Figure 6.2 Three sample graphs. The graphs G1 and G2 are undirected. G3 is a directed graph. V (G1) = {1,2,3,4}; E(G1) = {(1,2),(1,3),(1,4),(2,3),(2,4),(3,4)} V (G2) = {1,2,3,4,5,6,7}; E(G2) = {(1,2),(1,3),(2,4),(2,5),(3,6),(3,7)} V (G3) = {1,2,3}; E(G3) = {<1,2>, <2,1>, <2,3>}.

10CS35

Note that the edges of a directed graph are drawn with an arrow from the tail to the head. The graph G2 is also a tree while the graphs G1 and G3 are not. Trees can be defined as a special case of graphs, In addition, since E(G) is a set, a graph may not have multiple occurrences of the same edge. When this restriction is removed from a graph, the resulting data object is referred to as a multigraph. The data object of figure 6.3 is a multigraph which is not a graph. The number of distinct unordered pairs (vi,vj) with vi vj in a graph with n vertices is n(n - 1)/2. This is the maximum number of edges in any n vertex undirected graph. An n vertex undirected graph with exactly n(n - 1)/2 edges is said to be complete. G1 is the complete graph on 4 vertices while G2 and G3 are not complete graphs. In the case of a directed graph on n vertices the maximum number of edges is n(n - 1). If (v1,v2) is an edge in E(G), then we shall say the vertices v1 and v2 are adjacent and that the edge (v1,v2) is incident on vertices v1 and v2. The vertices adjacent to vertex 2 in G2 are 4, 5 and 1. The edges incident on vertex 3 in G2 are (1,3), (3,6) and (3,7). If <v1,v2> is a directed edge, then vertex v1 will be said to be adjacent to v2 while v2 is adjacent from v1. The edge <v1,v2> is incident to v1 and v2. In G3 the edges incident to vertex 2 are <1,2>, <2,1> and <2,3>.

Figure 6.3 Example of a multigraph that is not a graph. A subgraph of G is a graph G' such that V(G') the subgraphs of G1 and G3. V(G) and E(G') E(G). Figure 6.4 shows some of

A path from vertex vp to vertex vq in graph G is a sequence of vertices vp,vi1,vi2, ...,vin,vq such that (vp,vi1),(vi1,vi2), ...,(vin,vq) are edges in E(G). If G' is directed then the path consists of <vp,vi1>,<vi,vi2>, ...,<vin,vq>, edges in E(G'). DEPT OF CSE, SJBIT Page 72

DATA STRUCTERS WITH C

The length of a path is the number of edges on it.

10CS35

A simple path is a path in which all vertices except possibly the first and last are distinct. A path such as (1,2) (2,4) (4,3) we write as 1,2,4,3. Paths 1,2,4,3 and 1,2,4,2 are both of length 3 in G1. The first is a simple path while the second is not. 1,2,3 is a simple directed path in G3. 1,2,3,2 is not a path in G3 as the edge <3,2> is not in E(G3). A cycle is a simple path in which the first and last vertices are the same. 1,2,3,1 is a cycle in G1. 1,2,1 is a cycle in G3. For the case of directed graphs we normally add on the prefix "directed" to the terms cycle and path. In an undirected graph, G, two vertices v1 and v2 are said to be connected if there is a path in G from v1 to v2 (since G is undirected, this means there must also be a path from v2 to v1). An undirected graph is said to be connected if for every pair of distinct vertices vi, vi in V(G) there is a path from vi to vj in G. Graphs G1 and G2 are connected while G4 of figure 6.5 is not. A connected component or simply a component of an undirected graph is a maximal connected subgraph. G4 has two components H1 and H2 (see figure 6.5). A tree is a connected acyclic (i.e., has no cycles) graph . A directed graph G is said to be strongly connected if for every pair of distinct vertices vi, vj in V(G) there is a directed path from vi to vj and also from vj to vi. The graph G3 is not strongly connected as there is no path from v3 to v2. A strongly connected component is a maximal subgraph that is strongly connected. G3 has two strongly connected components.

(a) Some of the subgraphs of G1

DEPT OF CSE, SJBIT

Page 73

DATA STRUCTERS WITH C

(b) Some of the subgraphs of G3 Figure 6.4 (a) Subgraphs of G1 and (b) Subgraphs of G3

10CS35

Figure 6.5 A graph with two connected components.

Figure 6.6 strongly connected components of G3. The degree of a vertex is the number of edges incident to that vertex. The degree of vertex 1 in G1 is 3. In case G is a directed graph, we define the in-degree of a vertex v to be the number of edges for which v is the head. The out-degree is defined to be the number of edges for which v is the tail. Vertex 2 of G3 has in-degree 1, out-degree 2 and degree 3. If di is the degree of vertex i in a graph G with n vertices and e edges, then it is easy to see that e = (1/2) .

6.1 Binary Search Trees

Characteristics Trees in which the key of an internal node is greater than the keys in its left subtree and is smaller than the keys in its right subtree. Search search ( tree,key ) IF empty tree THEN return not-found IF key == value in root THEN return found IF key > value in root THEN search (left-subtree, key) search (right-subtree, key) Time: O(depth of tree) Insertion

insert 6

insert 10

DEPT OF CSE, SJBIT

Page 74

DATA STRUCTERS WITH C

10CS35

Deletion The way the deletion is made depends on the type of node holding the key. Node of degree 0 Delete the node

Node of degree 1 Delete the node, while connecting its predecessor to the successor.

Node of degree 2 Replace the node containing the deleted key with the node having the largest key in the left subtree, or with the node having the smallest key in the right subtree.

DEPT OF CSE, SJBIT

Page 75

DATA STRUCTERS WITH C

10CS35

6.2. Selection Trees

A selection tree is a complete binary tree in which the leaf nodes hold a set of keys, and each internal node holds the winner key among its children. Modifying a Key It takes O(log n) time to modify a selection tree in response to a change of a key in a leaf.

Initialization The construction of a selection tree from scratch takes O(n) time by traversing it level-wise from bottom up.

Application: External Sort Given a set of n values 16 9 10 8 6 11 12 1 4 7 14 13 2 15 5 3 n = 16 2 15 5 3 2 3 5 15 M =4

divide it into M chuncks, internally sort each chunk,

16 9 10 8 8 9 10 16

6 11 12 1 1 6 11 12

4 7 14 13 4 7 13 14

DEPT OF CSE, SJBIT

Page 76

DATA STRUCTERS WITH C

10CS35

construct complete binary tree of M leaves with the chunks attached to the leaves.

Convert the tree into a selection tree with the keys being fed to the leaves from the chunks

Remove the winner from the tree

Feed to the empty leaf the next value from its corresponding chunk

10CS35

Conjecture: The number of binary trees on n vertices is . Proof: Every binary tree either: ! Has no vertices (x0) or ! Breaks down as one root vertex (x) along with two binary trees beneath (B(x)2). Therefore, the generating function for binary trees satisfies B(x) = 1 + xB(x)2. We conclude bn = 1 n+1#2n n $ . Another way: Find a recurrence for bn. Note: b4 = b0b3 + b1b2 + b2b1 + b3b0. In general, bn =%n1 i=0 bibn1i . Therefore, B(x) equals 1 + & n"1 '&n1 i=0 bibn1I ( xn = 1 + x & n"1 '&n1 i=0 bibn1I ( xn1 = 1+x & k"0 '&k i=0 bibkI ( xk = 1+x '& k"0 bkxk ('& k"0 bkxk ( = 1+xB(x)2. : In computer science, a graph is an abstract data type that is meant to implement the graph and hypergraph concepts from mathematics.A graph data structure consists of a finite (and possibly mutable) set of ordered pairs, called edges or arcs, of certain entities called nodes or vertices. As in mathematics, an edge (x,y) is said to point or go from x to y. The nodes may be part of the graph structure, or may be external entities represented by integer indices or references. A graph data structure may also associate to each edge some edge value, such as a symbolic label or a numeric attribute (cost, capacity, length, etc.). Algorithms Graph algorithms are a significant field of interest within computer science. Typical higher-level operations associated with graphs are: finding a path between two nodes, like depth-first search and breadth-first search and finding the shortest path from one node to another, like Dijkstra's algorithm. A solution to finding the shortest path from each node to every other node also exists in the form of the FloydWarshall algorithm.A directed graph can be seen as a flow network, where each edge has a capacity and each edge receives a flow. The FordFulkerson algorithm is used to find out the maximum flow from a source to a sink in a graph Operations The basic operations provided by a graph data structure G usually include: adjacent(G, x, y): tests whether there is an edge from node x to node y. neighbors(G, x): lists all nodes y such that there is an edge from x to y. add(G, x, y): adds to G the edge from x to y, if it is not there. delete(G, x, y): removes the edge from x to y, if it is there. get_node_value(G, x): returns the value associated with the node x. set_node_value(G, x, a): sets the value associated with the node x to a. Structures that associate values to the edges usually also provide: get_edge_value(G, x, y): returns the value associated to the edge (x,y). set_edge_value(G, x, y, v): sets the value associated to the edge (x,y) to v. DEPT OF CSE, SJBIT Page 80

6.6 The Graph Abstract Data Type

DATA STRUCTERS WITH C

Representations Different data structures for the representation of graphs are used in practice:

10CS35

Adjacency list Vertices are stored as records or objects, and every vertex stores a list of adjacent vertices. This data structure allows the storage of additional data on the vertices. Incidence list Vertices and edges are stored as records or objects. Each vertex stores its incident edges, and each edge stores its incident vertices. This data structure allows the storage of additional data on vertices and edges. Adjacency matrix A two-dimensional matrix, in which the rows represent source vertices and columns represent destination vertices. Data on edges and vertices must be stored externally. Only the cost for one edge can be stored between each pair of vertices. Incidence matrix A two-dimensional Boolean matrix, in which the rows represent the vertices and columns represent the edges. The entries indicate whether the vertex at a row is incident to the edge at a column.

6.7. RECOMMENDED QUESTIONS

1. Define forest. Explain the forest traversals. 2. Define Binary search tree. Explain with example? 3. Define a path in a tree, terminal nodes in a tree 4. Why it is said that searching a node in a binary search tree is efficient than that of a simple binary tree? 5. List the applications of set ADT. 6. What do you mean by disjoint set ADT 7. List the abstract operations in the set. 8. Define Graph. What is a directed graph & undirected graph? 9. What is a weighted graph? Define path in a graph? 10. Define outdegree of a graph & indegree of a graph?

DEPT OF CSE, SJBIT

Page 81

DATA STRUCTERS WITH C

10CS35

Priority Queue: Need for priority queue: In a multi user environment, the operating system scheduler must decide which of several processes to run only for a fixed period for time. For that we can use the algorithm of QUEUE, where Jobs are initially placed at the end of the queue. The scheduler will repeatedly take the first job on the queue, run it until either it finishes or its time limit is up, and placing it at the and of the queue if it doesnt finish. This strategy is generally not approximate, because very short jobs will soon to take a long time because of the wait involved to run. Generally, it is important that short jobs finish as fast as possible, so these jobs should have precedence over jobs that have already been running. Further more, some jobs that are not short are still very important and should also have precedence. This particular application seems to require a special kind of queue, known as a PRIORITY QUEUE. P riori ty Queue: It is a collection of ordered elements that provides fast access to the minimum or maximum element. Basic Operations performed by priority queue are: 1. Inser t operation 2. Deletemin operation Insert operation is the equivalent of queues Enqueue opera tion. Deletemin operation is the priority queue equivalent of the queues Dequeue operation.

UNIT 7 : PRIORITY QUEUES

Deltemin(H)

I mplemen tation: There are three ways for implementing priority queue. They are: 1. Linked list 2. Binary Search tree 3. Binary Heap

Priority Queue H

Insert(H)

7.1. Single- and Double-Ended Priority Queues:

A (single-ended) priority queue is a data type supporting the following operations on an ordered set of values: 1) find the maximum value (FindMax); 2) delete the maximum value (DeleteMax); 3) add a new value x (Insert(x)). Obviously, the priority queue can be redefined by substituting operations 1) and 2) with FindMin and DeleteMin, respectively. Several structures, some implicitly stored in an array and some using more complex data structures, have been presented for implementing this data type, including max-heaps (or min-heaps) DEPT OF CSE, SJBIT Page 82

DATA STRUCTERS WITH C

10CS35

Conceptually, a max-heap is a binary tree having the following properties: a) heap-shape: all leaves lie on at most two adjacent levels, and the leaves on the last level occupy the leftmost positions; all other levels are complete. b) max-ordering: the value stored at a node is greater than or equal to the values stored at its children. A max-heap of size n can be constructed in linear time and can be stored in an n-element array; hence it is referred to as an implicit data structure [g]. When a max-heap implements a priority queue, FindMax can be performed in constant time, while both DeleteMax and Insert(x) have logarithmic time. We shall consider a more powerful data type, the doubleended priority queue, which allows both FindMin and FindMax, as well as DeleteMin, DeleteMax, and Insert(x) operations. An important application of this data type is in external quicksort . A traditional heap does not allow efficient implementation of all the above operations; for example, FindMin requires linear (instead of constant) time in a max-heap. One approach to overcoming this intrinsic limitation of heaps, is to place a max-heap back-to-back with a min-heap. Definition A double-ended priority queue (DEPQ) is a collection of zero or more elements. Each element has a priority or value. The operations performed on a double-ended priority queue are: 1. 2. 3. 4. 5. 6. 7. isEmpty() ... return true iff the DEPQ is empty size() ... return the number of elements in the DEPQ getMin() ... return element with minimum priority getMax() ... return element with maximum priority put(x) ... insert the element x into the DEPQ removeMin() ... remove an element with minimum priority and return this element removeMax() ... remove an element with maximum priority and return this element

Application to External Sorting The internal sorting method that has the best expected run time is quick sort (see Section 19.2.3). The basic idea in quick sort is to partition the elements to be sorted into three groups L, M, and R. The middle group M contains a single element called the pivot, all elements in the left group L are <= the pivot, and all elements in the right group R are >= the pivot. Following this partitioning, the left and right element groups are sorted recursively. In an external sort, we have more elements than can be held in the memory of our computer. The elements to be sorted are initially on a disk and the sorted sequence is to be left on the disk. When the internal quick sort method outlined above is extended to an external quick sort, the middle group M is made as large as possible through the use of a DEPQ. The external quick sort strategy is: 1. Read in as many elements as will fit into an internal DEPQ. The elements in the DEPQ will eventually be the middle group of elements. 2. Read in the remaining elements. If the next element is <= the smallest element in the DEPQ, output this next element as part of the left group. If the next element is >= the largest element in the DEPQ, output this next element as part of the right group. Otherwise, remove either the max or min element from the DEPQ (the choice may be made randomly or alternately); if the max element is removed, output it as part of the right group; otherwise, output the removed element as part of the left group; insert the newly input element into the DEPQ. 3. Output the elements in the DEPQ, in sorted order, as the middle group. 4. Sort the left and right groups recursively. Page 83

DEPT OF CSE, SJBIT

DATA STRUCTERS WITH C

10CS35

Generic Methods for DEPQs: General methods exist to arrive at efficient DEPQ data structures from single-ended priority queue (PQ) data structures that also provide an efficient implementation of the remove(theNode) operation (this operation removes the node theNode from the PQ). The simplest of these methods, dual structure method, maintains both a min PQ and a max PQ of all the DEPQ elements together with correspondence pointers between the nodes of the min PQ and the max PQ that contain the same element. Figure 1 shows a dual heap structure for the elements 6, 7, 2, 5, 4. Correspondence pointers are shown as red arrows.

Figure 1 Dual heap

Although the figure shows each element stored in both the min and the max heap, it is necessary to store each element in only one of the two heaps. The isEmpty and size operations are implemented by using a variable size that keeps track of the number of elements in the DEPQ. The minimum element is at the root of the min heap and the maximum element is at the root of the max heap. To insert an element x, we insert x into both the min and the max heaps and then set up correspondence pointers between the locations of x in the min and max heaps. To remove the minimum element, we do a removeMin from the min heap and a remove(theNode), where theNode is the corresponding node for the removed element, from the max heap. The maximum element is removed in an analogous way. Total and leaf correspondence are more sophisticated correspondence methods. In both of these, half the elements are in the min PQ and the other half in the max PQ. When the number of elements is odd, one element is retained in a buffer. This buffered element is not in either PQ. In total correspondence, each element a in the min PQ is paired with a distinct element b of the max PQ. (a,b) is a corresponding pair of elements such that priority(a) <= priority(b). Figure 2 shows a total correspondence heap for the 11 elements 2, 3, 4, 4, 5, 5, 6, 7, 8, 9, 10. The element 9 is in the buffer. Corresponding pairs are shown by red arrows.

In leaf correspondence, each leaf element of the min and max PQ is required to be part of a corresponding pair. Nonleaf elements need not be in any corresponding pair. Figure 3 shows a leaf correspondence heap.

Figure 2 Total correspondence heap

DEPT OF CSE, SJBIT

Page 84

DATA STRUCTERS WITH C

10CS35

Figure 3 A leaf correspondence heap

Total and leaf correspondence structures require less space than do dual structures. However, the DEPQ algorithms for total and leaf correspondence structures are more complex than those for dual structures. Of the three correspondence types, leaf correspondence generally results in the fastest DEPQ correspondence structures. Using any of the described correspondence methods, we can arrive at DEPQ structures from heaps, height biased leftist trees, and pairing heaps. In these DEQP structures, the operations put(x), removeMin(), and removeMax() take O(log n) time (n is the number of elements in the DEPQ, for pairing heaps, this is an amortized complexity), a nd the remaining DEPQ operations take O(1) time.

7.2. Leftist tree:

Definitions:An external node is an imaginary node in a location of a missing child.

Notation. Let the s-value of a node be the shortest distance from the node to an external node.

An external node has the s-value of 0. An internal node has the s-value of 1 plus the minimum of the s-values of its internal and external children. Height-Biased Leftist Trees In a height-biased leftist tree the s-value of a left child of a node is not smaller than the s-value of the right child of the node. height-biased non height-biased DEPT OF CSE, SJBIT Page 85

DATA STRUCTERS WITH C

10CS35

Merging Height-Biased Leftist Trees Recursive algorithm Consider two nonempty height-biased leftist trees A and B, and a relation (e.g., smaller than) on the values of the keys. Assume the key-value of A is not bigger than the key-value of B Let the root of the merged tree have the same left subtree as the root of A Let the root of the merged tree have the right subtree obtained by merging B with the right subtree of A. If in the merged tree the s-value of the left subtree is smaller than the s-value of the right subtree, interchange the subtrees. For the following example, assume the key-value of each node equals its s-value.

DEPT OF CSE, SJBIT

Page 86

DATA STRUCTERS WITH C

10CS35

Time complexity Linear in the rightmost path of the outcome tree. The rightmost path of the the outcome tree is a shortest path A shortest path cant contain more than log n nodes. Proof If the shortest path can contain more than log n nodes, then the first 1 + log n levels should include 20 + 21 + + 2log n = 21+log n - 1 = 2n - 1 nodes. In such a case, for n > 1 we end up with n > 2n - 1.

7.3. Binomial Heaps:

Binomial heap is a heap similar to a binary heap but also supports quickly merging two heaps. This is achieved by using a special tree structure. It is important as an implementation of the mergeable heap abstract data type (also called meldable heap), which is a priority queue supporting merge operation. A binomial heap is implemented as a collection of binomial trees (compare with a binary heap, which has a shape of a single binary tree). A binomial tree is defined recursively: A binomial tree of order 0 is a single node A binomial tree of order k has a root node whose children are roots of binomial trees of orders k1, k2, ..., 2, 1, 0 (in this order).

Binomial trees of order 0 to 3: Each tree has a root node with subtrees of all lower ordered binomial trees, which have been highlighted. For example, the order 3 binomial tree is connected to an order 2, 1, and 0 (highlighted as blue, green and red respectively) binomial tree. A binomial tree of order k has 2k nodes, height k. Because of its unique structure, a binomial tree of order k can be constructed from two trees of order k1 trivially by attaching one of them as the leftmost child of root of the other one. This feature is central to the merge operation of a binomial heap, which is its major advantage over other conventional heaps.The name comes from the shape: a binomial tree of order coefficient.) DEPT OF CSE, SJBIT has nodes at depth . (See Binomial Page 87

DATA STRUCTERS WITH C

Structure of a binomial heap

10CS35

A binomial heap is implemented as a set of binomial trees that satisfy the binomial heap properties: Each binomial tree in a heap obeys the minimum-heap property: the key of a node is greater than or equal to the key of its parent. There can only be either one or zero binomial trees for each order, including zero order. The first property ensures that the root of each binomial tree contains the smallest key in the tree, which applies to the entire heap. The second property implies that a binomial heap with n nodes consists of at most log n + 1 binomial trees. In fact, the number and orders of these trees are uniquely determined by the number of nodes n: each binomial tree corresponds to one digit in the binary representation of number n. For example number 13 is 1101 in binary, , and thus a binomial heap with 13 nodes will consist of three binomial trees of orders 3, 2, and 0 (see figure below).

Example of a binomial heap containing 13 The heap consists of three binomial trees with orders 0, 2, and 3. Implementation

nodes

with

distinct

keys.

Because no operation requires random access to the root nodes of the binomial trees, the roots of the binomial trees can be stored in a linked list, ordered by increasing order of the tree. Merge As mentioned above, the simplest and most important operation is the merging of two binomial trees of the same order within two binomial heaps. Due to the structure of binomial trees, they can be merged trivially. As their root node is the smallest element within the tree, by comparing the two keys, the smaller of them is the minimum key, and becomes the new root node. Then the other tree become a subtree of the combined tree. This operation is basic to the complete merging of two binomial heaps. function mergeTree(p, q) if p.root.key <= q.root.key return p.addSubTree(q) else return q.addSubTree(p) DEPT OF CSE, SJBIT Page 88

DATA STRUCTERS WITH C

Pairing heaps are a type of heap data structure with relatively simple implementation and excellent practical amortized performance. However, it has proven very difficult to determine the precise asymptotic running time of pairing heaps. Pairing heaps are heap ordered multiway trees. Describing the various heap operations is relatively simple (in the following we assume a min-heap): find-min: simply return the top element of the heap. merge: compare the two root elements, the smaller remains the root of the result, the larger element and its subtree is appended as a child of this root. insert: create a new heap for the inserted element and merge into the original heap. decrease-key (optional): remove the subtree rooted at the key to be decreased then merge it with the heap. delete-min: remove the root and merge its subtrees. Various strategies are employed. The amortized time per delete-min is O(logn).[1] The operations find-min, merge, and insert take O(1) amortized time[2] and decrease-key takes amortized time.[3] Fredman proved that the amortized time per decrease-key is at least (loglogn).[4] That is, they are less efficient than Fibonacci heaps, which perform decrease-key in O(1) amortized time.

Implementation DEPT OF CSE, SJBIT Page 95

DATA STRUCTERS WITH C

10CS35

A pairing heap is either an empty heap, or a pair consisting of a root element and a possibly empty list of pairing heaps. The heap ordering property requires that all the root elements of the subheaps in the list are not smaller that then root element of the heap. The following description assumes a purely functional heap that does not support the decrease-key operation. type PairingHeap[Elem] = Empty | Heap(elem: Elem, subheaps: List[PairingHeap[Elem]]) Operations find-min The function find-min simply returns the root element of the heap: function find-min(heap) if heap == Empty error else return heap.elem merge: Merging with an empty heap returns the other heap, otherwise a new heap is returned that has the minimum of the two root elements as its root element and just adds the heap with the larger root to the list of subheaps: function merge(heap1, heap2) if heap1 == Empty return heap2 elsif heap2 == Empty return heap1 elseif heap1.elem < heap2.elem return Heap(heap1.elem, heap2 :: heap1.subheaps) else return Heap(heap2.elem, heap1 :: heap2.subheaps) Insert: The easiest way to insert an element into a heap is to merge the heap with a new heap containing just this element and an empty list of subheaps: function insert(elem, heap) return merge(Heap(elem, []), heap) delete-min: The only non-trivial fundamental operation is the deletion of the minimum element from the heap. The standard strategy first merges the subheaps in pairs (this is the step that gave this datastructure its name) from left to right and then merges the resulting list of heaps from right to left: fuction delete-min(heap) if heap == Empty DEPT OF CSE, SJBIT Page 96

DATA STRUCTERS WITH C

error elsif length(heap.subheaps) == 0 return Empty elsif length(heap.subheaps) == 1 return heap.subheaps[0] else return merge-pairs(heap.subheaps) This uses the auxiliary function merge-pairs: function merge-pairs(l) if length(l) == 0 return Empty elsif length(l) == 1 return l[0] else return merge(merge(l[0], l[1]), merge-pairs(l[2.. ]))

10CS35

That this does indeed implement the described two-pass left-to-right then right-to-left merging strategy can be seen from this reduction: merge-pairs([H1, H2, H3, H4, H5, H6, H7]) => merge(merge(H1, H2), merge-pairs([H3, H4, H5, H6, H7])) # merge H1 and H2 to H12, then the rest of the list => merge(H12, merge(merge(H3, H4), merge-pairs([H5, H6, H7]))) # merge H3 and H4 to H34, then the rest of the list => merge(H12, merge(H34, merge(merge(H5, H6), merge-pairs([H7])))) # merge H5 and H5 to H56, then the rest of the list => merge(H12, merge(H34, merge(H56, H7))) # switch direction, merge the last two resulting heaps, giving H567 => merge(H12, merge(H34, H567)) # merge the last two resulting heaps, giving H34567 => merge(H12, H34567) # finally, merge the first merged pair with the result of merging the rest => H1234567

7.6. RECOMMENDED QUESTIONS

1. Define a priority queue 2. Define a Deque (Double-Ended Queue) 3. What is the need for Priority queue? 4. What are the applications of priority queues? 5. What are binomial heaps? 6. Explain the height-biased leftist trees. DEPT OF CSE, SJBIT Page 97

DATA STRUCTERS WITH C

10CS35

UNIT 8 : EFFICIENT BINARY SEARCH TREES

8.1. Optimal Binary Search Trees:

An optimal binary search tree is a binary search tree for which the nodes are arranged on levels such that the tree cost is minimum. For the purpose of a better presentation of optimal binary search trees, we will consider extended binary search trees, which have the keys stored at their internal nodes. Suppose n keys k1, k2, , k n are stored at the internal nodes of a binary search tree. It is assumed that the keys are given in sorted order, so that k1< k2 < < kn. An extended binary search tree is obtained from the binary search tree by adding successor nodes to each of its terminal nodes as indicated in the following figure by squares:

In the extended tree: the squares represent terminal nodes. These terminal nodes represent unsuccessful searches of the tree for key values. The searches did not end successfully, that is, because they represent key values that are not actually stored in the tree; the round nodes represent internal nodes; these are the actual keys stored in the tree; assuming that the relative frequency with which each key value is accessed is known, weights can be assigned to each node of the extended tree (p1 p6). They represent the relative frequencies of searches terminating at each node, that is, they mark the successful searches. If the user searches a particular key in the tree, 2 cases can occur: 1 The key is found, so the corresponding weight p is incremented; 2 The key is not found, so the corresponding q value is incremented. GENERALIZATION: the terminal node in the extended tree that is the left successor of k1 can be interpreted as representing all key values that are not stored and are less than k1. Similarly, the terminal node in the extended tree that is the right successor of kn, represents all key values not stored in the tree that are greater than kn. The terminal node that is successed between ki and ki-1 in an inorder traversal represents all key values not stored that lie between ki and ki - 1. An obvious way to find an optimal binary search tree is to generate each possible binary search tree for the keys, calculate the weighted path length, and keep that tree with the smallest weighted path length. This search through all possible solutions is not feasible, since the number of such trees grows exponentially with n. An alternative would be a recursive algorithm. Consider the characteristics of any optimal tree. Of course it has a root and two subtrees. Both subtrees must themselves be optimal binary search trees with respect to their keys and weights. First, any subtree of any binary search tree must be a binary search tree. Second, the subtrees must also be optimal. Since there are n possible keys as candidates for the root of the optimal tree, the recursive solution must try them all. For each candidate key as root, all keys less than DEPT OF CSE, SJBIT Page 98

DATA STRUCTERS WITH C

10CS35

that key must appear in its left subtree while all keys greater than it must appear in its right subtree. Stating the recursive algorithm based on these observations requires some notations: OBST(i, j) denotes the optimal binary search tree containing the keys ki, ki+1, , kj; Wi, j denotes the weight matrix for OBST(i, j) Wi, j can be defined using the following formula:

__ Ci, j, 0 i j n denotes the cost matrix for OBST(i, j) Ci, j can be defined recursively, in the following manner: Ci, i = Wi, j Ci, j = Wi, j + mini<kj(Ci, k - 1 + Ck, j) Ri, j, 0 i j n denotes the root matrix for OBST(i, j) Assigning the notation Ri, j to the value of k for which we obtain a minimum in the above relations, the optimal binary search tree is OBST(0, n) and each subtree OBST(i, j) has the root kRij and as subtrees the trees denoted by OBST(i, k-1) and OBST(k, j). *OBST(i, j) will involve the weights qi-1, pi, qi, , pj, qj. All possible optimal subtrees are not required. Those that are consist of sequences of keys that are immediate successors of the smallest key in the subtree, successors in the sorted order for the keys. The bottom-up approach generates all the smallest required optimal subtrees first, then all next smallest, and so on until the final solution involving all the weights is found. Since the algorithm requires access to each subtrees weighted path length, these weighted path lengths must also be retained to avoid their recalculation. They will be stored in the weight matrix W. Finally, the root of each subtree must also be stored for reference in the root matrix R. The following function builds an optimal binary search tree FUNCTION CONSTRUCT(R, i, j) begin *build a new internal node N labeled (i, j) k _ R (i, j) i f i = k t he n *build a new leaf node N labeled (i, i) el s e *N _ CONSTRUCT(R, i, k) *N is the left child of node N if k = (j 1) then *build a new leaf node N labeled (j, j) el s e *N _ CONSTRUCT(R, k + 1, j) *N is the right child of node N return N end

8.2. AVL Trees

DEPT OF CSE, SJBIT

Page 99

DATA STRUCTERS WITH C

Definitions Named after Adelson, Velskii, and Landis.

10CS35

Trees of height O(log n) are said to be balanced. AVL trees consist of a special case in which the subtrees of each node differ by at most 1 in their height. Balanced trees can be used to search, insert, and delete arbitrary keys in O(log n) time. In contrast, height-biased leftist trees rely on non-balanced trees to speed-up insertions and deletions in priority queues.

Height
Claim: AVL trees are balanced. Proof. Let Nh denote the number of nodes in an AVL tree of depth h Nh > Nh-1 + Nh-2 + 1 > 2Nh-2 + 1 > 1 + 2(1 + 2Nh-4) = 1 + 2 + 22N h-4 > 1 + 2 + 22 + 23N h-6 ... > 1 + 2 + 22 + 23 + ... + 2h/2 = 2h/2 1 Hence, 2h/2 - 1 < n h/2 h < log 2(n + 1) < 2 log 2(n + 1)

A more careful analysis, based on Fibonacci numbers theory, implies the tighter bound of 1.44 log 2(n + 2).

DEPT OF CSE, SJBIT

Page 100

DATA STRUCTERS WITH C Rotations

10CS35

DEPT OF CSE, SJBIT

Page 101

DATA STRUCTERS WITH C

10CS35

LL & LR LL

Insertions and Deletions Insertions and deletions are performed as in binary search trees, and followed by rotations to correct imbalances in the outcome trees. In the case of insertions, one rotation is sufficient. In the case of deletions, O(log n) rotations at most are needed from the first point of discrepancy going up toward the root.

Delete 4

Imbalance at 3 implies a LL rotation with 2

Imbalance at 5 implies a RR rotation with 8.

DEPT OF CSE, SJBIT

Page 102

DATA STRUCTERS WITH C

10CS35

8.3. Red-black Trees

Properties A binary search tree in which The root is colored black All the paths from the root to the leaves agree on the number of black nodes No path from the root to a leaf may contain two consecutive nodes colored red Empty subtrees of a node are treated as subtrees with roots of black color. The relation n > 2h/2 - 1 implies the bound h < 2 log 2(n + 1). Insertions Insert the new node the way it is done in binary search trees Color the node red If a discrepancy arises for the red-black tree, fix the tree according to the type of discrepancy. A discrepancy can result from a parent and a child both having a red color. The type of discrepancy is determined by the location of the node with respect to its grand parent, and the color of the sibling of the parent. Discrepancies in which the sibling is red, are fixed by changes in color. Discrepancies in which the siblings are black, are fixed through AVL-like rotations. Changes in color may propagate the problem up toward the root. On the other hand, at most one rotation is sufficient for fixing a discrepancy.

LLr

if A is the root, then it should be repainted to black

DEPT OF CSE, SJBIT

Page 103

DATA STRUCTERS WITH C

10CS35

LRr
if A is the root, then it should be repainted to black

LLb

LRb

Discrepancies of type RRr, RLr, RRb, and RLb are handled in a similar manner.

insert 1

insert 2

insert 3 RRb discrepancy

DEPT OF CSE, SJBIT

8.4. Splay Trees :

Splay Trees (self-adjusting search trees): These notes just describe the bottom-up splaying algorithm, the proof of the access lemma, and a few applications. Every time a node is accessed in a splay tree, it is moved to the root of the tree. The amortized cost of the operation is O(log n). Just moving the element to the root by rotating it up the tree does not have this property. Splay trees do movement is done in a very special way that guarantees this amortized bound. I'll describe the algorithm by giving three rewrite rules in the form of pictures. In these pictures, x is the node that was accessed (that will eventually be at the root of the tree). By looking at the local structure of the tree defined by x, x's parent, and x's grandparent we decide which of the following three rules to follow. We continue to apply the rules until x is at the root of the tree:

y Zig (terminal case): x z / \ x z / / x z

x ====> y

Zig-zag:

/ x ====> x ====> / y z y x y \ ====> / \ ====> x z \ z

Zig-zig:

Notes (1) Each rule has a mirror image variant, which covers all the cases. (2) The zig-zig rule is the one that distinguishes splaying from just rotating x to the root of the tree. (3) Top-down splaying is much more efficient in practice. Code for doing this is on my web site (www.cs.cmu.edu/~sleator). Here are some examples: DEPT OF CSE, SJBIT Page 107

DATA STRUCTERS WITH C

10CS35

6 0 / \ 5 5 / /\ 4 splay(0) 3 6 / =======> /\ 3 1 4 / \ 2 2 / 1 / 0

3 /\ / \ / \ splay(3) 0 =======> 1 4 6 \ 2

5 \ /\

To analyze the performance of splaying, we start by assuming that each node x has a weight w(x) > 0. These weights can be chosen arbitrarily. For each assignment of weights we will be able to derive a bound on the cost of a sequence of accesses. We can choose the assignment that gives the best bound. By giving the frequently accessed elements a high weight, we will be able to get tighter bounds on the running time. Note that the weights are only used in the analysis, and do not change the algorithm at all. (A commonly used case is to assign all the weights to be 1.) Before we can state our performance lemma, we need to define two more quantities. The size of a node x (denoted s(x)) is the total weight of all the nodes in the subtree rooted at x. The rank of a node x (denoted r(x)) is the floor(log_2) of the size of x. Restating these:

s(x) = Sum (over y in the subtree rooted at x) of w(y) r(x) = floor(log(s(x)))

For each node x, we'll keep r(x) tokens on that node. (Alternatively, the potential function will just be the sums of the ranks of all the nodes in the tree.) Here's an example to illustrate this: Here's a tree, labeled with sizes on the left and ranks on the right.

9o / 8o /\ 6o o1 /\ 2o o3 / / 1o o2 \ o1
Notes about this potential: DEPT OF CSE, SJBIT

3o / 3o /\ 2o o0 /\ 1o o1 / / 0o o1 \ o0
Page 108

DATA STRUCTERS WITH C

10CS35

(1) Doing a rotation between a pair of nodes x and y only effects the ranks of the nodes x and y, and no other nodes in the tree. Furthermore, if y was the root before the rotation, then the rank of y before the rotation equals the rank of x after the rotation. (2) Assuming all the weights are 1, the potential of a balanced tree is O(n), and the potential of a long chain (most unbalanced tree) is O(n log n). (3) In the banker's view of amortized analysis, we can think of having r(x) tokens on node x. Access lemma: The number of splaying steps done when splaying node x in a tree with root t is at most 3(r(t)-r(x))+1. Proof: As we do the work, we must pay one token for each splay step we do. Furthermore we must make sure that there are always r(x) tokens on node x as we do our restructuring. We are going to allocate 3(r(t) r(x)) +1 tokens to do the splay. Our job in the proof is to show that this is enough. First we need the following observation about ranks, called the Rank Rule. Suppose that two siblings have the same rank, r. Then the parent has rank at least r+1. This is because if the rank is r, then the size is at least 2^r. If both siblings have size at least 2^r, then the total size is at least 2^(r+1) and we conclude that the rank is at least r+1. We can represent this with the following diagram:

x /\ r r

Then x >= r+1

Conversly, suppose we find a situation where a node and its parent have the same rank, r. Then the other sibling of the node must have rank < r.So if we have three nodes configured as follows, with these ranks:

r /\ x r

Then x < r

Now we can go back to proving the lemma. The approach we take is to show that the 3(r'(x) - r(x)) tokens are sufficient to pay for the a zig-zag or a zig-zig steps. And that 3(r'(x) - r(x)) +1 is sufficient to pay for the zig step. (Here r'() represents the rank function after the step, and r() represents the rank function before the step.) When we sum these costs to compute the amortized cost for the entire splay operation, they telescope to:

3(r(t) - r(x)) +1. Note that the +1 comes from the zig step, which can happen only once. Here's an example, the labels are ranks:
DEPT OF CSE, SJBIT

Page 109

DATA STRUCTERS WITH C / /\ 2o 0o o2 / / 2o splay(x) 2o / ==========> /\ 2x 1o o0 /\ / 0o o1 0o / o0 ----------------Total: 9 ---------------7

10CS35

We allocated: 3(2-2)+1 = 1 extra tokens from restructuring: 9-7 = 2 -----3

There are 2 splay steps. So 3 > 2, and we have enough.

It remains to show these bounds for the individual steps. There are three cases, one for each of the types of splay steps.

Zig:

ro / ao

or ==> \ o b <= r

The actual cost is 1, so we spend one token on this. We take the tokens on a and augment them with another r-a and put them on b. Thus the total number of tokens needed is 1+r-a. This is at most 1+3(r-a). Zig-zag: We'll split it into 2 cases: Case 1: The rank does not increase between the starting node and ending node of the step.

ro / ro \ ro

or /\ ===> a o o b

By the Rank Rule, one of a or b must be < r, so one token is released from the data structure. we use this to pay for the work. Thus, our allocation of 3(r-r) = 0 is sufficient to pay for this.

Case2: (The rank does increase)

DEPT OF CSE, SJBIT

Page 110

DATA STRUCTERS WITH C / bo \ ao /\ ===> c o o d

10CS35

The tokens on c can be supplied from those on b. (There are enough there cause b >= c.) Note that r-a > 0. So: use r-a (which is at least 1) to pay for the work use r-a to augment the tokens on a to make enough for d Summing these two gives: 2(r-a). But 2(r-a) <= 3(r-a), which completes the zig-zag case. Zig-zig: Again, we split into two cases. Case 1: The rank does not increase between the starting node and the ending node of the step.

ro / ro / ro

ro or /\ \ =====> r o o d ====> o c <= r \ (d<r by rank rule) od<r

As in the zig-zag case, we use the token gained because d < r to pay for the step. Thus we have 3(r-r)=0 tokens and we need 0. Case 2: The rank increases during the step. ro / bo / ao or \ ============> o c <= r \ o d <= r

use r-a (which is at least 1) to pay for the work use r-a to boost the tokens on a to cover those needed for d use r-a to boost the tokens on b to cover those needed for c Summing these gives 3(r-a), which completes the analyzis of the zig-zig case.

This completes the proof of the access lemma. Balance Theorem: A sequence of m splays in a tree of n nodes takes time O(m log(n) + n log(n)). Proof: We apply the access lemma with all the weights equal to 1. For a given splay, r(t) <= log(n), and r(x) >= 0. So the amortized cost of the splay is at most:
DEPT OF CSE, SJBIT

Page 111

DATA STRUCTERS WITH C

10CS35

We now switching to the world of potentials (potential = total tokens in the tree). To bound the cost of the sequence we add this amount for each splay, then add the initial minus the final potential. The initial potential is at most n log(n), and the final potential is at least 0. This gives a bound of: Splaying

DATA STRUCTERS WITH C

10CS35

Performance of Splay Tree Splaying at a node of depth d takes Theta(d) time ck= actual cost of operation k

= amortized cost of operation k Dk = the state of the data structure after applying k'th operation to Dk = potential associated with Dk

so we get:

The actual amount of work required is given by:

DEPT OF CSE, SJBIT

Page 115

DATA STRUCTERS WITH C So need the total amortized work and difference in potential Potential for Splay Trees Let: w(x) = weight of node x, a fixed but arbitrary value size(x) = rank(x) = lg(size(x))

10CS35

Example Let w(x) = 1/n where n is the number of nodes in the tree

Lemma The amortized time to splay node x in a tree with root at t is at most 3(r(t) - r(x)) + 1 = O(lg(s(t)/s(x))) Let s, r denote the size, rank functions before a splay Let s', r' denote the size, rank functions after a splay Count rotations Case 1 (zig) One rotation

DEPT OF CSE, SJBIT

Page 116

DATA STRUCTERS WITH C

Amortized time of this step is: 1 + [r'(x) + r'(y)] - r(x) - r(y) only x and y change rank <= 1 + r'(x) - r(x) r(y) >= r'(y) <= 1 + 3(r'(x) - r(x)) r'(x) >= r(x) Case 2 (zig-zig) Two rotations

10CS35

Amortized time of this step is: 2 + r'(x) + r'(y) + r'(z) - r(x) - r(y) - r(z) only x, y ,z change rank = 2 + r'(y) + r'(z) - r(x) - r(y) r'(x) = r(z) <= 2 + r'(x) + r'(z) - 2r(x) r'(x) >= r'(y) and r(y) >= r(x) Assume that 2r'(x) - r(x) - r'(z) >= 2 2 + r'(x) + r'(z) - 2r(x) <= 2r'(x) - r(x) - r'(z) + r'(x) + r'(z) - 2r(x) = 3r'(x) - 3r(x) Need to show 2r'(x) - r(x) - r'(z) >= 2

Claim 1 Set b = 1-a DEPT OF CSE, SJBIT Page 117

DATA STRUCTERS WITH C

10CS35

We have Setting this to 0 to find extreme value we get

that is a = 1/2 and b = 1/2

but lg(1/2)+lg(1/2)= -2
End claim 1 Claim 2 2r'(x) - r(x) - r'(z) >= 2 Recall that:

We have: r(x) + r'(z) - 2r'(x) = lg(s(x)) + lg(s'(z)) - 2lg(s'(x)) = lg(s(x)/s'(x)) + lg(s'(z)/s'(x)) Now s(x) + s'(z) <= s'(x) (Why?) so 0<= s(x)/s'(x) + s'(z)/s'(x) <= 1 Set s(x)/s'(x) = a and s'(z)/s'(x) =b in claim 1 to get lg(s(x)/s'(x)) + lg(s'(z)/s'(x)) <= -2 DEPT OF CSE, SJBIT Page 118

DATA STRUCTERS WITH C

Thus r(x) + r'(z) - 2r'(x) <= -2 or 2r'(x) - r(x) - r'(z) >= 2 Case 3 (zig-zag)

10CS35

8.5. RECOMMENDED QUESTIONS

1. Define AVL Tree. 2. What are the categories of AVL rotations? 3. What do you mean by balance factor of a node in AVL tree 4. Define splay tree. 5. What is the idea behind splaying? 6. List the types of rotations available in Splay tree. 7. What is the minimum number of nodes in an AVL tree of height h? 8. What is optimal binary search tree. 9. Explain the representation of a Red-black tree.

DEPT OF CSE, SJBIT

Page 119

Cse v Database Management Systems
No ratings yet
Cse v Database Management Systems
104 pages
Learning JavaScript Data Structures and Algorithms - Second Edition
From Everand
Learning JavaScript Data Structures and Algorithms - Second Edition
Loiane Groner
No ratings yet
Venting Calculations
No ratings yet
Venting Calculations
3 pages
Cse Iii Data Structures With C 10CS35 Notes PDF
No ratings yet
Cse Iii Data Structures With C 10CS35 Notes PDF
119 pages
Cse-Iii-Data Structures With C (10CS35) - Notes PDF
No ratings yet
Cse-Iii-Data Structures With C (10CS35) - Notes PDF
119 pages
Syllabus Diploma (Cse)
No ratings yet
Syllabus Diploma (Cse)
79 pages
Ece III Network Analysis (10es34) Notes
No ratings yet
Ece III Network Analysis (10es34) Notes
94 pages
EE (All) Semesters
No ratings yet
EE (All) Semesters
34 pages
India Year Book
No ratings yet
India Year Book
23 pages
Lecture Plan-Unit III
No ratings yet
Lecture Plan-Unit III
18 pages
Ise Vi File Structures 10is63 Notes
No ratings yet
Ise Vi File Structures 10is63 Notes
107 pages
June 2015
No ratings yet
June 2015
48 pages
Mastering Algorithms and Data Structures
From Everand
Mastering Algorithms and Data Structures
Manish Soni
No ratings yet
Msds Eurokyd Bs36 Tx60
No ratings yet
Msds Eurokyd Bs36 Tx60
4 pages
Dip III 14 15 (Revised) Ee
No ratings yet
Dip III 14 15 (Revised) Ee
22 pages
Dawit Research Methods and Techniques 001
100% (1)
Dawit Research Methods and Techniques 001
274 pages
Cse V Systems Software (10cs52) Notes
No ratings yet
Cse V Systems Software (10cs52) Notes
206 pages
Cse-V-Systems Software (10CS52) - Notes PDF
No ratings yet
Cse-V-Systems Software (10CS52) - Notes PDF
206 pages
Information Technology 27-5-13
No ratings yet
Information Technology 27-5-13
31 pages
Cse-III-data Structures With C (10cs35) - Solution
100% (1)
Cse-III-data Structures With C (10cs35) - Solution
54 pages
CE6304
No ratings yet
CE6304
124 pages
B.Pharmacy 6 Sem
No ratings yet
B.Pharmacy 6 Sem
18 pages
May 2015
No ratings yet
May 2015
48 pages
Chapter 2 PDF
No ratings yet
Chapter 2 PDF
53 pages
B.Pharmacy 7 Sem
No ratings yet
B.Pharmacy 7 Sem
12 pages
Thorough Examination 07
No ratings yet
Thorough Examination 07
19 pages
Estimation
No ratings yet
Estimation
99 pages
8TH
No ratings yet
8TH
11 pages
DDTWC 2014
No ratings yet
DDTWC 2014
3 pages
At 329-Alu GB
No ratings yet
At 329-Alu GB
2 pages
Lo3 PDF
No ratings yet
Lo3 PDF
13 pages
Chismtry Form 2 Government Book (1)
No ratings yet
Chismtry Form 2 Government Book (1)
118 pages
Emi Syllabus
No ratings yet
Emi Syllabus
2 pages
EPGTD 4th SEM Syllabus
No ratings yet
EPGTD 4th SEM Syllabus
12 pages
Chapter 5, 6 and 7, RESEARCH (1)
No ratings yet
Chapter 5, 6 and 7, RESEARCH (1)
22 pages
Java Notes
No ratings yet
Java Notes
78 pages
Java Notes (SJBIT) PDF
No ratings yet
Java Notes (SJBIT) PDF
78 pages
C Data Structures and Algorithms: Implementing Efficient ADTs
From Everand
C Data Structures and Algorithms: Implementing Efficient ADTs
Larry Jones
No ratings yet
Civil II Engineering Physics (10phy 22) Notes
No ratings yet
Civil II Engineering Physics (10phy 22) Notes
137 pages
Memorandum of Association-06122016.PDF Coolberg
No ratings yet
Memorandum of Association-06122016.PDF Coolberg
6 pages
A Study On Customer Satisfaction in Ceasefire Industries LTD
0% (1)
A Study On Customer Satisfaction in Ceasefire Industries LTD
75 pages
Ece III Logic Design (10es33) Notes
No ratings yet
Ece III Logic Design (10es33) Notes
193 pages
Industrial Electrical Machines LG-30
No ratings yet
Industrial Electrical Machines LG-30
87 pages
B.Pharmacy-7-Sem
No ratings yet
B.Pharmacy-7-Sem
12 pages
CE6021
No ratings yet
CE6021
96 pages
De 4th SEM Syllabus
No ratings yet
De 4th SEM Syllabus
11 pages
Syllabus - Electrical Sem 4
No ratings yet
Syllabus - Electrical Sem 4
81 pages
Comm240 Dumont
No ratings yet
Comm240 Dumont
3 pages
B.pharmacy 8 Sem
No ratings yet
B.pharmacy 8 Sem
25 pages
Web Technologies
100% (1)
Web Technologies
107 pages
155 Arty RfI
No ratings yet
155 Arty RfI
10 pages
Engineering Chemistry Notes
No ratings yet
Engineering Chemistry Notes
99 pages
Advanced CompSci Sample Pages Combined REDUCED
No ratings yet
Advanced CompSci Sample Pages Combined REDUCED
20 pages
8_Sem_Syllabus_AI&DS
No ratings yet
8_Sem_Syllabus_AI&DS
8 pages
4_Sem_BTech_AI_Honors_Syllabus (1)
No ratings yet
4_Sem_BTech_AI_Honors_Syllabus (1)
13 pages
PDF
No ratings yet
PDF
207 pages
Psychology Objective 2015
No ratings yet
Psychology Objective 2015
7 pages
Nces Syllabus
No ratings yet
Nces Syllabus
2 pages
DATA MINING and MACHINE LEARNING: CLUSTER ANALYSIS and kNN CLASSIFIERS. Examples with MATLAB
From Everand
DATA MINING and MACHINE LEARNING: CLUSTER ANALYSIS and kNN CLASSIFIERS. Examples with MATLAB
César Pérez López
No ratings yet
C++ Data Structures Explained: A Practical Guide with Examples
From Everand
C++ Data Structures Explained: A Practical Guide with Examples
William E. Clark
No ratings yet
Machine Learning in the AWS Cloud: Add Intelligence to Applications with Amazon SageMaker and Amazon Rekognition
From Everand
Machine Learning in the AWS Cloud: Add Intelligence to Applications with Amazon SageMaker and Amazon Rekognition
Abhishek Mishra
No ratings yet
Landscape Photography (From Snapshots To Great Shots)
No ratings yet
Landscape Photography (From Snapshots To Great Shots)
50 pages
HK432BT (V3) en
No ratings yet
HK432BT (V3) en
30 pages
Haier in India
No ratings yet
Haier in India
25 pages
Racing Rings Installation PDF
No ratings yet
Racing Rings Installation PDF
4 pages
LAB-1 Microprocessor
No ratings yet
LAB-1 Microprocessor
7 pages
Enomatic - Enoline 4+4 TC, 8 RT
No ratings yet
Enomatic - Enoline 4+4 TC, 8 RT
1 page
Open Circuit Pumps: Series 45 Frame K 38 and 45cc
No ratings yet
Open Circuit Pumps: Series 45 Frame K 38 and 45cc
120 pages
Hirtz
No ratings yet
Hirtz
11 pages
STI 1210B Instruction Manual
No ratings yet
STI 1210B Instruction Manual
2 pages
Sustainable Cities Index 2010 FINAL 15-10-10
No ratings yet
Sustainable Cities Index 2010 FINAL 15-10-10
32 pages
Schools Division of Parañaque City Technology and Livelihood Education Electrical Installation & Maintenance 9 Quarter 4 Week 7 & 8 Wiring Diagrams
No ratings yet
Schools Division of Parañaque City Technology and Livelihood Education Electrical Installation & Maintenance 9 Quarter 4 Week 7 & 8 Wiring Diagrams
4 pages
TRM401 Energy-Savings-Calculator pump-and-fan-VFD v4 1 14
No ratings yet
TRM401 Energy-Savings-Calculator pump-and-fan-VFD v4 1 14
30 pages
2 Piece Drinks Can
No ratings yet
2 Piece Drinks Can
5 pages
SSLC Ict Practical Record Worksheet - em
0% (1)
SSLC Ict Practical Record Worksheet - em
25 pages
The Role of Education in Economic Development
100% (2)
The Role of Education in Economic Development
8 pages
Data Sheet For GFM-650Z Battery: Specifications
No ratings yet
Data Sheet For GFM-650Z Battery: Specifications
1 page
RAMIRENT. Service Manual. Portable Compressor M 64. KAESER KOMPRESSOREN GmbH. No. - 9 - E. Manufacturer
No ratings yet
RAMIRENT. Service Manual. Portable Compressor M 64. KAESER KOMPRESSOREN GmbH. No. - 9 - E. Manufacturer
384 pages
Adorno - Punctuation Marks
No ratings yet
Adorno - Punctuation Marks
7 pages
Ptex: Per-Face Texture Mapping For Production Rendering: EGSR 2008
No ratings yet
Ptex: Per-Face Texture Mapping For Production Rendering: EGSR 2008
37 pages
GF - Lust Disciples 3.3.1
No ratings yet
GF - Lust Disciples 3.3.1
5 pages
SYLLABUS Microeconomics
No ratings yet
SYLLABUS Microeconomics
4 pages
Interview questions 2021
No ratings yet
Interview questions 2021
20 pages
Bus Timetable
No ratings yet
Bus Timetable
524 pages
Rab Produksi WP Blitar
No ratings yet
Rab Produksi WP Blitar
2 pages
Urea Plant
No ratings yet
Urea Plant
25 pages
Rends: Society 5.0: Aiming For A New Human-Centered Society
No ratings yet
Rends: Society 5.0: Aiming For A New Human-Centered Society
6 pages
Electrical Engineering Single Phage Motor Mostly Asked MCQ PDF
100% (1)
Electrical Engineering Single Phage Motor Mostly Asked MCQ PDF
22 pages
From Structured Data To The Knowledge Graph
No ratings yet
From Structured Data To The Knowledge Graph
48 pages