1. Advanced Data Structure using C++

ADVANCED 

DATA 

STRUCTURE 

NOTES 

(MTCSE 

110) 

Prepared By : 

Er. Harvinder Singh 

Assist Prof, C.S.E 

H.C.T.M (Kaithal) 

JULY 25, 2011 

2011

LECTURE NOTES OF ADVANCED DATA STRUCTURE (MT-CSE 110) 

Introduction to sorting 

Sorting Techniques 

Sorting is a process in which arranging of data is done in some given sequence 

increasing or decreasing order . Searching for an element will be more efficient in 

an array 

Categorization: 

internal sorting external sorting 

Arranigng the no’s within the sorting of no. from 

the array only which is in external file by 

reading it primary memory from secondary memory 

Why we do sorting? 

Commonly encountered programming task in computing. 

Examples of sorting: 

1. List containing exam scores sorted from Lowest to Highest or from 

Highest to Lowest 

2. List containing words that were misspelled and be listed in 

alphabetical order. 

3. List of student records and sorted by student number or 

alphabetically by first or last name. 

Prepared By : 


Assist Prof., CSE, H.C.T.M (Kaithal) Page ‐ 2 ‐


Algorithm for Quick Sort 

Quik_Sort(a,l,h) 

Where a = represents list of elements. 

l = represents the position of the first element in the list 

h = represents the position of the last element in the list 

1. [Initially] 

low =l 

high =h 

key = a[(l + h)/2] [Middle element of the list] 

2. Repeat through step 7 while (low


1.INITIAL STEP‐ FIRST PARTITION 

2.SORT LEFT PART IN SAME WAY 

Prepared By : 




INTRODUCTION OF QUICK SORT 

Quick sort is a divide‐and‐conquer style algorithm. A divide‐and‐conquer 

algorithm solves a given problem by splitting it into two or more smaller sub 

problems, recursively solving each of the sub problems, and then combining the 

solutions to the smaller problems to obtain a solution to the original one. 

To sort the sequence S={S1,S2,S3,…………,Sn}, quick sort performs the following 

steps: 

1. Select one of the elements of S. The selected element, p, is 

called the pivot. 

2. Remove p from S and then partition the remaining 

elements of S into two distinct sequences, L and G, such 

that every element in L is less than or equal to the pivot 

and every element in G is greater than or equal to the 

pivot. In general, both L and G are unsorted. 

3. Rearrange the elements of the sequence as follows: 

Notice that the pivot is now in the position in which it belongs in the 

sorted sequence, since all the elements to the left of the pivot are less 

than or equal to the pivot and all the elements to the right are greater 

than or equal to it. 

4. Recursively quick sort the unsorted sequences L and G. 

The first step of the algorithm is a crucial one. We have not specified how to 

select the pivot. Fortunately, the sorting algorithm works no matter which 

element is chosen to be the pivot. However, the pivot selection affects directly 

the running time of the algorithm. If we choose poorly the running time will be 

poor. 

Figure illustrates the detailed operation of quick sort as it sorts the sequence 

{3,1,4,1,5,9,2,6,5,4}. To begin the sort, we select a pivot. In this example, the 

Prepared By : 




value 4 in the last array position is chosen. Next, the remaining elements are 

partitioned into two sequences, one which contains values less than or equal to 

4 (L={3,1,2,1}) and one which contains values greater than or equal to 4 

(G={5,9,4,6,5}). Notice that the partitioning is accomplished by exchanging 

elements. This is why quick sort is considered to be an exchange sort. 

Prepared By : 




Algorithm for Bucket Sort 

Bucket_Sort(A,N) 

Where A = Linear Array,N = Number of elements in linear array, A. 

1. Find the largest element of the array. 

2. Find the total number of digits num in the largest digit 

Set digit = num 

3. Repeat step 4 , 5 for pass = 1 to num 

4. Initialize buckets 

For i=1 to (n‐1) 

Set num = obtain digit number pass of a[i] 

Put a[i] in bucket number digit 

[end of for loop] 

5. Calculate all number from the bucket in order. 

6. Exit 

Radix/Bucket Sort Theory 

Radix Sort is one of the linear sorting algorithms for integers. This sorting 

technique is also known as Bucket Sort or Pocket Sort. It functions by sorting the 

input numbers on each digit, for each of the digits in the numbers. However, the 

process adopted by this sort method is somewhat counterintuitive, in the sense 

that the numbers are sorted on the least‐significant digit first, followed by the 

second‐least significant digit and so on till the most significant digit. 

To appreciate Radix Sort, consider the following analogy: Suppose that we wish 

to sort a deck of 52 playing cards (the different suits can be given suitable 

values, for example 1 for Diamonds, 2 for Clubs, 3 for Hearts and 4 for Spades). 

The 'natural' thing to do would be to first sort the cards according to suits, then 

sort each of the four seperate piles, and finally combine the four in order. This 

Prepared By : 




approach, however, has an inherent disadvantage. When each of the piles is 

being sorted, the other piles have to be kept aside and kept track of. If, instead, 

we follow the 'counterintuitive' aproach of first sorting the cards by value, this 

problem is eliminated. After the first step, the four seperate piles are combined 

in order and then sorted by suit. If a stable sorting algorithm (i.e. one which 

resolves a tie by keeping the number obtained first in the input as the first in 

the output) it can be easily seen that correct final results are obtained. 

As has been mentioned, the sorting of numbers proceeds by sorting the 

least significant to most significant digit. For sorting each of these digit 

groups, a stable sorting algorithm is needed. Also, the elements in this 

group to be sorted are in the fixed range of 0 to 9. 

Example: 

To illustrate the bucket sort method, consider following list of numbers: 

121, 70, 965, 432, 12, 577, 683 

Solution: 

Pass 1: 

121 

70 

965 

432 

12 

577 12 

683 70 121 432 683 965 577 

Input 0 1 2 3 4 5 6 7 8 9 

Pass 2: 

Prepared By : 



70 

121 

432 

12 

638 


965 70 

577 12 121 432 965 577 683 

Input 0 1 2 3 4 5 6 7 8 9 

Pass 3: 

70 

121 

432 

12 

638 

965 70 

577 12 121 432 577 683 965 

Input 0 1 2 3 4 5 6 7 8 9 

After pass 3, when the numbers are collected, they are in the following order 

Prepared By : 




12, 70, 121, 432, 577, 683, 965 

Thus, the numbers are sorted. 

Algorithm for Merge Sort 

Merge_Sort(A,N) 

Where A = Linear Array. 

N = Number of elements in linear array, A. 

1. [ Call the recursive function divide ] 

Call divide (A,1,N) 

2. [ Finished ] 

Exit 

Procedure : divide (A, first, last) 

This function consider the array A. first and last variables represents the index 

of the first and the last element of the array A, respectively. The variable mid 

represents the middle position of array A. 

1. [ divide the array recursively ] 

If ( first < last) then 

mid := (first + last )/2 

call divide ( A, first, mid) 

call divide ( A, mid+1, last) 

call merge ( A, first, mid, last); 

Prepared By : 




[ End of if statement ] 


Return 

Procedure : merge (A, first, mid, last ) 

Here first, mid and last represents the first, middle and last position of array A. 

In this procedure we use auxiliary array TEMP. The variables i, j, k are local 

variables. 

1. [ Initialise ] 

i = first, j = mid + 1, k = first 

2. [ compare elements and output the smaller in array TEMP ] 

Repeat while (i


j = j + 1 

[ End of loop ] 

4. [ Copy array TEMP into array A ] 

Repeat for i = first to last 

A [i] = TEMP [i] 

[ End of for loop ] 


Return 

MERGE‐SORT Theory 

Merging is the process of combining two sorted lists into one sorted list. For this 

the elements from both the sorted list are compared. The smaller of both the 

elements is then sorted in the third array. The sorting is complete when all the 

elements from both the lists are placed in the third list 

EXAMPLE OF MERGE‐ SORT 

Suppose the array A contains 12 elements as follow: 

85, 76, 46, 92, 30, 41,12, 19, 93, 3, 50, 11 

Each pass of the merge sort algorithm will start at the beginning of the array A 

and merge pairs of sorted subarrays as follow: 

Pass1: merge each pair of elements to obtain the following list of sorted 

pairs: 

76 85 

46 92 

30 41 

12 19 

Prepared By : 



3 91 

11 50 


Pass 2:merge each pair of pairs to obtain the lists of sorted elements. 

46 76 85 92 

12 19 30 41 

3 11 50 93 

Pass 3: again merge the two subarrays to get two lists. 

12 19 30 41 46 76 85 92 

3 11 50 93 

Pass 4: merging the above two lists, we get. 

3 11 12 19 30 41 46 50 76 85 92 93 

Prepared By : 




Algorithm for Heap Sort 

Create_Heap(A,N) 

Where A = Linear Array. 

N = Number of elements in linear array, A. 

The index variable Count controls the number of insertion. The integer variable j 

denotes the index of the parent of key k[i], key contains he element being 

inserted into an existing heap. 

1. [ Repeat for each element to be placed in heap ] 

Repeat step 2 to step 7 for Count = 2 to N 

2. [ Obtain child to be placed at heap level ] 

i = Count 

key = A [Count] 

3. [ Obtain the position of parent for his child ] 

j = i div 2 

4. [ Place the child in existing heap ] 

Repeat step 5 to 6 while i > 1 and key > A[ j] 

5. [ Move the parent down to the position of the child ] 

A[i] = A[j] 

6. [ Obtain the position of the new parent ] 

i = j 

j = i div 2 

if j < 1 then 

Prepared By : 




j = 1 

[ End of if statement ] 

[ End of step 4 loop ] 

7. [ Copy the child record into its proper place ] 

A [i] = key 

[ End of step 1 for loop ] 


Return 

Algorithm : Heap_Sort ( A,N ) 

1. [ Create the initial heap ] 

Call Create_Heap (A,N) 

2. [ Perform the sort ] 

Repeat step 3 to 10 for Count = N to i‐1 

3. [ Exchange the first element with the last unsorted element ] 

A [i] = A [Count] 

4. [ Initialise Pass] 

i = 1 

key = A[i] 

j = 2 

5. [ Obtain index of largest son ] 

if j+1 < Count then 

if A[j+1] > A[j] then 

j = j +1 

[ End of inner if statement] 

Prepared By : 




[ End of outer if statement] 

6. [ Reconstruct the new heap ] 

Repeat step 7 to 10 while (j key) 

7. [ Interchange element ] 

A[i] = A[j] 

8. [ Obtain the next left son] 

i = j 

j= 2 *i 

9. [ Obtain the index of next largest son ] 

If j+1 < Count then 

If A [j+1] > A[j] then 

j = j + 1 


Else 

If j > n then 

j = n 


[ End of outer if statement] 

10. [ Copy the record into its proper place ] 

A[i] = key 

11. [ Finished ] 

Exit 

HEAP SORT Theory 

A Heap is a binary tree that satisfies the following properties :‐ 

1. Heap must be a complete binary tree. 

2. For every node in the heap, the value stored in that node is greater than 

or equal to the value in each of its children. This is known as order 

Prepared By : 




property and a heap that satisfies this property is known as maximum 

heap. 

If the order property is such that for every node in the heap, the value stored in 

that node is less than or equal to the value in each of its children, then that 

heap is known as minimum heap. 

STEPS IN HEAP SORT 

Heap sort follows two main steps:‐ 

Step I:‐ creation of heap 

Step II:‐ operation on heap 

CREATION OF HEAP 

A heap is a complete binary tree in which every node satisfies the heap 

condition. 

HEAP CONDITION 

A complete binary tree is said to satisfy the heap condition if the key of each 

node is greater than or equal to the key in its children. 

Thus the root node will have the largest key value 

OPERATION ON HEAP 

The steps of operations are as follows:‐ 

Step I – Remove the root node of the heap and insert it into the sorted list from 

right to left. 

Step II‐ Replace the deleted element (root) by the last element. 

Prepared By : 




Step III‐Reconstruct a new heap which now consists of N‐1 elements. 

Repeat the steps I,II & III to get the desired sorted list. 

ALGORITHM FOR SELECTION SORT 

Selection_Sort (A,N) 

Here A is a linear array having N no. of elements 

1. Set I=LB 

2. Repeat steps 3,4,7 while I


Example 

ALGORITHM FOR BUBBLE SORT 

Bubble_sort(A,N) 

Here A is a linear array having N no. of elements. 

1: Initialise counter 

Set I=1 

2: Repeat step 3,4,7 while I


5: if(A[J]>A[J+1]) then 

temp=A[J] 

A[J]=A[J+1] 

A[J+1]=temp 

[end of if statement] 

6: Set J=J+1 

[end of step 4 loop] 

7: Set I =I+1 

8: Exit 

[end of step 2 loop] 

Example 

Prepared By : 




ALGORITHM FOR INSERTON SORT 

Insertion_sort(A,N) 

Here A is a linear array having N no. of elements 

1: Repeat step 2 to 4 for I=2 to N 

2: Set temp =A[I] 

Position=I‐1 

3: [Move down 1 position all elements greater than temp] 

Repeat while temp=1 

(i) Set A[position+1]=A[position] 

(ii)Set position=position‐1 

[end of loop] 

4: Insert temp at proper position 

Set A[position+1]=temp 

[end of step 1 for loop] 

5: Finished 

Exit 

Prepared By : 




Example 

Insertion Sort runtimes 

1. Best case: O(n). It occurs when the data is in sorted order. After making 

one pass through the data and making no insertions, insertion sort exits. 

2. Average case: θ(n^2) since there is a wide variation with the running time. 

Worst case: O(n^2) if the numbers were sorted 

Advantage of Insertion Sort 

1. The advantage of Insertion Sort is that it is relatively simple and easy to 

implement. 

Disadvantage of Insertion Sort 

1. The disadvantage of Insertion Sort is that it is not efficient to 

operate with a large list or input size. 

Prepared By : 




HASHING 

Hashing is the transformation of a string of characters into a usually shorter 

fixed‐length value or key that represents the original string. Hashing is used to 

index and retrieve items in a database because it is faster to find the item using 

the shorter hashed key than to find it using the original value. It is also used in 

many encryption algorithms. 

As a simple example of the using of hashing in databases, a group of people 

could be arranged in a database like this: 

Abernathy, Sara Epperdingle, Roscoe Moore, Wilfred Smith, David (and many 

more sorted into alphabetical order) 

Each of these names would be the key in the database for that person's data. A 

database search mechanism would first have to start looking character‐by‐ 

character across the name for matches until it found the match (or ruled the 

other entries out). But if each of the names were hashed, it might be possible 

(depending on the number of names in the database) to generate a unique four‐ 

digit key for each name. For example: 

7864 Abernathy, Sara 9802 Epperdingle, Roscoe 1990 Moore, Wilfred 8822 

Smith, David (and so forth) 

A search for any name would first consist of computing the hash value (using 

the same hash function used to store the item) and then comparing for a match 

using that value. It would, in general, be much faster to find a match across four 

digits, each having only 10 possibilities, than across an unpredictable value 

length where each character had 26 possibilities. 

The principle of hashing involves taking a key value from some large range of 

values and transforming or mapping it to a smaller range of values. The action 

of mapping a key is called hashing and uses a hash function. The resultant 

hashed key is used to place a record in an array or hash table. The idea is that 

the hash table is much smaller than the array that would have been needed to 

hold all possible values, but that it is large enough to hold the expected number 

of values in the list. 

Prepared By : 




Let us make the hash table 479 elements long. A popular method for 

transforming keys is to use the modulus operator, taking the remainder of the 

division of the original key by the size of the hash table. For example, consider 

student number 949786: 

949786 % 479 = 408 

Therefore we should place this student in array element 408 in the hash table 

(note: the modulus operator is effective because it can only have the range 0 ‐ 

478). 

HASHING FUNCTION 

A hash function is any well‐defined procedure or mathematical function which 

converts a large, possibly variable‐sized amount of data into a small datum, 

usually a single integer that may serve as an index to an array. The values 

returned by a hash function are called hash values, hash codes, hash sums, or 

simply hashes. 

Hash functions are mostly used to speed up table lookup or data comparison 

tasks — such as finding items in a database, detecting duplicated or similar 

records in a large file, finding similar stretches in DNA sequences, and so on. 

There are two basic issues when designing a hash algorithm: 

1.Choosing the best hash function 

2.Deciding what to do with collisions 

If the key is an integer and there is no reason to expect a non‐random key 

distribution then the modulus operator is a simple (and efficient) and effective 

method. 

However if the key is a string value (e.g. someone’s name) then it first needs to 

be transformed to an integer. 

Prepared By : 



COLLISION 


When inserting an element, if it hashes to the same value as an already inserted 

element, then we have a collision and need to resolve it. There are two popular 

methods: 

1.Open Addressing 

2.Chaining 

Open Addressing 

1. Linear Probing 

In linear probing, when a collision occurs, the new element is put in the next 

available spot (by doing a sequential search). 

For example: 

Insert : 49, 18, 89, 48, Hash table size = 10, so 

49 % 10 = 9, 

18 % 10 = 8, 

89 % 10 = 9, 

48 % 10 = 8 

The problem with linear probing is that records tend to get clustered around 

each other. i.e. once an element is placed in the hash table the chances of it’s 

adjacent element being filled are doubled (i.e. it can either be filled by a 

collision or directly). 

Prepared By : 




2. Quadratic Probing 

Quadratic probing is a collision resolution method that eliminates the primary 

clustering problem of linear probing. In Quadratic Probing, if there is a collision 

we first try and insert an element in the next adjacent space (at a distance of 

+1). If this is full we try a distance of 4 (22) then 9 (32) and so until we find an 

empty element. 

The full index function is of the form: 

(h + i 2 ) % HashTableSize for i = 0,1,2,3,... where h is the initial hashed key value 

We take the modulus of the result so the search can wrap around to the 

beginning of the table. Even so not all the locations in a table may be able to be 

reached (especially if the table size is a power of 2). This means we may not be 

able to insert a value even though the table is not full. Generally though, in 

linear and quadratic probing, the hash table size is deliberately kept 

considerably larger than the number of expected keys, otherwise the 

performance of hashing becomes too slow (as the table becomes fuller more 

collisions occur and more probing is required to insert and retrieve elements). 

Example: 

as before insert : 49 18 89 48, Hash table size = 10: 

3. Double Hashing 

Another method of probing is to use a second hash function to calculate the 

probing distance. For example we define a second hash function Hash2(Key) and 

we use the return value as the probe value. If this results in a collision we try a 

distance of 2 * Hash2 (Key), then 3 * Hash2(Key) and so on. A common second 

hash function is: 

Prepared By : 



4. Rehashing 


Hash2 (Key) = R ‐ (Key % R) where R is a prime number smaller than the hash 

table size. 

If the table gets too full, the running time for the operations will start taking too 

long and inserts might fail with quadratic probing. 

The standard solution in this case is to build an entirely new hash table 

approximately twice the size of the original, calculate a new hash value for each 

key and then insert all keys into the new table (then destroying the old table). 

This is known as reorganization or rehashing. 

HASHING ALGORITHMS 

Hashing is a technique in which a given key field value is converted in to address 

of a storage location of the record by applying some operations on it.This 

technique is very useful for creatingand using random file organisation. 

A number of hash techniques are available.some examples of hashing 

algorithms are as follows: 

1. Method of division:In this method the key field value is divided by some 

suitable number (a prime number) so that quotient can be used as the 

address of the record.e.g.key field value 210 can be divided by 13 to 

obtain quotient 16 as address of the record. 

2. Division/Remainder Method:In this method key field value is divided by 

appropriate integer and the remainder is used as the relative address 

for the record. e.g. a file having 90 records with primary key values 

between 300 to 5000.let the divisor be 97.Then if the key values are 

600,1082,1540,the remainder after divison by 97 are 18,15 and 85 

respectively.common practice is to add 1 to the remainder.hence relative 

address are 19,16 & 86 respectively. 

Prepared By : 




3. Midsquare method:In this method the primary key value is squared then 

desire number of digits are extracted from the middle of the squared 

value to obtain the address e.g.suppose we have a file having 10000 

records then we need 4 digits address 0 to 9999 if the key value in 

(123456) 2 =2895783936 hence computed address is 5783. 

4. Truncation method:suppose a nine digit key field is to converted into four 

digit address the right most four digit of key can be used as a address 

e.g.key value 747479635 gives the address as 9635. 

5. Shifting method:In this method,the outer digits of the key at both ends 

are shifted inward to overlap by an amount equal to the desired address 

length.The digits are then added to obtain the address of the record. 

6. Folding method:In this method,digits in the key are folded inward like 

folding paper.The digits are then added to obtain the address. 

7. Radix conversion method:In this method,the radix of the key may be 

converted to another radix,say11.The excess high‐order digits may then 

be truncated and this number is multiplied by 0.7 to obtain the address. 

8. Polynomial method:In this method,each digit of the key is regarded as a 

polynomial coefficient. 

Prepared By : 




HASH TABLES 

In computer science, a hash table or hash map is a data structure that uses a 

hash function to efficiently map certain identifiers or keys (e.g., person names) 

to associated values (e.g., their telephone numbers). The hash function is used 

to transform the key into the index (the hash) of an array element (the slot or 

bucket) where the corresponding value is to be sought. 

Prepared By : 




ARRAYS 

An array is a data structure process multiple elements with the same data type. 

Array elements are accessed using subscript. The valid range of subscript is 0 to size ‐1. 

Arrays are commonly used in computer programs to organize data so that a 

related set of values can be easily sorted or searched. For example, a search 

engine may use an array to store Web pages found in a search performed by the 

user. When displaying the results, the program will output one element of the 

array at a time. This may be done for a specified number of values or until all 

the values stored in the array have been output. While the program could 

create a new variable for each result found, storing the results in an array is 

much more efficient way to manage memory. 

• Block of memory locations given one name 

• Homogeneous 

• Each memory location is referred to as an element 

• An index or subscript is used to access each element 

• The index indicates the position in the collection 

Example: 

DataType ArrayName[ConstIntExp]; 

float cost[4]; 

const int MAX= 7; 

int test[MAX]; 

cost[0] cost[1] cost[2] cost[3] 

Prepared By : 




Passing Arrays as Parameters 

• Passes base address of array to function (address of first element in the 

array) 

• Always a call by reference parameter (no & needed) 

• The formal parameter in the function does not need to state the size. 

• Prefixing the array declaration with “const” in the formal parameter 

prevents the function from modifying the array. 

• Cannot be the returned value of a function. 

Examples: 

someFunction(anArray); // VALID call 

void someFunction(int anArray[ ]); // Function can change the elements 

void someFunction (const int anArray[ ]); // Function cannot change the 

elements 

#include 

main() 

{ 

int a[5]; 

int i; 

for(i = 0;i


Step1: Set I=LB 

Step2: Repeat step 3 & 4 while I=J 

Step3: Set A[I+1]=A[I] 

Step4: Set I=I‐1 

[end step2 loop] 

Step5: A[J]=New 

Step6: Set M = M+1 

Step7: Exit 

Algorithm for Deletion 

Algorithm_delete(A,M,J,Del) 

Here A is a linear array with M no. of elements.We want to delete Jth element 

and store it into the variable Del. 

Step1: Set Del=A[J] 

Step2: I=J 

Step3: Repeat steps 3 & 4 while I


TYPES OF ARRAYS 

One‐dimensional arrays 

The one dimensional arrays are also known as Single dimension array and are a 

type of Linear Array. In the one dimension array the data type is followed by the 

variable name which is further followed by the single subscript i.e. the array can 

be represented in the row or column wise. It contains a single subscript that is 

why it is known as one dimensional array because one subscript can either 

represent a row or a column. 

For example auto int new[10]; 

In the given example the array starts with auto storage class and is of integer 

type named new which can contain 10 elements in it i.e. 0‐9. It is not necessary 

to declare the storage class as the compiler initializes auto storage class by 

default to every data type After that the data type is declared which is followed 

by the name i.e. new which can contain 10 entities. 

For a vector with linear addressing, the element with index i is located at the 

address B + c ∙ i, where B is a fixed base address and c a fixed constant, 

sometimes called the address increment or stride. 

If the valid element indices begin at 0, the constant B is simply the address of 

the first element of the array. For this reason, the C programming language 

specifies that array indices always begin at 0; and many programmers will call 

that element "zeroth" rather than "first". 

However, one can choose the index of the first element by an appropriate 

choice of the base address B. For example, if the array has five elements, 

indexed 1 through 5, and the base address B is replaced by B − 30c, then the 

indices of those same elements will be 31 to 35. If the numbering does not start 

at 0, the constant B may not be the address of any element. 

Prepared By : 




Example of one dimensional array is as follows: 

1. int a[5]; declares an array of size 5. 

0 1 2 3 4 

2. a[0]=10; a[1]=20; a[2]=30; a[3]=40; a[4]=50; Assigns values to the elements. 

3. Array can also be initialised at point of declaration: 

int a[]={10, 20, 30, 40, 50}; 

Two Dimensional arrays 

Multidimensional arrays can be described as "arrays of arrays". For example, a 

bidimensional array can be imagined as a bidimensional table made of 

elements, all of them of a same uniform data type. 

jimmy represents a bidimensional array of 3 per 5 elements of type int. The way 

to declare this array in C++ would be: 

int jimmy [3][5]; 

and, for example, the way to reference the second element vertically and fourth 

horizontally in an expression would be: 

Jimmy[1][3] 

Prepared By : 




(remember that array indices always begin by zero). 

Multidimensional arrays are not limited to two indices (i.e., two dimensions). 

They can contain as many indices as needed. But be careful! The amount of 

memory needed for an array rapidly increases with each dimension. 

For example: 

char century [100][365][24][60][60]; 

declares an array with a char element for each second in a century, that is more 

than 3 billion chars. So this declaration would consume more than 3 gigabytes 

of memory! 

Address Calculations in One‐dimensional arrays 

The one dimensional arrays are also known as Single dimension array and is a 

type of Linear Array. In the one dimension array the data type is followed by the 

variable name which is further followed by the single subscript i.e. the array can 

be represented in the row or column wise. It contains a single subscript that is 

why it is known as one dimensional array because one subscript can either 

represent a row or a column. 

The address of a particular element in a one‐dimensional array is given by the 

relation: 

Address of element a[k] = B+W*K 

Where B is the base address of the array, W is the size of each element of array 

, and k is the number of required element in the array (index of element) which 

should be a integer quantity. For example: 

Let the base address of the first element of the array is 2000( i. e, base address B 

is =2000), and each element of the array occupies four bytes in the memory, 

then address of fifth element of a one dimensional array a[10] will be given as: 

Address of element a [5] =2000+4*5=2000+20=2020 

Prepared By : 




The address of a particular element in a one‐dimensional array is given by the 

relation: 

Address of element a[k] = {Base address} + {Size of each element in array} * 

{Index of the array} 

Let LA be a linear array in the memory of the computer.Recall that the memory 

of the computer is simply a sequence of addressed locations as picturised in 

fig.let us use the notation 

LOC(LA[k])=address of the element LA[K] of the array LA 

1000 

1001 

1002 

1003 

1004 

(a) computer memory 

As previously noted,the elements of LA are stored in successive memory 

cells.Accordingly,thecomputer does not need to keep track of the address of 

every elements of LA,but needs to keep track only of the address of the first 

element of LA,denoted by 

Base(LA) 

and called the base address of LA.Using the address Base(LA),the computer 

calculates the address of any elements of LA by the following formula: 

Prepared By : 




LOC(LA[K])=Base(LA) + w (K‐lower bound) 

Where w is the number of words per memory cell for the array LA. 

Multidimensional arrays 

This can be done by the following methods 

ROW MAJOR IMPLEMENTATION 

Row major implementation is a linearization technique in which elements of 

array are reader from the keyboard row wise i.e the complete first row is 

stored, then the complete second row is stored and so on. 

Address of elements in row major implementation: 

The computer does not keep the track of all the elements of the array, rather, it 

keeps a base address and calculates the address of required element when 

needed. It calculates this by the following relation: 

Address of element a[i][j]= B+W (n (i‐L1) + (j‐L2)) 

Where B is the base address of the array, W is size of each array element, n is 

the number of column. L1 the lower bound of row,l2 is lower bound of column. 

Let us study an example to get a clear idea of row major implementation. 

A two dimensional array defined as a [4.. 7,‐1.. 3] requires 2 bytes of storage 

space for each element. If the array is stored in row major form, then calculate 

the address of element at location a[6,2]. Give that the base address is 100. 

Base address B=100 

Size of each element in the array W= 2 bytes 

Lower bound of row L1=4 

Lower bound of column L2=‐1 

Upper bound of row U1=7 

Upper bound of column U2=3 

Row number of the required element i=6 

Column number of required element j=2 

Now the number of columns n will be: 

U2 – L2 + 1= 3 – (‐1) + 1+5 

Address of a[6][2] = 100+2(5(6‐4)+(2‐(‐1))) 

=100+2(5*2+3) 

Prepared By : 




=100+26 

=126 

COLUMN MAJOR IMPLEMENTATION 

ADDRESS OF ELEMENT IN COLUMN MAJOR IMPLEMENTATION: 

Address of element a[i][j]= B+W(m(j‐L2)+(i‐L1)) 

Example:‐ 

Each element of an array a[‐20..20, 10..35] requires one byte of storage. If the 

array is column major implemented =, and the beginning of the array is at 

location 500, determine the address of element a[0,30] or a[0][30]. 

B= 500 

Size of each element W=1 byte 

Lower bound of row L1=‐20 

Lower bound of column L2=10 

Upper bound of row U1=20 

Upper bound of column U2=35 

I=0 

J=30 

Address of a[0][30]= 500+1(41(30‐10)+(0‐(‐20))) 

=500+1(820+20) 

= 500+840 

=1340 

Let a be a two‐dimensional m×n array.Though a is pictured as a rectangular 

pattern with m and n columns,it is represented in memory by a block of m*n 

sequential memory locations.However ,the elements can be stored in two 

different ways‐ 

Column major order‐the elements are stored column by column i.e m 

elements of the first column and stored in first m locations,elements of 

the second column are stored in next m locations,and so on. 

Row major order‐the elements are stored row by row i.e n elements of 

the first row and stored in first n locations,elements of the second row 

are stored in next n locations,and so on. 

Prepared By : 




a00 

a10 

a20 

a01 

a11 

a21 

a02 

a12 

a22 

(a) Column major order 

a00 

a01 

a02 

a10 

a11 

a12 

a20 

a21 

a22 

(b) Row major order 

Let us consider a two‐dimensional array a of size m×n.further consider that 

the lower bound for the row index is lbr and for column index is lbc. 

Prepared By : 




Like linear array,system keeps track of the address of first element only i.e 

the base address of the array. 

Using the base address,the computer computes the address of the element 

in the ith row and jth column,i.e,loc(a[i][j]),using the following formulae: 

Column major order 

Loc(a[i][j])=base(a)+w[m(j‐lbc)+(i‐lbr)] in general 

Loc(a[i][j])=base(a)+w(m×j+i) in c/c++ languages 

Row major order 

Loc(a[i][j])=base(a)+w[n(i‐lbr)+(j‐lbc)] in general 

Loc(a[i][j])=base(a)+w(n×i+j) in c/c++ languages 

Where w is the of bytes per storage location for one element of the array. 

MULTI‐DIMENSIONAL ARRAY 

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 k−1 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) specify that array indices begin at 1, as 

Prepared By : 




in mathematical tradition; while other languages (like Pascal and Algol) let the 

user choose the minimum value for each index 

IMPLEMENTATION OF MULTI‐DIMENSIONAL ARRAY 

Consider for a moment a Pascal array of the form "A:array[0..3,0..3] of char;". 

This array contains 16 bytes organized as four rows of four characters. 

Somehow you've got to draw a correspondence with each of the 16 bytes in this 

array and 16 contiguous bytes in main memory. 

Fig. Mapping a 4x4 Array to Sequential Memory Locations 

The actual mapping is not important as long as two things occur: (1) each 

element maps to a unique memory location (that is, no two entries in the array 

occupy the same memory locations) and (2) the mapping is consistent. That is, a 

given element in the array always maps to the same memory location. So what 

you really need is a function with two input parameters (row and column) that 

produces an offset into a linear array of sixteen memory locations. 

Now any function that satisfies the above constraints will work fine. Indeed, you 

could randomly choose a mapping as long as it was unique. However, what you 

really want is a mapping that is efficient to compute at run time and works for 

any size array (not just 4x4 or even limited to two dimensions. 

Prepared By : 




4.2 EXAMPLES OF MULTI‐DIMENSIONAL ARRAY 

e.g.1 suppose B is three – dimensional 2×3×4 array.Then B contains 2.3.4=24 

elements.These 24 elements of B are usually pictured ,i.e.,they appear in three 

layers ,called pages,where each page consists of the 2×4 rectangular array of 

elements with the same third subscript. 

B[1,1,3] B[1,2,3] B[1,3,3] 

B[1,4,3] 

B[2,1,3] B[2,2,3] B[2,2,3] 

B[2,4,3] 

B[1,1,2] B[1,2,2] B[1,3,2] B[1,4,2] 

B[2,1,2] B[2,2,2] B[2,3,2] 

B[2,4,2] 

B[1,1,1] B[1,2,1] B[1,3,1] 

B[1,4,1] 

for a given B[2,1,1] B[2,2,1] B[2,3,1] 

subscript Ki,the 

effective index B[2,4,1] 

Ei of Li is the 

number of indices preceding 

Ki in the index set,and Ei can be calculated from 

Ei=Ki‐lower bound 

Then the address LOC(C[K1,K2,…..Kn] of an arbitrary constant of C can be 

obtained from the formula 

Base(c) + w[(((….(EnLn‐1+En‐1)Ln‐2)+…..+E3)L2+E2)L1 + E1] 

Prepared By : 




According to whether C is stored in column‐major or row‐major order.once 

again,Base(C) denotes the address of the first element of C, and w denotes 

the number of words per memory location. 

Prepared By : 




INTRODUCTION 

DATA STRUCTURE 

What is data: Collection of raw, unorganized facts. Represented inside 

computer as unique binary combinations (0 & 1). 

Manipulate: if done properly, data transformed into information. Manipulation 

possible is based on the type of data. 

Store: Dependent on how you will use the data. Programs store data. 

PRIMITIVE DATA TYPES ‐ 

boolean 

char 

byte 

short 

int 

long 

float 

double 

Data Structure definition: 

Defined and orderly way of organizing and accessing data. 

Data Structure = Organised Data + Allowed Operations. 

Can be categorized two ways, based on were the data structure is stored. 

• Permanent (stored on secondary storage media): File, Database 

Prepared By : 




• Temporary (stored in RAM during program execution): Array, Stack, 

Queue, Linked List, Graph, Tree, Hash Table 

PROBLEMS THAT UTILIZE DATA STRUCTURES 

Real‐World Data Storage: Entities external to the computer, such as Student 

Records, Personnel Records, Inventory Records. 

Programmer’s Tools: Data structures used in compilers, run‐time modules 

(i.e.: Java Stack), Software packages. 

Real‐World Modeling: Graph and queue data structures extensively used to 

model real‐world situations. Examples: Disney: modeling software for queues at 

each attraction; Utilities: model how to layout utility grid (sewer pipes, 

electrical lines, cable lines, etc.) 

WHY STUDY DATA STRUCTURES? 

Efficient storage of data 

Efficient retrieval of data 

Ease and transparency of accessing data from an application program / class. 

Ensure correctness of data 

DATA TYPE DEFINITION: 

Data Type = Permitted Data Values + Operations 

Further, we had seen that simple data type can be used to built new scalar data 

types, for example enumerated type in C++. Similarly there are standard data 

structures which are often used in their own right and can form the basis for 

complex data structures. One such basic data structure is the Array. Arrays are 

Prepared By : 




basic building block for more complex data structures. Designing and using data 

structures is an important programming skill. We may classify these data 

structures as linear and non‐linear data structures. However, this is not the only 

way to classify data structures. In linear data structure the data items are 

arranged in a linear sequence like in an array. In a non‐linear, the data items are 

not in sequence. An example of a non linear data structure is a tree. 

Data structures may also be classified as homogenous and non‐ homogenous 

data structures. An Array is a homogenous structure in which all elements are of 

same type. In non‐homogenous structures the elements may or may not be of 

the same type. Records or Vectors are common example of non‐homogenous 

data structures. 

Another way of classifying data structures is as static or dynamic data 

structures. Static structures are ones whose sizes and structures associated 

memory location are fixed at compile time. Dynamic structures are ones which 

expand or shrink as required during the program execution and their associated 

memory locations change. 

A program = data + instructions 

Data: 

• there are several data types (numbers, characters, etc.) 

• each individual data item must be declared and named 

• each individual data item must have a value before use 

• initial values come from 

o program instructions 

o user input 

o disk files 

• program instructions can alter these values 

• original or newly computed values can go to 

o screen 

o printer 

o disk 

Prepared By : 



Instructions: 


• for data input (from keyboard, disk) 

• for data output (to screen, printer, disk) 

• computation of new values 

• program control (decisions, repetition) 

• modularization (putting a sequence of instructions into a package called a 

function) 

Data structure is the representation of logical relationship existing between 

indivisual elements of data. In other words data structure is a way of organizing 

all data items. That concidering not only the element stored but also their 

relationship to each other on the other hand ,the structure should be simple 

enough that one can effectively process the data when necessary. 

A data structure is a specialized format for organizing and storing data. General 

data structure types include the array, the file, the record, the table, the tree, 

and so on. Any data structure is designed to organize data to suit a specific 

purpose so that it can be accessed and worked with in appropriate ways. In 

computer programming, a data structure may be selected or designed to store 

data for the purpose of working on it with various algorithms. 

Data Structure Diagram 

Data Structure Diagrams (DSDs) can be thought of as graphical representations 

of DD entries. Information modeling is concerned with the definition of data 

within the system in terms of its meaning, composition and relationships. One 

of the methods within Cradle that can be used to represent information 

modeling is the use of DSDs. DSDs are a graphical means of representing the 

composition of data. 

Prepared By : 




Example 

Here is an example Data Structure Diagram(DSD). 

Description 

The DSD has been introduced into Cradle as a supplement to the functional 

modeling methodology. In essence, DSDs provide a graphical alternative to the 

composition specification of a DD entry, or a set of DD entries. A DSD contains 

data items, and shows the decomposition of data items into lower‐level data 

items. If the DSD contains only a data item and its decomposition then it is an 

Prepared By : 




exact graphical substitute for the DD entry of the data item. If the DSD 

additionally shows the decomposition of the lower‐level data items into further 

data items, then it is a graphical substitute for a set of DD entry composition 

specifications. 

DSDs are not normally used instead of DD entry composition specifications. 

DSDs find a useful application as a graphical representation of the structure of 

one or more of a system's data items, as a supplement to the DD. Even when 

DSDs are in use, the DD should still be regarded as the master source of 

reference information for a system's data and control definitions. 

DSDs visually reflect the composition of a number of DD entries such that the 

composition of each data item is shown in terms of the connected data items 

below it. The DSD notation corresponds, in effect, to a graphical version of the 

DD composition specification BNF. 

Diagram Conversions 

Symbol Name Description Definition Expansion 

Comment 

Boundary 

point 

Makes a note 

anywhere in 

the diagram. 

Are always 

surrounded by 

* characters. 

A connection 

point for the 

None None 

None None 

Prepared By : 




Data 

object 

Iteration 

data object 

Selection 

data object 

initial 

transition to 

enter the initial 

state. 

An item of data 

in the system's 

DD. 


that appears as 

an iterative 

(repeated) 

component of 

another, higher 

level, data 

item. It 

appears in the 

composition 

specification of 

the higher level 

data item 

within a (...) or 

n {...} m 

construction. 


that appears as 

an optional 

(selected) 

DD Entry None 

DD Entry None 

DD Entry None 

Prepared By : 




Picture 

Connection 

component of 

another, higher 

level data item. 

It appears in 

the 

composition 

specification of 

the higher level 

data item 

within a {...|...} 

construction. 

Allows you to 

choose the 

location of a 

GIF or JPEG 

image to be 

displayed as a 

diagram 

symbol or to be 

embedded in 

an existing 

diagram 

symbol. 

The means of 

interconnecting 

data items. 

None None 

None None 

Prepared By : 




Data structure mainly specify the following four things 

• Organisation of data 

• Accessing method 

• Degree of associative 

• Processing alternating for information 

2 

3 

4 

5 

Example of data structure 

Student 

1 

Sumit 

Ankit 

Gourav 

Vishal 

Sunil 

Operation of data structures 

The data appearing in our data structure are processed by mean of certain 

operations. In fact, the particular data structure that one chooses for a given 

situation depends largely on the frequency with which specific operations are 

performed. This section introduces the reader to some of the most frequently 

use of these operation. 

The most commonly used operation on data structure are given below as 

Prepared By : 




Traversing 

Searching 

Inserting 

Deleting 

Updating 

Sorting 

Merging 

• Traversing :‐ Accessing each record exactly once so that certain items 

in the record processed (this accessing and processing is sometime called 

“visiting” the record.) 

Example :‐1 Suppose the organization wants to announce a meeting 

through a mailing .then one would traverse the file to obtain Name and 

address for each member. 

2. Suppose one wants to find the name of all member of living in a certain 

area. Again traverse the file to obtain the data. 

• Searching :‐ finding the location of the record with the given key 

value ,or finding the locations of all records which satisfy one or more 

conditions. 

Example :‐ Suppose one wants to obtain address for a name. Then one 

would search the file for the record containing Name. 

• Inserting :‐Adding a new record to the structure. 

Example :‐ Suppose a new person join the organization.Then 

one would insert his or her record 

• Deleting :‐ This operation is also called destroy operation. In which 

memory allocation for the specified data structure. 

Example :‐ Suppose a member dies. Then one would delete his or her 

record. 

Prepared By : 




• Updating :‐ In this operation modify and update the data in the data 

structure. 

Example:‐ suppose a member moved and has a new address and 

telephone number. Given the name of the member one need to search 

for the record in the file. Then one would perform the”update”i.e.change 

item in the record with the new item 

• Sorting :‐ arranging the records in some logical record(i.e. the arranging all 

data item in a data structure in a particular order either in accending 

order or in decending order). 

• Merging :‐ The process of combination the data item of two different 

sorted list into a single sorted list. 

Applications of data structure :‐ 

Arrays 

Lists 

Stack 

Queues 

Trees 

Graphs 

Run Time of a Program 

Run‐time means the time it takes the CPU to execute an implementation of the 

algorithm. The number of C++ instructions should give us a good measure of the 

number of machine instructions. This is how we will measure the run‐time 

efficiency of an algorithm. Usually the "number of steps" depends on the 

number n of inputs to the algorithm. For instance, if you are searching an array, 

it will usually take less steps if the size n of the array is smaller. 

Prepared By : 




Algorithm Analysis and Big‐O Notation 

An algorithm is a sequence of computational steps that transform the input 

data into useful output data. Algorithm analysis is mostly measuring of the 

computational time to solve the problem. Because the behavior of an algorithm 

may be different for each possible set of data, there needs to be a means for 

summarizing that behavior in simple, easily understood formulas. One way to 

derive these formulas is the big O notation. Big O notation, also called an 

efficiency indicator, is used to describe the growth rate of a function. 

A notation we use to give an approximation to the run‐time efficiency of an 

algorithm is called Big‐O notation (The O is for order of magnitude of operations 

or space at run‐time. 

The Big‐O of a function is a relative measure of how fast the function grows with 

respect to n. To apply Big‐O to an algorithm we let f(n) = the number of steps 

(or instructions) that are executed when the algorithm runs on n inputs. There 

are certain Big‐Oh values that occur frequently in the analysis of algorithms. 

Here is a partial list in increasing "size" and the approximate value of |f(n)| for a 

few values of n. 

Abstract Data Type 

Array 

– A collection of data of the same type 

An array is usually implemented as a consecutive set of memory locations 

– int list[5], *plist[5] 

Variable Memory Address 

list[0] base address= b 

list[1] b+sizeof(int) 

list[2] b+2*sizeof(int) 

Prepared By : 






ADT definition 

– More general structure than "a consecutive set of memory locations." 

Abstract Data Type Array 

Class GeneralArray{ 

//objects: A set of pairs where for each value of index there //is 

a value from the set item. Index is a finite ordered set of one or more 

//dimensions, for example, 

{0, ..., n‐1} for one dimension, 

{(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)} for two dimensions, 

etc. 

Public: 

GeneralArray(int j, RangeList list,float initValue=defaultValue); 

//The constructor creates a j dimensional array; 

//the range of the kth dimension is given by the kth element of list; 

//for each i in the index set, insert into the array. 

float Retrieve(index i); 

// if ((i in index) return the item associated with index value i in array 

Prepared By : 




Void Store(i, float x); 

else return error 

// if (i in index) insert the new pair 

};//end of GeneralArray 

else return error. 

The Polynomial Abstract Data Type 

Examples of polynomials 

( ) 

( ) 

Ax = 3x+ 2x+ 4 

Bx = x + 10x + 3x + 1 

Sum and product of polynomials 

– Let A(x)= aix i and B(x)= bix i 

– Sum 

A(x)+ B(x)= (ai + bi)x i 

– Product 

The Sparse Matrix Abstract Data Type 

Matrix 

20 5 

4 3 2 

A(x)*B(x)= (aix i * (bjx j )) 

Prepared By : 




– Examples of matrix 

Sparse matrix 

– Many zero items 

Representation of matrix 

– A[][], standard representation 

– Sparse matrix, store non‐zero item only 

col 0 col 1 col 2 

row 0 ‐27 3 4 

row 1 6 82 ‐2 

row 2 109 ‐64 11 

row 3 12 8 9 

row 4 48 27 47 

col 0 col 1 col 2 col 3 col 4 col 5 

row 0 15 0 0 22 0 ‐15 

row 1 0 11 3 0 0 0 

row 2 0 0 0 ‐6 0 0 

row 3 0 0 0 0 0 0 

row 4 91 0 0 0 0 0 

row 5 0 0 28 0 0 0 

Abstract Data Type Sparse Matrix 

class SparseMatrix 

{ 

//objects: a set of triples, , where row and column are 

integers and 

// form a unique combination, and value comes from the set item. 

public: 

SparseMatrix(int MaxRow, int MaxCol); 

Prepared By : 




//create a SparseMatrix that can hold up to MaxItems= MaxRow*MaxCol 

and whose //maximum row size is MaxRow and whose maximum column 

size is MaxCol 

SparseMatrix Transpose(); 

// return the matrix produced by interchanging the row and column value of 

every triple. 

SparseMatrix Add(SparseMatrix b); 

//if the dimensions of a(*this) and b are the same, return the matrix produced 

by adding //corresponding items, namely those with identical row and column 

values. else return //error. 

SparseMatrix Multiply(a, b); 

//if number of columns in a equals number of rows in b return the matrix d 

produced by //multiplying a by b according to the formula: d[i][j]= 

Sum(a[i][k](b[k][j]), where d(i, j) is the (i, j)th element, k=0 ~ ((columns of a) –1) 

else return error. 

Representation of Sparse Matrix 

class SparseMatrix; 

class MatrixTerm { 

friend class SparseMatrix 

private: 

int col, row, value; 

}; 

private: 

int col, row,Terms; 

MatrixTerm smArray[MaxTerms]; 

Prepared By : 




Note: triples are ordered by row and within rows by columns 

Representation of Sparse Matrix 

col0 col1 col2 col3 col4 col5 

row0 15 0 0 22 0 ‐15 

row1 0 11 3 0 0 0 

row2 0 0 0 ‐6 0 0 

row3 0 0 0 0 0 0 

row4 91 0 0 0 0 0 

row5 0 0 28 0 0 0 

row col value 

smArray[0] 0 0 15 

smArray[1] 0 3 22 

smArray[2] 0 5 ‐15 

smArray[3] 1 1 11 

smArray[4] 1 2 3 

smArray[5] 2 3 ‐6 

smArray[6] 4 0 91 

smArray[7] 5 2 28 

Transposing a Matrix 

Transpose a matrix, [i][j] [j][i] 

– O(columns*rows) 

For the sparse matrix 

for (all elements in column j) 

for(j=0; j< columns; j++) 

for(i=0; i< rows; i++) 

b[j][i]= a[i][j]; 

Prepared By : 




place element in element < j, i, value>; 

‐ O(columns*terms) /*program 2.10, page 91 */ 

Analysis of complexity 

‐ When terms=rows*columns, 

worse case: O(columns*terms)= O(rows*columns 2 ) 

‐ A better approach 

FastTranspose( ); O(terms + columns), worse case: O(rows*columns) 

/* program 2.11, page 93 */ 

Transposing a Sparse Matrix 

row col value 

a[1] 0 0 15 

a[2] 0 3 22 

a[3] 0 5 ‐15 

a[4] 1 1 11 

a[5] 1 2 3 

a[6] 2 3 ‐6 

a[7] 4 0 91 

a[8] 5 2 28 

row col value 

b[1] 0 0 15 

b[2] 0 4 91 

b[3] 1 1 11 

b[4] 2 1 3 

b[5] 2 5 28 

b[6] 3 0 22 

b[7] 3 2 ‐6 

b[8] 5 0 ‐15 

Prepared By : 




Call by Value and Call by Reference 

The arguments passed to function can be of two types namely 

1. Values passed 

2. Address passed 

The first type refers to call by value and the second type refers to call by 

reference. 

For instance consider program1 

main() 

{ 

int x=50, y=70; 

interchange(x,y); 

printf(“x=%d y=%d”,x,y); 

} 

interchange(x1,y1) 

int x1,y1; 

{ 

int z1; 

z1=x1; 

x1=y1; 

y1=z1; 

printf(“x1=%d y1=%d”,x1,y1); 

} 

Prepared By : 




Here the value to function interchange is passed by value. 

Consider program2 

main() 

{ 

int x=50, y=70; 

interchange(&x,&y); 

printf(“x=%d y=%d”,x,y); 

} 

interchange(x1,y1) 

int *x1,*y1; 

{ 

int z1; 

z1=*x1; 

*x1=*y1; 

*y1=z1; 

printf(“*x=%d *y=%d”,x1,y1); 

} 

Here the function is called by reference. In other words address is passed by 

using symbol & and the value is accessed by using symbol *. 

The main difference between them can be seen by analyzing the output of 

program1 and program2. 

The output of program1 that is call by value is 

x1=70 y1=50 

x=50 y=70 

But the output of program2 that is call by reference is 

*x=70 *y=50 

x=70 y=50 

Prepared By : 




This is because in case of call by value the value is passed to function named as 

interchange and there the value got interchanged and got printed as 

x1=70 y1=50 

and again since no values are returned back and therefore original values of x 

and y as in main function namely 

x=50 y=70 got printed. 

But in case of call by reference address of the variable got passed and therefore 

whatever changes that happened in function interchange got reflected in the 

address location and therefore they got reflected in original function call in 

main also without explicit return value. So value got printed as *x=70 *y=50 and 

x=70 y=50 

DYNAMIC MEMORY ALLOCATION 

Your computer's memory is a resource ‐ it can run out. The memory usage for 

program data can increase or decrease as your program runs. 

Up until this point, the memory allocation for your program has been handled 

automatically when compiling. However, sometimes the computer doesn't 

know how much memory to set aside (for example, when you have an unsized 

array). 

The following functions give you the power to dynamically allocate memory for 

your variables at RUN‐TIME (while the program is running). For the past 

tutorials, memory was allocated when the program was compiled (i.e. COMPILE‐ 

TIME). 

To use the four functions discussed in this section, you must include the stdlib.h 

header file. 

Prepared By : 




Malloc Function:‐ 

Malloc requires one argument ‐ the number of bytes you want to allocate 

dynamically. 

If the memory allocation was successful, malloc will return a void pointer ‐ you 

can assign this to a pointer variable, which will store the address of the 

allocated memory. 

If memory allocation failed (for example, if you're out of memory), malloc will 

return a NULL pointer. 

Passing the pointer into free will release the allocated memory ‐ it is good 

practice to free memory when you've finished with it. 

This example will ask you how many integers you'd like to store in an array. It'll 

then allocate the memory dynamically using malloc and store a certain number 

of integers, print them out, then releases the used memory using free. 

#include 

#include /* required for the malloc and free functions */ 

int main() { 

int number; 

int *ptr; 

int i; 

printf("How many ints would you like store? "); 

scanf("%d", &number); 

ptr = malloc(number*sizeof(int)); /* allocate memory */ 

if(ptr!=NULL) { 

for(i=0 ; i

} 


for(i=number ; i>0 ; i‐‐) { 

printf("%d\n", *(ptr+(i‐1))); /* print out in reverse order */ 

} 

free(ptr); /* free allocated memory */ 

return 0; 

} 

else { 

printf("\nMemory allocation failed ‐ not enough memory.\n"); 

return 1; 

} 

} 

Output if I entered 3: 

Calloc Function:‐ 

How many ints would you like store? 3 

2 

1 

0 

Calloc is similar to malloc, but the main difference is that the values stored in 

the allocated memory space is zero by default. With malloc, the allocated 

memory could have any value. 

calloc requires two arguments. The first is the number of variables you'd like to 

allocate memory for. The second is the size of each variable. 

Prepared By : 




Like malloc, calloc will return a void pointer if the memory allocation was 

successful, else it'll return a NULL pointer. 

This example shows you how to call calloc and also how to reference the 

allocated memory using an array index. The initial value of the allocated 

memory is printed out in the for loop. 

#include 

#include 

/* required for the malloc, calloc and free functions */ 

int main() { 

float *calloc1, *calloc2, *malloc1, *malloc2; 

int i; 

calloc1 = calloc(3, sizeof(float)); /* might need to cast */ 

calloc2 = calloc(3, sizeof(float)); 

malloc1 = malloc(3 * sizeof(float)); 

malloc2 = malloc(3 * sizeof(float)); 

if(calloc1!=NULL && calloc2!=NULL && malloc1!=NULL && malloc2!=NULL) { 

for(i=0 ; i


} 

else { 

printf("Not enough memory\n"); 

return 1; 

} 

} 

Output: 

calloc1[0] holds 0.00000, malloc1[0] holds ‐431602080.00000 






Realloc Function:‐ 

Now suppose you've allocated a certain number of bytes for an array but later 

find that you want to add values to it. You could copy everything into a larger 

array, which is inefficient, or you can allocate more bytes using realloc, without 

losing your data. 

realloc takes two arguments. The first is the pointer referencing the memory. 

The second is the total number of bytes you want to reallocate. 

Passing zero as the second argument is the equivalent of calling free. 

Once again, realloc returns a void pointer if successful, else a NULL pointer is 

returned. 

Prepared By : 




This example uses calloc to allocate enough memory for an int array of five 

elements. Then realloc is called to extend the array to hold seven elements. 

#include 

#include 

int main() { 

int *ptr; 

int i; 

ptr = calloc(5, sizeof(int)); 


*ptr = 1; 

*(ptr+1) = 2; 

ptr[2] = 4; 

ptr[3] = 8; 

ptr[4] = 16; 

/* ptr[5] = 32; wouldn't assign anything */ 

ptr = realloc(ptr, 7*sizeof(int)); 


printf("Now allocating more memory... \n"); 

ptr[5] = 32; /* now it's legal! */ 

ptr[6] = 64; 

for(i=0 ; i


return 1; 

} 

} 

else { 

printf("Not enough memory ‐ calloc failed.\n"); 

return 1; 

} 

} 

Output: 

Free Function:‐ 

Now allocating more memory... 

ptr[0] holds 1 







It is used to de‐allocate the previously allocated memory using Malloc or Calloc 

functions. 

When you allocate memory with either malloc() or calloc(), it is taken from the 

dynamic memory pool that is available to your program. This pool is sometimes 

called the heap, and it is finite. When your program finishes using a particular 

block of dynamically allocated memory, you should de‐allocate, or free, the 

Prepared By : 




memory to make it available for future use. To free memory that was allocated 

dynamically, use free(). Its prototype is 

void free(void *ptr); 

The free() function releases the memory pointed to by ptr. This memory must 

have been allocated with malloc(), calloc(), or realloc(). If ptr is NULL, free() 

does nothing. Sample program below demonstrates the free() function. 

Prepared By : 



Definitions : 


GRAPHS 

Graph: nodes/vertices, and edges/arcs as pairs of nodes. {V, E} e12=(v1, v2, l12) 

The third term l12, if present, could be a label or the weight of an edge. 

Directed graph: edges are ordered pairs of nodes. 

Weighted graph: each edge (directed/undirected) has a weight. 

Path between a pair of nodes: sequence of edges with those two nodes at the 

two ends. 

Simple path: covers no node in it twice. 

Loop: a path with the same start and end node. 

Path length: number of edges in it. 

Path weight: total wt of all edges in it. 

Connected graph: there exists a path between every node, no node is 

disconnected. 

Complete graph: edge between every pair of nodes. 

Acyclic graph: a graph with no cycles. 

Graphs are one of the most used models of real‐life problems for computer‐ 

solutions. 

Representations: visual pictures are not useful data structures for storing a 

graph! Adjacency list (link list of directly connected nodes for each node), and 

matrix are two representations. The second one is less efficient but easy to use, 

while the first one is good for sparse graph (sparsely distributed edges, less 

connected). 

DEFINING GRAPH: 

A graph g consist of a set V of vertices(nodes) and a set E of edges(arcs).We 

write G=(V,E),V is a finite and non empty set of vertices .E is a set of pairs of 

vertices ,their pairs are called edges .therefore , 

Prepared By : 




V(G),read as V of G is a set of vertices 

E(G),read as E of G is a set of edges . 

An edge e =(v,w),is a pair of vertices v & w and is said to be incident with v& w. 

Fig A shows sample graph , for which 

V (G)={v1,v2,v3,v4,v5}& 

E(G)={e1,e2,e3,e4,e5}. 

i.e.,there are 5 vertices and 5 edges in the graph. 

Basic Graph Terminology. 

If a and b are a pair of vertices in a graph G and (a,b) is an edge of G (this will be 

our notation for the edge (a,b)), we say that a and b are connected by an edge 

or adjacent. An edge (a,a) is called a loop. 

Type of graphs: 

1. Multigraph: Edges: unordered pairs. May contain parallel edges and 

loops. 

2. Simple Graph (graph): Edges: unordered pairs, no loops or multiple edges. 

3. Directed Graph (DiGraph): Edges: ordered pairs. 

4. Weighted Graph: A graph in which a weight (cost) is assigned to edges. 

Prepared By : 




A sequence of vertices a1, ... ,an where (ai,ai+1)∈E(G) is called a walk. We say 

that the walk connects a1 and an. 

If the walk does not intersect itself we call the walk a path. Note that if there is 

a walk from a1 to an then there is also a path from a1 to an. 

A closed path a1, ... ,an, a1 is called a cycle (circuit). 

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

The distance between two vertices is the length of the shortest path between 

them. 

A graph G is connected if there is a path between any pair of vertices. 

The diameter of a graph is the longest distance between any pair of vertices. 

A graph T is a tree if it is connected and has no cycles. 

If G is a graph, and G' is another graph with V(G) ⊇ V(G') and E(G) ⊇ E(G') we 

call G' a subgraph of G. 

If G' is a subgraph of G and V(G') = V(G) we call G' a spanning subgraph of G. If G' 

is a tree, it is called a spanning tree of G. 

A matching in a graph G is a set of edges such that no two share a vertex. 

A matching in a graph G is a perfect matching if every vertex of the graph 

belongs to an edge in the matching. 

A graph G is Hamiltonian if it has a path (cycle) that contains all vertices. 

A graph G is Eulerian if it has a walk (closed walk) that contains each edge 

exactly once. 

Prepared By : 




A graph G is called planar if it's vertices can be identified with points in the 

plane, it's edges with arcs joining the corresponding points so that no edges 

cross each other. 

By a coloring of the vertices of a graph we mean an assignment of colors 

(numbers) to the vertices so that if two vertices are connected by an edge, they 

are assigned distinct colors. 

A graph G is called bipartite if it's vertices can be colored by 2 colors. 

A labeling of a graph is an assignment of distinct labels (symbols) to it's vertices. 

Two graphs G and G' are isomorphic if it possible to label the vertices of G and 

G' by the same set of labels (i.e. by the integers 1,...,n) so that two vertices are 

connected by an edge in G if and only if they are connected by an edge in G'. 

A network is a weighted digraph with two distinguished vertices, S (source) and 

T (terminal, sink) such that all edges incident with S are directed away from S 

and all edges incident with T are directed towards T. 

The degree (valence) of a vertex a in a graph G is the number of distinct edges 

(a,x) in G. 

The Indegree of a vertex v in a DiGraph is |{(x,v) | (x,v) ∈ E(G)}| 

The Outdegree of a vertex x in a DiGraph is |{(x,v) | (x,v) ∈ E(G)}| 

REPRESENTATION of GRAPHS 

There are various ways to represent graphs, each has it's advantages and 

disadvantages. We will discuss 3 common ways to represent graphs. 

[1] Visual representation. Draw points in the plane, each point corresponding to 

a vertex of the graph. Connect two points by an arc if the corresponding vertices 

are connected by an edge (use arrows if the graph is a digraph).This 

representation is simple and straight forward. It is useful to visualize some 

properties of graphs. It is obviously limited to graphs of relatively small size. 

Prepared By : 




[2] Adjacency Matrix. Number the vertices of the graph G by 1,2,...,n. 

Define an n x n matrix as follows: 

A[i,j] = 0 if there is no edge between i and j. 

A[i,j] = Number of edges connecting i to j, or the weight of an edge 

from i to j. 

The matrix A is called the adjacency matrix of the graph G. We shall denote this 

matrix by A(G). This is a very powerful, flexible representation. The same matrix 

can be used to represent graphs, multigraphs, loops, digraphs and weighted 

graphs. It also gives us access to all matrix operations, and thus many graph 

algorithms can be designed to take advantage of these operations. The 

disadvantage of this representation is it's size. For a graph with n vertices it 

requires storage of size n2. In many applications only a small fraction of the 

possible edges are present. 

[3] Adjacency list. With each vertex x we associate a single list consisting of the 

vertices in the graph adjacent to x. The order within each list is usually arbitrary. 

This representation has the same flexibilities as the adjacency matrix, it is more 

compact than the adjacency matrix, as it does not account for missing edges. 

The price for the compactness is denial of access to matrix operations. The usual 

computer implementation of an adjacency list is an array (or a list) of linked 

lists. Note that the records used for the linked list implementation can store a 

variety of fields, thus giving this method a powerful flexibility. 

These are the most common representations used for graphs. There are other 

representations, usually tailored to fit some specific problem. The choice for 

your implementation usually depends on the operations you will need to 

perform. 

A graph can be represented in two ways: 

1.Undirected 2.Directed 

1.Undirected: as shown in fig :B 

Prepared By : 




In undirected method we have numbered a node as 1,2,3,4,5. therefore: 

V(G)={1,2,3,4,5}& 

E(G)={(1,2),(2,4),(2,3),(1,4),(1,5),(4,5),(3,4)} 

This is to be notice that edge incident with node 1& 2 is written as (1,2) ;we 

could also written it as (2,1).And this may same for all other edges . 

2. Directed:In an directed graph , pair of vertices representing any edges is 

ordered .if e=(v,w) ,then v is initial vertex and w is the final vertex 

subsequently (v,w )&(w,v). Represents two different edges . 

a directed graph may be 

pictorially represented as in fig C(above). 

GRAPH REPRESENTATION: 

Graph is a mathematical structure and finds its applications in many areas of 

interest in which problem need to be solved using computers .thus ,this 

mathematical structures must be represent in some kind of data structure 

.there are three such representations which are commonly used. 

Prepared By : 




These are : 

1. Adjacent matrix 

2. Adjacency list representation 

3. Multi list representation 

ADJACENT MATRIX: 

The adjacency matrix A for a graph G=(v,e) with n vertices , is an nxn matrix of 

bits such that Aij=1,if there is an edge from Vi to Vj & Aij=0,if there is no such 

edge .For undirected :as shown in 

fig 

1 2 3 4 5 6 

I \ j 

1 0 1 0 0 0 0 

2 1 1 1 0 0 0 

3 0 1 0 1 1 1 

4 0 0 1 0 0 0 

5 0 0 1 0 0 0 

6 0 0 1 0 0 0 

Fig:e 

The adjacency matrix for the undirected graph is shown in fig E. 

For directed graph: An edge of a directed graph has its source in one node and 

terminates in another nodes .By convection (Vi,Vj) denotes direction for node Vi 

to nodeVj. 

Prepared By : 




as shown in fig :f 

The adjacency matrix of the directed graph in fig:F is shown in fig :G: 

i \ j 1 2 3 4 5 6 

1 0 1 0 0 0 0 

2 0 1 1 0 0 0 

3 0 0 0 0 1 1 

4 0 0 1 0 0 0 

5 0 0 0 0 0 0 

6 0 0 0 0 0 0 

Fig :G 

In this representation we required nxn bits to represent a graph with n nodes . 

the adjacency matrix is a simple way to represent a graph ,but it has two 

disadvantages ; 

1. it takes o(nxn )space to represent a graph with n vertices,even for spars 

graph and 

2. it takes o(nxn)time to solve most of graph problem. 

ADJACENCY LIST REPRESENTATION: 

In this representation ,we store a graph as a linked structure. We store all the 

vertices in a list and then for each vertex ,we have a linked list of its adjacent 

vertices. 

Prepared By : 




For undirected: below shown fig:h is aadjacency list representation of 

undirected graph in fig D. 

An undirected graph of order N with E edges requires N enteries in the directory 

and ZxE linked list enteries,except that each loop reduces the no.of linked list 

enteries by one. 

For directed :adjacency list representatioof the directed graph of fig :F is shown 

in fig:I 

A directed graph of order an with E edges requires N enteries in the directory 

and E linked list enteries . 

Prepared By : 




Multi‐list representation: 

In the multi‐list representation of graph structures, there are two parts ,a 

directory of nodes information and a set of linked list of edge information .there 

is one entry in the node directory for each node of the graph .the directory 

entry for node i points to a linked adjacency list for node i. each record of the 

linked list area appears on two adjacency list:one for the node at each end of 

the represented edge. 

Using the data structure of fig :j for each edge entry (Vi,Vj),a multi‐list 

representation for the eg. Graph of fig :u is fig:K 

Prepared By : 




this is not the only multi‐list representation for this graph. It is based on the set 

of edges {(1,2),(2,2),(2,3),(4,3),(3,5),(3,6)}.an alternative representation based 

upon the set edges .{(2,1),(2,2),(2,3),(3,4),(5,3),(3,6)} is shown in fig:k. if the 

graph were directed ,there would not be such flexibility in selecting identifiers 

for edges an edge wieght can be stored with the other information recorded for 

the edge ,just as was done in earlier example of graph representations . 

Traversal Algorithms 

Prepared By : 




Introduction:‐ 

A graph traversal means visiting all the nodes of the graph . Graph 

traversal may be needed in many of the application areas. 

Given the root node of a binary tree, one of the most common 

things one wishes to do is to traverse the tree and visit the nodes in some 

order. In the case of trees, we have three ways to traverse it i.e. 

PREORDER, INORDER and POSTORDER. An analogous problem arises in 

the case of Graphs. 

Given an undirected graph G= (V, E) and a vertex v in V (G) we are 

inserted in visiting all vertices in G that are reachable from v (i.e., all 

vertices connected to v). We shall look at two ways of doing this:‐ 

1. Depth First Traversal(Depth First Search) 

2. Breadth First Traversal(Breadth First Search) 

Both techniques produce a systematic traverse and when properly applied are 

useful for checking some basic properties of graphs. Both traverse the graph 

along the edges of a forest (spanning tree if the graph is connected). 

DFS (Depth first search) 

Depth‐first search (DFS) is an algorithm for traversing or searching a tree, tree 

structure, or graph. One starts at the root (selecting some node as the root in 

the graph case) and explores as far as possible along each branch 

before backtracking 

DFS is an uninformed search that progresses by expanding the first 

child node of the search tree that appears and thus going deeper and 

deeper until a goal node is found, or until it hits a node that has no 

children. Then the search backtracks, returning to the most recent node it 

hasn't finished exploring. In a non‐recursive implementation, all freshly 

expanded nodes are added to a stack for exploration. 

The time and space analysis of DFS differs according to its 

application area. In theoretical computer science, DFS is typically used to 

traverse an entire graph, and takes time O(|V| + |E|), linear in the size of 

the graph. In these applications it also uses space O(|V| + |E|) in the 

Prepared By : 




worst case to store the stack of vertices on the current search path as well 

as the set of already‐visited vertices. Thus, in this setting, the time and 

space bounds are the same as for breadth first search and the choice of 

which of these two algorithms to use depends less on their complexity 

and more on the different properties of the vertex orderings the two 

algorithms produce. 

For applications of DFS to search problems in artificial intelligence, 

however, the graph to be searched is often either too large to visit in its 

entirety or even infinite, and DFS may suffer from non‐termination when 

the length of a path in the search tree is infinite. Therefore, the search is 

only performed to a limited depth, and due to limited memory availability 

one typically does not use data structures that keep track of the set of all 

previously visited vertices. In this case, the time is still linear in the 

number of expanded vertices and edges (although this number is not the 

same as the size of the entire graph because some vertices may be 

searched more than once and others not at all) but the space complexity 

of this variant of DFS is only proportional to the depth limit, much smaller 

than the space needed for searching to the same depth usingbreadth‐first 

search. For such applications, DFS also lends itself much better 

to heuristic methods of choosing a likely‐looking branch. When an 

appropriate depth limit is not known a priori, iterative deepening depth‐ 

first search applies DFS repeatedly with a sequence of increasing limits; in 

the artificial intelligence mode of analysis, with a branching factor greater 

than one, iterative deepening increases the running time by only a 

constant factor over the case in which the correct depth limit is known 

due to the geometric growth of the number of nodes per level. 

For the following graph:‐ 

Prepared By : 




a depth‐first search starting at A, assuming that the left edges in the 

shown graph are chosen before right edges, and assuming the search 

remembers previously‐visited nodes and will not repeat them (since this is a 

small graph), will visit the nodes in the following order: A, B, D, F, E, C, G. 

Performing the same search without remembering previously visited 

nodes results in visiting nodes in the order A, B, D, F, E, A, B, D, F, E, etc. forever, 

caught in the A, B, D, F, E cycle and never reaching C or G. 

Iterative deepening prevents this loop and will reach the following nodes 

on the following depths, assuming it proceeds left‐to‐right as above: 

0: A 

1: A (repeated), B, C, E 

(Note that iterative deepening has now seen C, when a conventional depth‐first 

search did not.) 

2: A, B, D, F, C, G, E, F 

(Note that it still sees C, but that it came later. Also note that it sees E via a 

different path, and loops back to F twice.) 

3: A, B, D, F, E, C, G, E, F, B 

For this graph, as more depth is added, the two cycles "ABFE" and "AEFB" will 

simply get longer before the algorithm gives up and tries another branch. 

Output of a Depth‐First Search 

Prepared By : 




The most natural result of a depth first search of a graph (if it is 

considered as a function rather than a procedure) is a spanning tree of the 

vertices reached during the search. Based on this spanning tree, the edges of 

the original graph can be divided into three classes: forward edges, which point 

from a node of the tree to one of its descendants, back edges, which point from 

a node to one of its ancestors, and cross edges, which do neither. 

Sometimes tree edges, edges which belong to the spanning tree itself, are 

classified separately from forward edges. It can be shown that if the graph is 

undirected then all of its edges are tree edges or back edges. 

Algorithm Of DFS:‐ 

Start with an arbitrary vertex v. 

Visit a neighbor w of v. Continue visiting vertices that have not been visited yet. 

If w has no unvisited neighbors return to the vertex from which you reached w 

(backtrack). Repeat until all vertices have been visited. Note that each edge will 

be tested at most twice. The traversed edges will never contain a cycle. 

1. Enqueue the root node. 

2. Pop a node from the stack and examine it. 

If the element sought is found in this node, quit the search and return 

a result. 

Otherwise enqueue any successors (the direct child nodes) that have 

not yet been discovered. 

Prepared By : 




3. If the stack is empty, every node on the graph has been examined 

– quit the search and return "not found". 

4. Repeat from Step 2. 

5. Exit 

Applications of DFS:‐ 

Algorithms where DFS is used: 

• Finding connected components. 

• Topological sorting. 

• Finding 2‐(edge or vertex)‐connected components. 

• Finding strongly connected components. 

• Solving puzzles with only one solution, such as mazes. (DFS can be 

adapted to find all solutions to a maze by only including nodes on the 

current path in the visited set.) 

Prepared By : 




BFS (Breadth first search) 

In graph theory, breadth‐first search (BFS) is a graph search 

algorithm that begins at the root node and explores all the neighboring 

nodes. Then for each of those nearest nodes, it explores their unexplored 

neighbor nodes, and so on, until it finds the goal. 

Breadth‐first search 

Order in which the nodes are expanded 

Working Of BFS:‐ 

BFS is an uninformed search method that aims to expand and 

examine all nodes of a graph or combination of sequences by 

systematically searching through every solution. In other words, it 

exhaustively searches the entire graph or sequence without considering 

the goal until it finds it. It does not use a heuristic algorithm. 

Prepared By : 




From the standpoint of the algorithm, all child nodes obtained by 

expanding a node are added to a FIFO queue. In typical implementations, 

nodes that have not yet been examined for their neighbors are placed in 

some container (such as a queue or linked list) called "open" and then 

once examined are placed in the container "closed". 

Example of BFS:‐ 

An example map of Germany with some connections between cities. 

The breadth‐first tree obtained when running BFS on the given map and 

starting in Frankfurt. 

Prepared By : 




Algorithm of BFS:‐ 

1) Choose v. Visit all neighbors of v that have not been visited. 

2) For each visited vertex repeat the same process until all vertices were visited. 

1. Enqueue the root node. 

2. Dequeue a node and examine it. 

a. If the element sought is found in this node, quit the search and 

return a result. 

b. Otherwise enqueue any successors (the direct child nodes) that 

have not yet been discovered. 

3. If the queue is empty, every node on the graph has been examined – quit 

the search and return "not found". 

4. Repeat from Step 2. 

5. Exit. 

Features of BFS:‐ 

Space complexity: 

Prepared By : 




Since all of the nodes of a level must be saved until their child nodes in 

the next level have been generated, the space complexity is proportional to the 

number of nodes at the deepest level. Given a branching factor b and graph 

depth d the asymptotic space complexity is the number of nodes at the deepest 

level, O(b d ). When the number of vertices and edges in the graph are known 

ahead of time, the space complexity can also be expressed as O( | E | + | V | 

) where | E | is the cardinality of the set of edges (the number of edges), 

and | V |is the cardinality of the set of vertices. In the worst case the graph has 

a depth of 1 and all vertices must be stored. Since it is exponential in the depth 

of the graph, breadth‐first search is often impractical for large problems on 

systems with bounded space. 

Time complexity 

Since in the worst case breadth‐first search has to consider all paths to all 

possible nodes the time complexity of breadth‐first search 

is which asymptotically approaches O (b d ). The time 

complexity can also be expressed as O (| E | + | V |) since every vertex and 

every edge will be explored in the worst case. 

Completeness: 

Breadth‐first search is complete. This means that if there is a solution 

breadth‐first search will find it regardless of the kind of graph. However, if the 

graph is infinite and there is no solution breadth‐first search will diverge. 

Proof of Completeness 

if the shallowest goal node is at some finite depth say d, breadth‐first 

search will eventually find it after expanding all shallower nodes (provided that 

the branching factor b is finite). 

Optimality 

For unit‐step cost, breadth‐first search is optimal. In general breadth‐first 

search is not optimal since it always returns the result with the fewest edges 

between the start node and the goal node. If the graph is a weighted graph, and 

therefore has costs associated with each step, a goal next to the start does not 

have to be the cheapest goal available. This problem is solved by improving 

Prepared By : 




breadth‐first search to uniform‐cost search which considers the path costs. 

Nevertheless, if the graph is not weighted, and therefore all step costs are 

equal, breadth‐first search will find the nearest and the best solution. 

Applications of BFS:‐ 

• Breadth‐first search can be used to solve many problems in graph 

theory, for example: 

• Finding all connected components in a graph. 

• Finding all nodes within one connected component 

• Copying Collection, Cheney's algorithm 

• Finding the shortest path between two nodes u and v (in 

an unweighted graph) 

• Finding the shortest path between two nodes u and v (in a weighted 

graph: see talk page) 

• Testing a graph for bipartiteness 

• (Reverse) Cuthill–McKee mesh numbering 

Minimum Spanning Tree: 

A minimum spanning tree is a subgraph of an undirected weighted graph G, 

such that 

• it is a tree (i.e., it is acyclic) 

• it covers all the vertices V 

– contains |V| ‐ 1 edges 

• the total cost associated with tree edges is the minimum among all 

possible spanning trees 

• not necessarily unique 

A spanning tree is a tree that contains all of the vertices in the graph. The 

minimum spanning tree is a spanning tree in which the total weight of the lines 

are guaranteed to be the minimum of all possible trees in the graph. 

Prepared By : 




To create a minimum spanning tree in a strongly connected network, that is in a 

network in which there is a path between any two vertices, the edges for the 

minimum spanning tree are chosen so that the following properties exist: Every 

vertex is included. The total edge weight of the spanning tree is the minimum 

possible that includes a path between any two vertices. 

4 

2 

Applications 

• Any time you want to visit all vertices in a graph at minimum cost (e.g., 

wire routing on printed circuit boards, sewer pipe layout, road planning…) 

• Internet content distribution 

– $$$, also a hot research topic 

– Idea: publisher produces web pages, content distribution network 

replicates web pages to many locations so consumers can access at 

higher speed 

– MST may not be good enough! 

• content distribution on minimum cost tree may take a long 

time! 

Provides a heuristic for traveling salesman problems. 

Given a weighted graph G find a minimum cost spanning tree. 

0 

3 

3 2 

2 

Prepared By : 


Assist Prof., CSE, H.C.T.M (Kaithal) Page ‐ 93 ‐ 

1 

1


Network has 10 edges. 

Spanning tree has only n ‐ 1 = 7 edges. 

Need to either select 7 edges or discard 3. 

• Start with an n‐vertex 0‐edge forest. Consider edges in ascending order of 

cost. Select edge if it does not form a cycle together with already selected 

edges. 

Kruskal’s method. 

• Start with a 1‐vertex tree and grow it into an n‐vertex tree by repeatedly 

adding a vertex and an edge. When there is a choice, add a least cost 

edge. 

Prim’s method. 

• Start with the connected graph. Repeatedly find a cycle and eliminate the 

highest cost edge on this cycle. Stop when no cycles remain. 

Consider edges in descending order of cost. Eliminate an edge provided 

this leaves behind a connected graph. 

Prepared By : 




Prepared By : 




Prepared By : 




Prepared By : 




Algorithm 1 (Kruskal): 

1) Order the edges by increasing weight. 

2) Add the edge ei if it does not produce a cycle. Ignore if it does. 

3) Stop when the (n‐1)‐st edge is added. 

The following description explains what this algorithm does: 

At any given stage we have a collection of disjoint trees (a forest). We add the 

cheapest edge that joins two distinct trees into a single tree. This is a GREEDY 

algorithm. The spanning tree produced is not unique. The initial state is just a 

collection of isolated vertices (trivial trees). 

Algorithm 2 (Prim) 

1) Choose an arbitrary vertex as your initial tree. 

2) To the current tree T add an edge (g,t) where g G\T , t T and the 

edge (g,t) chosen is the cheapest possible. 

3) Stop when T has all vertices or no more edges are available. 

Shortest Path 

Another common application used with graph requires that we find the shortest 

path between tow vertices in a network. For example, if the network 

represents the routes flown by an airline, when we travel we would like to find 

the least expensive route between home and our destination. 

Prepared By : 



DESTINATION 

DESTINATION 


SOURCE 

4 

4 

4 

4 

2 

6 

0 

3 

10 6 

5 

3 2 

2 

2 

6 

0 

1 

3 2 

2 

1 

2 

SHORTEST PATH IS 0, 2, 3 

3 

10 6 

SOURCE 

5 

1 

1 

Prepared By : 



2

LINK LIST 


LINK LISTS 

A linked list,or one‐way list, is a linear collection of data elements, called nodes, 

where the linear order is given by means of pointers. That is, each node is 

divided into two parts: the first contains the information of the elements, and 

the second part, called the link field or nextpointer field, contains the address of 

the next node in the list. 

The fig. is a schematic dia. Of a linked list with 6 nodes, Each node is pictured 

with two parts. The left part represents the information part of the node, which 

may contain an entire record of data items (e.g. NAME, ADDRESS, . . . .) the right 

part represents the nextpointer field of the node, and there is an arrow drown 

from it to the next node in the list .This follows the usual practice of drawing an 

arrow from a field to a node when the address of the node appears in the given 

field. 

Simple linked lists store dynamic variables in a single, one‐directional chain. 

data 1 data 2 data 3 

We want to create an ADT for simple linked lists with the following operations: 

• Create: Start a new list with nothing in it. 

• Insert: Add a record to the list. 

• Delete: Delete a record from the list. 

• Get Info: Find and return information from a record in the list. 

LINKED LIST STRUCTURE 

In sequential list representation,same kind of information are stored in a 

continuous memory addresses. 

Prepared By : 




For example in an array data structure, sorted names are stored in the following memory representation. 

If we insert a new name in to this sorted array representation, we have to first 

determine the location and than do the necessary swapping for the other 

elements and then we have to insert the new name into the correct position. 

We have the same problem if we delete any given name also. 

An elegant solution to this problem of data movement in sequential 

representation is achieved by using linked representation. Unlike a sequential 

representation where successive items of a list are located a fixed distance 

apart, in a linked representation these items may be placed anywhere in 

memory. To access elements in sequential list(arrays) representation we use 

subscript variables. Where else in linked representation we need a pointer value 

which point the address of next element. That’s why a typical node structure of 

a linked list data structure is as follows. 

Prepared By : 




Thus, associated with each data item in a linked list representation is a pointer 

to the next item. This pointer is often referred to as a link. In general, a node is 

a collection of data, Data1,…,Datan and links Link1,..,Linkm. Each item in a node is 

called a field. A field contains either a data item or a link. 

Linked Structure 

linked list ‐ A collection of items, called nodes, that can be physically scattered 

about memory, not necessarily in consecutive memory locations. 

Programmers responsible for maintaining logical order by chaining nodes 

together. Each node has two components: 

• The element (data object) ‐ (ItemType) 

• The link ‐ gives the location of the next node in the list ‐ 

establishes the logical order. 

Node : 

Dynamic representation of a list: 

Prepared By : 




Dynamic Data Structure ‐ A data structure that can expand and contract during 

execution. 

Dynamic Linked List ‐ A linked list composed of dynamically allocated nodes that 

are linked together by pointers. 

External Head Pointer ‐ A pointer variable that points to the first node in a 

dynamic linked list. 

EXAMPLE 

A hospital ward contains 12 beds, of which 9 are occupied as shown in fig. 

Suppose we want an alphabetical listing of the patients. This listing may be 

given by the pointer field, called Next in fig. We use the variable START to point 

to the first patient. Hence START contains 5, since the first patient, Adams, 

occupies bed 5. Also, Adams’s pointer is equal to 3, since Dean, the next patient, 

occupies bed3; Dean’s pointer is 11, since Fields, the next patient, occupies bed 

11;and so on. The entry for the last patient(Samuels) contains the null pointer , 

denoted by 0 . 

Representation of linklists in memory 

Let LIST be a linked list. Then LIST will be maintained in memory, unless 

otherwise specified or implied, as follows. First of all, LINK requires two 

linear arrays‐ we will call them here INFO and LINK‐ such that INFO[k] and 

LINK[k] contain, respectively, the information part and the next pointer field of 

a node of LIST. As noted above, LIST also requires a variable name‐ such as 

START‐which contains the location of the beginning of the list, and a 

nextpointer sentinel‐denoted by NULL‐which indicates the end of the list. Since 

the subscripts of the arrays INFO and LINK will usually be positive, we will 

choose NULL=0, unless otherwise stated. 

Types Of link list Structures : 

Circular linked list structure. 

Prepared By : 




In this structure link field of the last node points the head address of the list and 

we obtain a circular linked list structure. In a circular list the next field in the last 

node contains a pointer back to the first node rather than the null pointer. From 

any point in such a list it is possible to reach any other point in the list. 

Note that a circular list does not have a natural “first” or “last” node. We 

therefore, establish a first and last node by convention. One useful convention 

is to let the external pointer to the circular list point to the last node, and to 

allow the following node to be the first node 

Doubly Linked list Structure. 

In this kind of linked list structure each node has two link(pointer) fields, Right 

pointer and left pointer. We mostly use this kind of structure for 

ordered(sorted) list structure. So it becomes so easy to obtain ascending and 

descending order of information. In this structure there are two head nodes. 

Which are the beginning points of Left head and Right head. 

Prepared By : 




Operations on Single Link List 

INSERTION OPRETATION 

TO insert an element in the list, the first task is to get a free node, assign the 

element to be inserted to the info field of the node, and then new node is 

placed at the appropriate position by adjusting the appropriate pointer. The 

insertion in the list can take place at the following positions:‐ 

at the beginning of the list 

at the end of the list 

after a given element 

Insertion has three steps: 

1. Create a new element to add to the list 

2. Find the record preceding the place it should go in the list 

3. Do the insertion 

Prepared By : 




INSERTING AT THE BEGINNING OF THE LIST 

To insert an element at the beginning of the list,first we test whether the linked 

list is initially empty .If yes, then the element is inserted as the first and only 

element of the list 

However, if the list is initially not empty, then the element is inserted as the 

first element of the list 

Algorithm 

INSERT_FIRST(START ITEM).This algo insert an item as the first Node of the 

Linked list pointed by start 

1. [check for overflow ?] 

if PTR=NULL, then 

print,overflow 

exit 

else 

PTR=(Node *) malloc(size of (node)). 

//Create new node from memory and assign its 

address to PTR 

End if 

2. Set PTR INFO=item 

3. Set PTRNEXT=START 

4. Set START=PTR 

INSERTING A NODE AT THE END 

To insert the element at the end of the list, first we test whether the linked list 

is initially empty.If yes, then the element is inserted as the first and and only 

element of the list 

Prepared By : 




However, if the list is initially not empty, then the list is traversed to reach the 

last element, and then then the element is inserted as the last element of the 

list 

Algorithm 

INSERT_LAST(START, ITEM).This algo inserts an item at the last of the linked 

list. 

1. [Check for overflow ?] 

if PTR=NULL, then 

print, ‘over flow’ 

exit 

else 

PTR=(Node *)malloc (size of (node)); 

END if 

2. Set PTRInfo=Item 

3. Set PTRNext=NULL 

4. If START=NULL and If then set START=p; 

5. Set LOC=start 

6. Repeat step 7 untill Lonext!=NULL 

7. Set Loc=lonext 

8. Set Lonext=p 

Prepared By : 




INSETING A NODE AT THE SPECIFIED POSITION 

TO insert the new element after the given element, first we find the 

location, say loc, of the given element in the list, and then the element is 

inserted in the list 

Algorithm 

INSERT_LOCATION(START, item, loc).This algorithm inserts an item at the 

specified position in the linked list. 

1.[check for overflow ?] 

if PTR= = NULL, then 

print ‘overflow’ 

exit 

else 

PTR=(Node *) malloc (size of(node)) 

END if 

2. Set PTRINFO= Item 

3. If start= NULL then 

Set start=p 

Set next=NULL 

END if 

4.Initialise the counter(I) and pointers 

(Node * temp) 

set I=0 

set temp= START 

5. Repeat step 6 and 7 untill I


DELETION OPRERATION 

TO delete an element from the list, first the pointers are set properly and then 

the memory occupied by the node to be deleted is deallocated(freed). 

The deletion in the list can take place at the following positions: 

at the beginning of the list. 

at the end of the list 

after a given element 

Deletion has two steps: 

1. Find the record preceding the one to be deleted from the list 

2. Do the deletion 

DELETING FROM THE BEGINNING OF THE LIST 

An element from the beginning of the list can be deleted by following the given 

below algorithm 

Algorithm 

Delete First (START). This algorithm Deletes an elements from the first position 

or frent of the linked list. 

1. [check for under flow ?] 

If START = NULL, THEN 

Print ‘Linked list empty’ 

Exit 

End if 

2. Set PTR = START 

3. Set START = STARnext 

4. Print, element deleted is, praInfo. 

5. free(ptr). 

Prepared By : 




DELETING FROM THE END OF THE LIST 

To delete anelement from the end of the list, we first traverse to the second last 

element of the list and follow the given below algorithm 

Algorithm 

Deleting (START).This algorithm deletes an element from the last position of the 

linked list. 

1. [Check for underflow ?] 

if start = NULL , then 

print, ‘Linked list empty’ 

Exit 

End if 

2. If start next = NULL, then 

Set PTR=start 

Set start = NULL 

Print, element deleted is = PTR INFO 

Free(PTR) 

END if 

3.Set PTR =START 

4. Repeat steps 5 and 6 will PTNext!=NULL 

5. Set LOC = PTR 

6. Set PTR = PTNext 

7. Set LOCnext = NULL 

8.Free( PTR) 

DELETION AFTER A GIVEN ELEMENT OF THE LIST 

To delete an element after a given element, first we find the location(say loc) of 

the element after which the element to be deleted comes. 

Prepared By : 



Algorithm 


Delete‐location(START , LOC).This algorithm deletes an element from the 

specified position of the linked list. 

1. [check for under flow ?] 

If PTR= = NULL, then 

Print “underflow” 

Exit 

2. [Initialise the counter, I and pointers] 

Node * temp, node *PTR ; 

Set I=0 

Set *ptr = START 

3. Repeat step 4 to 9 untill I


1) Assign currentNode to previousNode 

2) Assign nextNode to currentNode 

3) Assign currentNodenext to nextNode 

4) Assign previousNode to currentNode 

These steps are repeated, till the last element becomes the current element. 

At this point , assign the address of the last element , held in variable 

currentNode, to head variable. 

Two‐way (Doubly) Linked Lists 

Two‐way linked lists make it easier to move backward (in addition to forward) 

in the list. 

Two‐way linked lists usually have a dummy node (called Head), with head and 

tail pointers already built‐in to the structure. 

The empty list looks like: 

Two_Way_Linked_List T; 

head 

data1 data2 data3 

Prepared By : 




Two_Way_Linked_List T; 

head 

In the linear linked list, we can only traverse the linked list in one direction. But 

sometimes, it is very desirable to traverse a linked list in either a forward or 

reverse manner. This property of a linked list implies that each node must 

contain two link fields instead of one. The links are used to denote the 

predecessor and successor of a node. The link denoting the predecessor of a 

node is called the left link, and that denoting its successor its right link. The 

Figure 3.1‐01 shows the structure of the node. 

A list containing this type of node is called a doubly linked linear list. See Figure 

3.1‐02. 

Left and Right are pointer variables denoting the left‐most and right‐most nodes 

in the list. The left link of the left‐most node and the right link of the right‐most 

Prepared By : 




node are both NULL, indicating the end of the list for each direction. 

Same as the linear linked list, the basic operations of double linked list include 

insertion, deletion and search. We will discuss them in the following section. 

To create an ADT for two‐way linked lists the following operations (at a 

minimum) are needed: 

• Create: Start a new list with nothing in it. 

• Insert: Add a record to the list. 

• Delete: Delete a record from the list. 

• Get Info: Find and return information from a record in the list. 

These operations basically mimic the simple linked list case, except that 

additional access variables must be used. 

OPERATIONS: 

Insertion of Double Linked List: 

Insertion is to add a new node into a linked list. It can take place anywhere ‐‐ 

the first, last, or interior of the linked list. 

To add a new node to the head and tail of a double linked list is similiar to the 

linear linked list. First, we need to construct a new node that is pointed by 

pointer new. Then the new node is linked to the left‐most node (or right‐most 

node) in the list. Finally, the Left (or Right) is set to point to the new node. 

To add a new node inside a double linked list is much more complicated. Four 

links must be attached. The following example will give you the details 

Example: Insert a new node to the left of a node pointed by cur in a double 

linked list. 

Prepared By : 




Step 1. Create a new node that is pointed by New. See Figure 3.2.1‐01. 

Step 2. Setting pointer prev points to the left node of the node pointed by cur. 

See Figure 3.2.1‐02. 

Step3. Setting the left link of the new node points to the node pointed by prev, 

and the right link of the new node points to the node pointed by cur. See Figure 

3.2.1‐03. 

Prepared By : 




Step4. Setting the righ link of the node pointed by prev and the left link of the 

node pointed by cur point to the new node. See Figure 3.2.1‐04. 

Deletion of Double Linked List: 

Deletion is to remove a node from a list. It can also take place anywhere ‐‐ the 

first, last, or interior of a linked list. 

To delete a node from a double linked is easier than to delete a node from a 

linear linked list. For deletion of a node in a single linked list, we have to search 

and find the predecessor of the discarded node. But in the double linked list, no 

such search is required. Given the address of the node that is to be deleted, the 

predecessor and successor nodes are immediately known. 

The following example will give the details 

Example: Delete a node pointed by old from a double linked list. Assume the list 

is not empty. 

Step 1. Setting pointer prev points to the left node of old and pointer cur points 

to the node on the right of old. See Figure 3.2.2‐01. 

Prepared By : 




Step2. Set the right link of prev points to cur, and the left link of cur points to 

prev. See Figure 3.2.2‐02. 

Step3. Discard the node pointed by old. See Figure 3.2.2‐03. 

Prepared By : 




Circular Link List 

Circular linked list is a linked list in which the last node of the list points to the 

first node in the list. 

A good example of an application where circular linked list should be used is a 

timesharing problem solved by the operating system. In a timesharing 

environment, the operating system must maintain a list of present users and 

must alternately allow each user to use a small slice of CPU time, one user at a 

time. The operating system will pick a user, let him/her use a small amount of 

CPU time and then move on to the next user, etc. For this application, there 

should be no NIL pointers unless there is absolutely no one requesting CPU 

time. 

The insert, delete and search operations are similar to the singly linked list. In 

circular linked list, we should always maintain that the next node of the tail is 

linked to the head after the insertion and deletion operations: Advantages: 

Disadvantage: 

• Each node is accessible from any node. 

• Address of the first node is not needed. 

• Certain operations, such as concatenation and splitting of string, is 

more efficient with circular linked list. 

• Danger of an infinite loop ! 

Prepared By : 




Application of Linked List structure. 

Creation of Symbol Tables: 

An important part of compiler is the construction and maintenance of dictionary 

containing names of variables and their associated values. Such a dictionary is also 

called a symbol table. Symbol table is used in order to get some advantage of 

memory space and processing time. 

It is an easy matter to construct a very fast symbol‐table system, provided that a 

large section of memory is available. In such case a unique memory address is 

assigned to each name, where the address is obtained from the arithmetic value 

of the characters making up the variable name. 

• The most straightforward method of accessing a symbol table is by using 

linear search method. The insertion is fast but referencing is slow. 

• Binary search method could be another method which can be used. The 

entries in the table are stored in alphabetical or numerically increasing order. 

This is considerably better than the search time for the linear search method. 

• The other method is hashing method. In this method a function maps a name 

into an integer number. 

Prepared By : 



MATRIX:‐ 


SPARSE MATRIX 

An m*n (pronounced as m by n) matrix is a two‐dimensional array 

whose m.n elements are arranged in m rows and n columns. A matrix is denoted 

by capital letters such as A, B, C,….., and its elements are denoted by 

corresponding lower letters suffixed with row index and column index such as 

aij.,bij.,cij.,…..,respectively. 

Entries of a matrix are often denoted by a variable with two subscripts, as 

shown:‐ 

Example:‐ 

Prepared By : 




is a 4*4 matrix. 

An alternative notation uses large parenthesis instead of box brackets as 

shown:‐ 

Matrices are often used to organize data for business and scientific applications. 

It has been proved that many scientific & engg. Problems can be solved 

efficiently if they are expressed using matrices. 

NOTATIONS OF MATRIX:‐ 

The horizontal lines in a matrix are called rows and the vertical lines are called 

columns. A matrix with m rows and n columns is called an m‐by‐n matrix (or 

m×n matrix) and m and n are called its dimensions. 

We write to define an m × n matrix A with each 

entry in the matrix called aij for all 1 ≤ i ≤ m and 1 ≤ j ≤ n. In the above example, 

the element A [2, 3] or a23 =7. 

Some programming languages start the numbering of rows and columns at 

zero, in which case the entries of an m‐by‐n matrix are indexed by 0 ≤ i ≤ m − 1 

and 0 ≤ j ≤ n − 1. 

Prepared By : 




Functions:‐ 

A function is a relation between a given set of elements (the domian) and 

another set of elements (the codomain), which associates each element in the 

domain with exactly one element in the codomain. The elements so related can 

be any kind of thing (words, objects, qualities). 

In matrix, a matrix coefficient (or matrix element) is a function on a group of a 

special form, which depends on a linear representation of the group and 

additional data. 

OPERATIONS ON MATRIX:‐ 

The operations most commonly performed on matrices are:‐ 

(A) ADDITION 

(B) SUBTRACTION 

(C) MULTIPLICATION 

(D) TRANSPOSE 

(A) ADDITION:‐ 

The sum of two matrices is defined only when the two matrices 

are compatible i.e. have the same number of rows and columns. The sum of 

two m*n matrices A and B is a third m*n matrix C such that Cij=aij+bij (for 0 ≤ 

i ≤ m‐1 and 0 ≤ j ≤ n‐1). 

The sum of two matrices is the matrix, which (i,j)‐th entry is equal to 

the sum of the (i,j)‐th entries of two matrices: 

The two matrices have the same dimensions. Here A + B = B + A is true. 

(B) SUBTRACTION:‐ 

Prepared By : 




The difference of two matrices is also defined only when the 

two matrices are compatible. The difference of m*n matrix A is a third m*n 

matrix C such that 

Cij=aij‐bij (for 0 ≤ i ≤ m‐1 and 0 ≤ j ≤ n‐1). 

The difference of two matrices is the matrix, which (i,j)‐th entry is equal to the 

difference of the (i,j)‐th entries of two matrices: 

(C) MULTIPLICATION:‐ 

The product, A*B, of a m*n matrix A and a q*p matrix B is 

defined only when the number of columns in A equals the number of rows in B, 

i.e., n=q. When n=q, the product is a m*p matrix C with the property 

Cij =Σ aik bjk (for 0 ≤ i ≤ m‐1 and 1 ≤ j ≤ n‐1). 

In matrix, the multiplication of two matrices is a bit more complicated: 

• Two matrices can be multiplied with each other even if they have 

different dimensions, as long as the number of columns in the first matrix 

is equal to the number of rows in the second matrix. 

• The result of the multiplication, called the product, is another matrix with 

the same number of rows as the first matrix and the same number of 

columns as the second matrix. 

• The multiplication of matrices is not commutative, this means, in general 

that . 

• The multiplication of matrices is associative, this 

means . 

Prepared By : 




(C) TRANSPOSE:‐ 

The transpose of a m*n matrix A is an n*m matrix B (denoted as A T 

) with the property bij = aji (for 0 ≤ i ≤ n‐1 and 0 ≤ j ≤ m‐1). 

The transpose of a matrix A is another matrix A T (also written A′) can be created 

by any one of the following equivalent actions: 

• Write the rows of A as the columns of A T . 

• Write the columns of A as the rows of A T . 

• Reflect A by its main diagonal (which starts from the top left) to obtain A T 

INTRODUCTION OF 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. 

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 every 

ball to every other ball, the system would be represented by a dense matrix. 

Prepared By : 




The concept of sparsity is useful in combinatorics and application areas such as 

network theory, of a low density of significant data or connections. 

Huge sparse matrices often appear in science or engineering when solving 

partial differential equations. 

When storing and manipulating sparse matrices on a computer, it is beneficial 

and often necessary to use specialized algorithms and data structures that take 

advantage of the sparse structure of the matrix. Operations using standard 

matrix structures and algorithms are slow and consume large amounts of 

memory when applied to large sparse matrices. Sparse data is by nature easily 

compressed, and this compression almost always results in significantly less 

memory usage. Indeed, some very large sparse matrices are impossible to 

manipulate with the standard algorithms. 

One example of such a sparse matrix format is the Yale Sparse Matrix Format. It 

stores an initial sparse m×n matrix, M, in row form using three one‐dimensional 

arrays. Let NNZ denote the number of nonzero entries of M. The first array is A, 

which is of length NNZ, and holds all nonzero entries of M in left‐to‐right top‐to‐ 

bottom (row‐major) order. The second array is IA, which is of length m + 1 (i.e., 

one entry per row, plus one). IA(i) contains the index in A of the first nonzero 

element of row i. Row i of the original matrix extends from A(IA(i)) to A(IA(i+1)‐ 

1), i.e. from the start of one row to the last index before the start of the next. 

The third array, JA, contains the column index of each element of A, so it also is 

of length NNZ. 

For example, the matrix 

[ 1 2 0 0 ] 

[ 0 3 9 0 ] 

[ 0 1 4 0 ] 

is a three‐by‐four matrix with six nonzero elements, so 

A = [ 1 2 3 9 1 4 ] // List of non‐zero matrix element in order 

IA = [ 1 3 5 7 ] // IA(i) = Index of the first nonzero element of row i in A 

JA = [ 1 2 2 3 2 3 ] // JA(i) = Column position of the non zero element A(i) 

Prepared By : 




Sparse Matrix Storage Representation 

A sparse matrix can be stored in full‐matrix storage mode or a packed 

storage mode. When a sparse matrix is stored in full‐matrix storage 

mode, all its elements, including its zero elements, are stored in an 

array. 

The seven packed storage modes used for storing sparse matrices are 

described in the following: 

• Compressed‐Matrix Storage Mode 

• Compressed‐Diagonal Storage Mode 

• Storage‐by‐Indices 

• Storage‐by‐Columns 

• Storage‐by‐Rows 

1. Compressed‐Matrix Storage Mode 

The sparse matrix A, stored in compressed‐matrix storage mode, uses 

two two‐dimensional arrays to define the sparse matrix storage, AC 

and KA. Given the m by n sparse matrix A, having a maximum of nz 

nonzero elements in each row: 

• AC is defined as AC(lda,nz), where the leading dimension, lda, 

must be greater than or equal to m. Each row of array AC 

contains the nonzero elements of the corresponding row of 

matrix A. For each row in matrix A containing less than nz 

nonzero elements, the corresponding row in array AC is padded 

with zeros. The elements in each row can be stored in any order. 

• KA is an integer array defined as KA(lda,nz), where the leading 

dimension, lda, must be greater than or equal to m. It contains 

the column numbers of the matrix A elements that are stored in 

the corresponding positions in array AC. For each row in matrix 

Prepared By : 




A containing less than nz nonzero elements, the corresponding 

row in array KA is padded with any values from 1 to n. Because 

this array is used by the ESSL subroutines to access other target 

vectors in the computation, you must adhere to these required 

values to avoid errors. 

Consider the following as an example of a 6 by 6 sparse matrix A with a 

maximum of four nonzero elements in each row. It shows how matrix 

A can be stored in arrays AC and KA. 

Given the following matrix A: 

┌ ┐ 

| 11 0 13 0 0 0 | 

| 21 22 0 24 0 0 | 

| 0 32 33 0 35 0 | 

| 0 0 43 44 0 46 | 

| 51 0 0 54 55 0 | 

| 61 62 0 0 65 66 | 

└ ┘ 

the arrays are: 

┌ ┐ 

| 11 13 0 0 | 

| 22 21 24 0 | 

AC = | 33 32 35 0 | 

| 44 43 46 0 | 

| 55 51 54 0 | 

| 66 61 62 65 | 

└ ┘ 

┌ ┐ 

| 1 3 * * | 

| 2 1 4 * | 

KA = | 3 2 5 * | 

| 4 3 6 * | 

| 5 1 4 * | 

| 6 1 2 5 | 

└ ┘ 

Prepared By : 




where "*" means you can store any value from 1 to 6 in that position 

in the array. 

2. Compressed‐Diagonal Storage Mode 

The storage mode used for square sparse matrices stored in 

compressed‐diagonal storage mode has two variations, depending 

on whether the matrix is a general sparse matrix or a symmetric 

sparse matrix. This explains both of these variations; however, the 

conventions used for numbering the diagonals in the matrix, which 

apply to the storage descriptions, are explained first. 

Matrix A of order n has 2n‐1 diagonals. Because k = j‐i is constant 

for the elements aij along each diagonal, each diagonal can be 

assigned a diagonal number, k, having a value from 1‐n to n‐1. Then 

the diagonals can be referred to as dk, where k = 1‐n, n‐1. 

The following matrix shows the starting position of each diagonal, 

dk: 

For a general (square) sparse matrix A, compressed‐diagonal 

storage mode uses two arrays to define the sparse matrix storage, 

Prepared By : 




AD and LA. Using the above convention for numbering the 

diagonals, and given that sparse matrix A contains nd diagonals 

having nonzero elements, arrays AD and LA are set up as follows: 

• AD is defined as AD(lda,nd), where the leading dimension, 

lda, must be greater than or equal to n. Each diagonal of 

matrix A that has at least one nonzero element is stored in a 

column of array AD. All of the elements of the diagonal, 

including its zero elements, are stored in n contiguous 

locations in the array, in the same order as they appear in 

the diagonal. Padding with zeros is required as follows to fill 

the n locations in each column of array AD: 

o Each superdiagonal (k > 0), which has n‐k elements, is 

padded with k trailing zeros. 

o The main diagonal (k = 0), which has n elements, does 

not require padding. 

o Each subdiagonal (k < 0), which has n‐|k| elements, is 

padded with |k| leading zeros. 

• LA is a one‐dimensional integer array of length nd, containing 

the diagonal numbers k for the diagonals stored in each 

corresponding column in array AD. 

3. Storage‐by‐Indices 

For a sparse matrix A, storage‐by‐indices uses three one‐ 

dimensional arrays to define the sparse matrix storage, AR, IA, and 

JA. Given the m by n sparse matrix A having ne nonzero elements, 

the arrays are set up as follows: 

• AR of (at least) length ne contains the ne nonzero elements of 

the sparse matrix A, stored contiguously in any order. 

• IA, an integer array of (at least) length ne contains the 

Prepared By : 




corresponding row numbers of each nonzero element, aij, in 

matrix A. 

• JA, an integer array of (at least) length ne contains the 

corresponding column numbers of each nonzero element, aij, 

in matrix A. 

Consider the following as an example of a 6 by 6 sparse matrix A and 

how it can be stored in arrays AR, IA, and JA.: 


┌ ┐ 

| 11 0 13 0 0 0 | 

| 21 22 0 24 0 0 | 

| 0 32 33 0 35 0 | 

| 0 0 43 44 0 46 | 

| 0 0 0 0 0 0 | 

| 61 62 0 0 65 66| 

└ ┘ 


AR = (11, 22, 32, 33, 13, 21, 43, 24, 66, 46, 35, 62, 61, 65, 44) 

IA = (1, 2, 3, 3, 1, 2, 4, 2, 6, 4, 3, 6, 6, 6, 4) 

JA = (1, 2, 2, 3, 3, 1, 3, 4, 6, 6, 5, 2, 1, 5, 4) 

AR(k) = aij 

IA(k) = i 

JA(k) = j 

where: 

aij are the elements of the m by n sparse matrix A. 

Arrays AR, IA, and JA each have ne elements. 

4. Storage‐by‐Columns 

Prepared By : 




For a sparse matrix, A, storage‐by‐columns uses three one‐ 





the sparse matrix A, stored contiguously. The columns of 

matrix A are stored consecutively from 1 to n in AR. The 

elements in each column of A are stored in any order in AR. 

• IA, an integer array of (at least) length ne contains the 

corresponding row numbers of each nonzero element, aij, in 

matrix A. 

• JA, an integer array of (at least) length n+1 contains the 

relative starting position of each column of matrix A in array 

AR; that is, each element JA(j) of the column pointer array 

indicates where column j begins in array AR. If all elements in 

column j are zero, then JA(j) = JA(j+1). The last element, 

JA(n+1), indicates the position after the last element in array 

AR, which is ne+1. 

Consider the following as an example of a 6 by 6 sparse matrix A and 

how it can be stored in arrays AR, IA, and JA. 


| 11 0 13 0 0 0 | 

| 21 22 0 24 0 0 | 

| 0 32 33 0 0 0 | 

| 0 0 43 44 0 46 | 

| 0 0 0 0 0 0 | 

| 61 62 0 0 0 66 | 


AR = (11, 61, 21, 62, 32, 22, 13, 33, 43, 44, 24, 46, 66) 

IA = (1, 6, 2, 6, 3, 2, 1, 3, 4, 4, 2, 4, 6) 

Prepared By : 




JA = (1, 4, 7, 10, 12, 12, 14) 

5. Storage‐by‐Rows 

The storage mode used for sparse matrices stored by rows has 

three variations, depending on whether the matrix is a general 

sparse matrix or a symmetric sparse matrix. This explains these 

variations. 

For a general sparse matrix A, storage‐by‐rows uses three one‐ 





the sparse matrix A, stored contiguously. The rows of matrix 

A are stored consecutively from 1 to m in AR. The elements in 

each row of A are stored in any order in AR. 

• IA, an integer array of (at least) length m+1 contains the 

relative starting position of each row of matrix A in array AR; 

that is, each element IA(i) of the row pointer array indicates 

where row i begins in array AR. If all elements in row i are 

zero, then IA(i) = IA(i+1). The last element, IA(m+1), indicates 

the position after the last element in array AR, which is ne+1. 

• JA, an integer array of (at least) length ne contains the 

corresponding column numbers of each nonzero element, aij, 

in matrix A. 

Consider the following as an example of a 6 by 6 general sparse 

matrix A and how it can be stored in arrays AR, IA, and JA. 


Prepared By : 




| 11 0 13 0 0 0 | 

| 21 22 0 24 0 0 | 

| 0 32 33 0 0 0 | 

| 0 0 43 44 0 46| 

| 0 0 0 0 0 0| 

| 61 62 0 0 0 66 | 


AR = (11, 13, 24, 22, 21, 32, 33, 44, 43, 46, 61, 62, 66) 

IA = (1, 3, 6, 8, 11, 11, 14) 

JA = (1, 3, 4, 2, 1, 2, 3, 4, 3, 6, 1, 2, 6) 

PROGRAMS FOR VARIOUS OPERATIONS PERFORMED ON MATRIX 

• FOR ADDITION:‐ 

#include 

#include 

void create_m(int [10][10],int,int); 

void display_m(int [10][10],int,int); 

void add_m(int [10][10],int [10][10],int,int); 

int i,j,k,a[10][10],b[10][10],c[10][10]; 

void main () 

{ 

int m,n,p,q,ch; 

clrscr(); 

while(1) 

{ 

printf("\nenter the nums of row and column of matrix A\n"); 

scanf("%d%d",&m,&n); 

create_m(a,m,n); 

Prepared By : 




printf("\nenter the nums of row and column B\n"); 

scanf("%d%d",&p,&q); 

create_m(b,p,q); 

printf("\nMATRIX A IS\n"); 

display_m(a,m,n); 

printf("\nMATRIX B IS\n"); 

display_m(b,p,q); 

if(m==p && n==q) 

{ 

add_m(a,b,m,n); 

printf("\nMATRIX AFTER ADDITION IS\n"); 

display_m(c,m,n); 

} 

else 

printf("ADDITION IS NOT POSSIBLE"); 

break; 

} 

} 

FOR SUBTRACTION:‐ 

#include 

#include 



voidsub_m(int[10][10],int 10][10],int,int); 

int i,j,k,a[10][10],b[10][10],c[10][10]; 

void main() 

{ 


clrscr(); 

while(1) 

{ 

Prepared By : 














if(m==p && n==q) 

{ 

sub_m(a,b,m,n); 

printf("\NMATRIX AFTER 

SUBTRACTION IS\n"); 

display_m(c,m,n); 

} 

else 

printf("SUBTRACTION IS NOT POSSIBLE"); 

break; 

} 

} 

FOR MULTIPLICATION:‐ 

#include 

#include 



void multi_m(int [10][10],int [10][10],int [10][10],int,int,int); 

int i,j,k,a[10][10],b[10][10],c[10][10]; 

void main() 

{ 


Prepared By : 




clrscr(); 

while(1) 

{ 











if(n==p) 

{ 

multi_m(c,a,b,m,n,q); 

printf("\nAFTER MULTIPLYING A & B MATRIX C IS \n"); 

display_m(c,m,q); 

} 

else 

printf("MULTIPICATION IS NOT POSSIBLE"); 

break; 

} 

} 

FOR TRANSPOSE:‐ 

#include 

#include 



void multi_m(int [10][10],int [10][10],int [10][10],int,int,int); 

Prepared By : 




int i,j,k,a[10][10],b[10][10],c[10][10]; 

void main() 

{ 


clrscr(); 

while(1) 

{ 




printf("\nMATRIX ENTERED IS\n"); 


for(i=0;i


QUEUES 

Queues, like stacks, also used in the computer solution of many problems. 

Perhaps the most common occurrence of a queue in computer applications is 

for the scheduling jobs in batch processing. 

When we talk of queues we talk about two distinct ends; the front and 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(deleted). 

First In First Out(FIFO) or First Come First Serve(FCFS) is the logical operation of the 

queue. 

Simple queue with the capacity n 

DEFINATION OF QUEUES 

QUEUES:‐ 

A queues is a logically “FIRST IN FIRST OUT”(FIFO) type of data 

structure.It is a linear list in which deletion are performed from the 

beinging i.e. front list and insertion are performed at the end is known 

as rear of the list. The information in such type of list can be processed 

Prepared By : 




on the basis of “FIRST COME FIRST SERVE”. A Queue is a logically first in 

first out type 

Type of data structure. It is a linear list in which deletions are perform 

from the beginning i.e known as front of the list & insertions are performed at 

the end i.e known as rear of the list. 

The information in such type of list can be processed on the basis of first term 

first serve 

EXAMPLE Queue at the railway reservation booth 

EXPLAINATION 

For getting the railway reservation new customers got into the queue 

from the rear end whereas the customers who get their seats 

reserved they leave from the queue from the front end. It means 

customers are service in the order in which they arrive. 

Thus, a queue is a non‐primitive linear data structure & can be 

defined as the collection of homogeneous elements in which new 

elements are added at one end called rear end & the existing 

elements are deleted from other end known as front end. 

IMPLEMENTATION OF QUEUES 

Queues can be implemented in to two different ways:‐ 

Static implementation. 

Dynamic implementation. 

1.Static implementation: If queue is implemented using array we must know 

about the adjacent no. of element we want to store in a queue .so at the 

beginning of the array we will be sure of the front pointer of the queue & the 

rear pointer for the queue.The following formula will give the fol. no. of 

elements in the queue 

FRONT=REAR+1 

OPERATIONS ON QUEUES 

Prepared By : 




There are two basic operations that can be performed on a queue. These are :‐ 

1.Insertion operation (put) 

2.Deletion operation(Get) 

Insertion operation (Put) Algorithm on a Queues:‐ 

Insertion operation 

procedure:‐Insert (Q,F,R,N,X) 

Q=name of queue 

F=front pointer variable 

R=rear pointer variable 

X=element to be inserted 

N=maximum size of queue 

PROCEDURE 

Step ‐1:‐ [over flow condition?] 

if R>=N,then write 

“OVER FLOW CONDITION” 

&return 

[end of if‐statement ] 

Step‐2:‐ [is queue empty?] 

if F=0,then F=1 

[end of if‐statement] 

Step 3:‐[increment rear pointer] 

R=R+1 

Step 4:‐[insert new element] 

Q(R) =X 

step 5:‐ finished 

return 

Deletion (Get) operation of Algorithm on Queues:‐ 

Procedure:‐Delete (Q,F,R,X) 

x=variable used to store deleted elements 

Step 1:‐[under flow condition?] 

if F=0,then write 

“UNDER FLOW CONDITION” 

Prepared By : 




[end of if ‐statement] 

Step 2:‐[is queue now empty] 

X=Q(F) 

Step 3:‐[is queue now empty?] 

if F=R ,then [queue has only 1 element] 

F=0, R=0 & return 

Step 4:‐[increment front pointer] 

F=F+1 

Step 5:‐finished 

return. 

IMPLEMENTATION OF QUEUES 

Queues can be implemented in two different ways 

1. Static implementation 

2. Dynamic implementation 

STATIC IMPLEMENTATION 

If queue is implemented using arrays we must know about the exact no. of 

elements we want to store in the queue . so at the beginning of array we will be 

sure of the front pointer for the queue & the rear pointer for the queue. The 

following formula will give the total no. of elements present in a queue when it 

is implemented in array data structured. 

Front=rear+one 

OPERATIONS 

INSERTION R=R+1 

DELETION F=F+1 

EXAMPLE OF INSERTION 

Prepared By : 




1 2 3 4 5 

A(f=1,r=1) 

A(f=1) B(r=2) 

A(f=1) B C(r=3) 

A(f=1) B C D(r=4) 

A(f=1) B C D E(r=5) 

Steps one by one(insertion) 

Step 1: in queue table there are five elements are filled one by one first is 

empty so F=0,R=0 

Step 2:insert A so, F=1,R=1 in special case 

Step 3: insert B so, F=1,R=2 

Step 4: insert C so, F=1,R=3 

Step 5: insert D so, F=1,R=4 

Step 6: insert E so, F=1,R=5 

Step 7: insert F so , it can’t be inserted 

DELETION TABLE 

Prepared By : 



queue 


1 

A(front) 

2 

B 

Prepared By : 



3 

C 

4 

D 

5 

E(rear) 

Delete A B(front) C D E(rear) 

INTRODUCTION TO CIRCULAR QUEUES : 

Delete B C(front) D E(rear) 

Delete C D(front) E(rear) 

Delete D E(rear)(front) 

Delete E(f=0,r=0) 

A circular queue is that queue in which the insertion of new element is done at the very 

first location of the queue. if the last location of queue is full , in other words if we have 

a queue denoted by Q which consist of n element then after inserting an element at last 

location of the array the next element will be inserted at very first location of the array. 

If a queue is full then no further elements can be inserted into it. So it is possible to 

insert new element iff some location in a queue are empty. 

A circular queue is a type of queue in which the first element comes just after the last 

element. it can be represented by loop of wire , in which the two ends of the wire are 

connected together.


Suppose an array x of n element is used to implement a circular queue. If we go on 

adding elements to the queue we may reach x[n‐1].we cannot add any more elements 

to the queue since the end of the array has been reached. Instead of reporting the 

queue is full , if some elements in the queue have been deleted then there might be 

empty slots at the beginning of the queue. In such case these slots would be filled by 

new elements added to queue. In short, just because we have reached the end of the 

array , the queue would not be reported as full. The queue would be reported full only 

when all the slots in the array are occupied. 

ALGORITHM FOR INSERTION OPERATION:‐ 

PROCEDURE: 

(Circular queue)insert(Q,F,R,N,X) 

STEP 1: [is queue empty?] 

if F=1 & R+N then 

write overflow and return 



if F=0 then 

F=1 


STEP 3: [Reset rear pointer] 

if R=N then 

R=1 

else 

R=R+1 


STEP 4: [insert new element] 

Q[R]=X 

STEP 5: [finished] 

Prepared By : 




return 

ALGORITHM FOR DELETION OPERATION:‐ 

PROCEDURE: 

delete(Q,F,R,X) 


if F=0 then 

write underflow and return 


STEP 2: [delete front element] 

X=Q[F] 

STEP 3: [is queue now empty?] 

if F=R then 

F=0,R=0 & return 


STEP 4: [increment front pointer] 

if F=N then 

F=1 

else 

F=F+1 


STEP 5: [finished] 

return 

Prepared By : 




Implementation 2: 

Wrapped Configuration 

EMPTY QUEUE 

[2] [3] [2] [3] 

[1] [4] [1] J1 

[4] 

[0] [5] [0] [5] 

front = 0 front = 0 

rear = 0 rear = 3 

Can be seen as a circular queue 

Leave one empty space when queue is full 

Why? 

FULL QUEUE FULL QUEUE 

[2] [3] [2] [3] 

J2 J3 

J8 J9 

[1] J1 J4 [4][1] J7 

[4] 

J5 

J6 J5 

[0] [5] [0] [5] 

front =0 

rear = 5 

How to test when queue is empty? 

How to test when queue is full? 

J2 

J3 

front =4 

rear =3 

Prepared By : 




LINKED LIST BASED QUEUE IMPLEMENTATION 

A queue represented using a linked list is also known as a linked queue. The array 

based representation of queue suffer from following limitations. 

• Size of the queue must be known in advance 

• We may come across situation when an attempt to enqueue an element 

causes over flow. However, queue as an abstract data structure cannot be 

full. Hence , abstractly it is always possible to enqueue an element in queue. 

Therefore, implementing queue as an array prohibits the growth of queue 

beyond finite number of elements. 

The link list representation allows a queue to grow to a limit of the 

computers memory . 

The following are the necessary declarations 

Typedef struct nodetype 

{ 

Int info ; 

Struct node type *next; 

} 

Node; 

Typedef struct { 

Node * front ; 

Node * rear; 

} 

Queue; 

Queue q; 

Here we have defined two data type name node and queue. The node type , 

a self referential structure , whose first element info hold the element of the 

queue and the second element next holds the address of the element after it 

in the queue .the second type in queue, a structure , whose first element 

front holds the address of the first element of the queue, and the second 

element rear holds the address of the last element of the queue. The last 

line declares a variable q of type queue. 

Prepared By : 




With these declarations , we will write functions for various operations to be 

performed on a queue represented using linked list. 

FRONT REAR 

5 7 12 8 9 x 

(a) Representation of queue in memory 

FRONT REAR 

(b) Representation of queue in memory 

12 8 9 x 

FRONT REAR 

12 8 9 3 10 11 x 

(c) Representation of queue in memory 

Prepared By : 




DEFINATION OF PRIORITY QUEUES:- 

A priority queues is a collection of element such that each element has been assigned a priority 

and such that order in which element are deleted and processed from the following rules: 

(a) An element of higher priority is processed before any element of lower 

priority 

(b) Two element with the same priority are processed according to 

standard queues 

Page-5 

Example of priority queue is time sharing system, where programs of higher priority are 

processed first. 

There can be different criteria of determining the priority. Some of them are summarized 

below: 

1. A shortest job is given higher priority over the longer one. 

2. An important job is given the higher priority over a routine type job. For example, a 

transaction for on line booking of an order is given preference over payroll 

processing. 

3. In a commercial computer center, the amount you pay for job can determine priority 

for your job. Pay more to get higher priority for your job. 

Prepared By : 




IMPLEMENTATATION OF PRIORITY QUEUES:‐ 

There are various way to implement a priority queues. These are: 

1. Using multiple queues, one for each priority. 

2. Using a linear linked list. 

3. Using a heap 

1. MULTIPLE QUEUES REPRESENTATION: 

In this representation, one of the queues is maintained for each priority 

number. In order to process an element of the priority queues, element from 

the first non‐empty highest priority number queues is accessed. In order to add 

a new element to the priority queues, the element is inserted in an appropriate 

queue for given priority number. 

Consider the priority queues as shown in figure. 

O1 O2 ……. Oi P1 P2 …….. pi 

1 1 ……. 1 2 2 …….. 2 

1=priority 

01=job identifier 

The priority queues of fig. can be visualized as three separated queues as shown 

in fig.1 

Priority1 

O1 O2 ……………….. oi 

Priority2 

P1 P2 …………….. pi 

In the figure1, jobs are always removed from the front of the queues. 

Now, whenever element are inserted, they are inserted in the end of one of the 

queues determined by their priority. 

2. LINKED LIST REPRESENTATION:‐ 

To maintain the linked list in memory, we need two linear arrays denoted by 

INFO and LINK. Since the subscripts of the array INFO and LINK will be positive, 

therefore, we can choose NULL=0 

EXAMPLE:‐. 

Prepared By : 




Figure shows two linked list in memory where each node of the both list are 

stored in the same linear array INFO and LINK. 

INFO LINK 

The information part of a node may be recorded with more than one data item. 

In such a case, the data should be stored in a collection of parallel arrays. 

3. HEAP REPRESENTATION OF A PRIORITY QUEUES: 

A heap is a complete binary tree and with the additional property‐ the root 

element is either smallest or largest from its children if root element of the heap 

is smallest from its children. It is known as min heap. If the root element of the 

heap is largest from its children, it is known as max heap. 

A priority queues can be resented using min or max heap. 

A priority queues having highest priority for lower number can be represented 

using min heap, and a priority queues having highest priority for higher number 

can be represented using max heap.Hence, the element of the priority queues 

to be processed next in the root node of the heap.If we compare the effort in 

Prepared By : 




adding or removing element from the priority queue, we find that heap 

representation is the best. 

APPLICATION OF PRIORITY QUEUES:‐ 

Priority queues are used in following areas: 

Operating Systems 

Priority queue is used for job scheduling and interrupt handling in 

operating system. 

Graph Search 

It is used for shortest path in graph searching. 

Event‐driven simulation 

It is used for customers in a line. For example, lines at ticket counter 

at railway station, bus stand, etc., are queues, because the service, 

i.e., ticket, is provided on first‐come in first‐served basis. 

Aritifical intelligence 

It is used for A* searching. 

Data Compression 

It is used for Huffman codes. 

Numerical Computation 

It is used for reducing round off error. 

Computational number theory 

It is use to find the sum of power 

Prepared By : 



SEARCHING 


SEARCHING TECHNIQUES 

Searching is the process of finding out whether a given number or string is 

present in an array of data. The search is said to b successful if the given 

element is found then the element does exist in the array otherwise 

unsuccessful. There are two types of searching techniques 

LINEAR SEARCH 

BINARY SEARCH 

LINEAR SEARCH 

Linear search is a searching process in which each element of an array is 

searched one by one sequentially in order to get or find the location of desired 

elements. A search wills b unsuccessful if all the elements are accessed and the 

desired element not found. In worst case, the no. of average case comparisons 

that we have to scan is half of the size of the array i.e. N/2. 

ALGORITHM FOR LINEAR SEARCH: 

PROCEDURE: Linear search(A,N,X) 

A= name of array 

N=total no. of elements in array 

x=element to be inserted 

STEP 1: (search the array) 

Repeat fo I=1 to N 

if A[i]=X then 

return (1) and exit 


[end of for loop] 

Prepared By : 




step 2: [element not found] 

return (0) 

exit 

EXAMPLE OF LINEAR SEARCH 

Consider an array ‘A’ (15, 11, 14, 13, 18, and 21) 

Here X=13 to be searched 

BINARY SEARCH 

Is x=A [1] = False 



Is x=A [4] = True 

Element x=13 found at position 

The Binary Search algorithm is a method of searching an ordered array for a 

single element by cutting the array in half with each pass. The trick is to pick a 

midpoint near the center of the array, compare the data at that point with the 

data being searched and then responding to one of three possible conditions: 

the data is found, the data at the midpoint is greater than the data being 

searched for, or the data at the midpoint is less than the data being searched 

for. 

Prepared By : 




This searching technique searches the given item in minimum possible no. of 

comparisons. To do the binary search first we have to sort the given array 

elements. 

IMPEMENTATION OF BINARY SEARCH 

Binary search operation is divided into 3 cases 

Case1: if a [item] a [mid] 

Then, big=mid+1 

ALGORITHIM 

The algorithm for binary search is given below‐ 

Algo: Binary search(A,N,X) 

A=name of array 

N=number of element 

X=element to be searched in array A 

If the search is successful this algorithm finds the location or position of x in 

the array otherwise the value 0 is return. 

1. [Initialize variables] 

First=1, last=N 

Prepared By : 




Middle=Int [(first+last)/2] 

2. Repeat step 3&4 while 

First


EXAMPLE OF BINARY SEARCH 

Consider an array a consisting of items‐10, 20, 30, 40,50,60,70 

10 20 30 40 50 60 70 

Let in this sorted array we have to search item ’70’ 

Mid= (beg +end)/2= (1+7)/2= 4 

Now,70>A [4] So, beg= 4+1 =5 

And 

End=7 

Mid= (5+7)/2 = 6 

Again 

70>A [6] 

Therefore, Beg=7,End=7 

Now, 

A[item] = A[mid] 

i.e. 70=70 

Hence we get the output, 70 is searched at location =A [7] 

EXAMPLE: 

To implement binary search we are provided with a sorted array A which consist 

of following elements. 

Sorted array A=3, 7, 11, 17, 19, 21, 27 

Element to be searched is 7 

X=7 

Middle=1+7/2=4 

Prepared By : 




1 2 3 4 5 6 7 

3 7 11 17 19 21 27 

first middle last 

TABLE: 

STEP NO. FIRST LAST MIDDLE CHECK REMINDER 

1 1 7 4 A(4)>7 Number is left 

half 

2 1 3 2 A(2)=7 No found 

Prepared By : 




DEFINATION OF STACKS 

STACKS 

A Stack is a non‐primitive linear data structure. It is an ordered list in which 

addition of new data items and deleting of already existing data items is done 

from only one end which is known as “TOP OF STACK” (top) as all the deletion 

and insertion operation is done from the top of stack. The last element will be 

first to be removed from the stack. That’s why stack is known as “LAST IN FIRST 

OUT” (LIFO) data structure. 

Prepared By : 




Representation of stacks 

Examples: 

• Pile of tray in cadet area. 

• Shunting for railway boogies system. 

IMPEMENTATION OF STACKS 

Stacks can be implemented in two ways: 

• Static implementation 

• Dynamic implementation 

• 

STATIC IMPLEMENTATION: 

This kind of implementation uses arrays to create stack . The array 

implementation o stack is not the flexible technique because the size of the 

array is fixed . If there is few elements to be stored in the stack then the 

statically allocated memory will be wasted and if there are more no. of 

elements to be stored in the stack then we can’t be able to change the size of 

array to increase its capacity. 

DYANAMIC IMPLEMENTATION: 

In this kind of implementation array is represented in the form of linked list by 

using pointers to implement the stacks type of data structure. 

Example : 

• Int a[7] 

we have to insert four elements 10,20,30,40 in the array. 

Prepared By : 




a[5],a[6],a[7] position of the array is empty and it is wasted. 

• Int a[7] 

max. size of array=7 

we cannot insert more elements because stack is full. 

STATIC IMPLEMENTATION 

OPERATIONS ON STACK 

The two basic operation that can be performed on stack are: 

• Push operation 

• Pop operation 

Prepared By : 




PUSH OPERATION: 

The process of adding a new element to the top of stack is known as PUSH 

OPERATION. 

Pushing an element in the is done at the top pointer and it is incremented by 

one. If array is full and no new element can be accommodated this condition is 

known as STACK FULL CONDITION. It is also called as 

STACK OVERFLOW. 

POP OPERATION: 

The process of deleting an element from top of stack is known as POP 

OPERATION. Each time after pop operation the stack pointer i.e. top is 

decremented by one. 

If there is no element on the stack then the pop operation can’t be 

performed. This condition is known as STACK EMPTY CONDITION which is also 

called as STACK UNDER FLOW CONDITION. 

Prepared By : 




ALGORITHM ON PUSH OPERATON 

PUSH OPERATION: 

procedure: push (S,TOP,N,X) 

S= stack 

Top= Top pointer 

N= maximum size of stack 

X= element to be inserted 

Step 1: [overflow ?] 

If TOP = N then write “OVERFLOW” 

return [end of If statement] 

Step 2: [Incremented top] 

TOP=TOP+1 

Step 3: [Insert new element] 

S(TOP)=X 

Step 4: [finished] 

Return 

Prepared By : 




ALGORITHM ON POP OPERATION 

POP OPERATION: 

procedure: pop (S,TOP,X) 

S= stack 

TOP= Top pointer 

Step 1: [underflow ?] 

X= element used to stored deleted elements. 

If TOP= 0 then write “underflow” 

Return [end of if statement] 

Step 2: [delete elements] 

X= S(TOP) 

Step 3: [decremented pointer] 

TOP=TOP‐1 

Step 4: [finished] 

Return 

Prepared By : 




EXAMPLE OF STACK 

This is used to show the position of element in the stack 

This is an example of Stack using Arrays. 

Example I: 

• Push(5) 

In the stack 

Array position=1 

Element=5 

Pointer=TOP 

• push(6) 

In stack 

Array position=2 

Pointer=TOP 

Element= 6 

Prepared By : 




EXAMPLE OF PUSH OPERATION 

Example II: 

Step 1: 

Prepared By : 



Step 2: 

Step 3 


Step 4: finished 

Prepared By : 




EXAMPLE OF POP OPERATION 

STEP 1: 

STEP 2: 

Step 3: 

STEP 4: FINISHED 

Prepared By : 




INTRODUCTION OF Infix, Postfix and Prefix 

Infix, Postfix and Prefix notations are three different but equivalent ways of 

writing expressions. It is easiest to demonstrate the differences by looking at 

examples of operators that take two operands. 

Infix notation: X + Y 

Operators are written in‐between their operands. This is the usual way 

we write expressions. An expression such as A * ( B + C ) / D is 

usually taken to mean something like: "First add B and C together, then 

multiply the result by A, then divide by D to give the final answer." 

Infix notation needs extra information to make the order of evaluation of 

the operators clear: rules built into the language about operator 

precedence and associativity, and brackets ( ) to allow users to override 

these rules. For example, the usual rules for associativity say that we 

perform operations from left to right, so the multiplication by A is 

assumed to come before the division by D. Similarly, the usual rules for 

precedence say that we perform multiplication and division before we 

perform addition and subtraction. 

Postfix notation (also known as "Reverse Polish notation"): X Y + 

Operators are written after their operands. The infix expression given 

above is equivalent to A B C + * D / 

The order of evaluation of operators is always left‐to‐right, and brackets 

cannot be used to change this order. Because the "+" is to the left of the 

"*" in the example above, the addition must be performed before the 

multiplication. 

Operators act on values immediately to the left of them. For example, the 

"+" above uses the "B" and "C". We can add (totally unnecessary) 

Prepared By : 




brackets to make this explicit: 

( (A (B C +) *) D /) 

Thus, the "*" uses the two values immediately preceding: "A", and the 

result of the addition. Similarly, the "/" uses the result of the 

multiplication and the "D". 

Infix Postfix Prefix Notes 

Prefix notation (also known as "Polish notation"): + X Y 

Operators are written before their operands. The expressions given above 

are equivalent to / * A + B C D 

As for Postfix, operators are evaluated left‐to‐right and brackets are 

superfluous. Operators act on the two nearest values on the right. I have 

again added (totally unnecessary) brackets to make this clear: 

(/ (* A (+ B C) ) D) 

Although Prefix "operators are evaluated left‐to‐right", they use values to 

their right, and if these values themselves involve computations then this 

changes the order that the operators have to be evaluated in. In the 

example above, although the division is the first operator on the left, it 

acts on the result of the multiplication, and so the multiplication has to 

happen before the division (and similarly the addition has to happe 

Prepared By : 




A * B + C / D A B * C D / + + * A B / C D 

A * (B + C) / D A B C + * D / / * A + B C D 

A * (B + C / D) A B C D / + * * A + B / C D 

Reverse Polish notation or postfix notation : 

multiply 

A and B, 

divide C 

by D, 

add the 

results 

add B 

and C, 

multiply 

by A, 

divide 

by D 

divide C 

by D, 

add B, 

multiply 

by A 

A unary operator for which the Reverse Polish notation is the general 

convention is the factorial. In Reverse Polish notation the operators follow their 

operands; for instance, to add three and four, one would write "3 4 +" rather 

than "3 + 4". If there are multiple operations, the operator is given immediately 

after its second operand; so the expression written "3 − 4 + 5" in conventional 

infix notation would be written "3 4 − 5 +" in RPN: first subtract 4 from 3, then 

add 5 to that. An advantage of RPN is that it obviates the need for parentheses 

that are required by infix. While "3 − 4 * 5" can also be written "3 − (4 * 5)", that 

means something quite different from "(3 − 4) * 5". In postfix, the former would 

Prepared By : 




be written "3 4 5 * −", which unambiguously means "3 (4 5 *) −" which of course 

reduces to "3 20 ‐". 

Interpreters of Reverse Polish notation are often stack‐based; that is, operands 

are pushed onto a stack, and when an operation is performed, its operands are 

popped from a stack and its result pushed back on. Stacks, and therefore RPN, 

have the advantage of being easy to implement and very fast. 

Algorithm : 

This algoritm finds the value of an arithmetic expression P written in postfix 

notation. 

1.Add a right parenthesis”)” at the end of P. 

[This act as sentinel.] 

2.Scan P from left to right and repeat step 

3and 4for each element of P until the sentinel”)” is encountered. 

3.If an operand is encountered then: 

a)Remove the two TOP elements of STACK where A is the top element and B is 

the next‐to‐top element. 

b)Evaluate B*A. 

c)Place the result of(b) back on STACK 

[End of if structure.] 

[End os step 2 loop.] 

5.SET VALUE equal to the element on SATCK 

6.EXIT 

Prepared By : 




Example:consider the following arithmetic expression P written in postfix 

notation. 

P:5 ,6 , 2 , + ,* ,12 ,4 ,/ ,‐ 

We evaluate P by stimulating the above defined 

algorithm .First we add a sentinel right parenthesis at 

the end of P to obtain 

P: 5, 6, 2, +, *, 12, 4, /, ‐, ) 

(1) (2) (3) (4) (5) (6) (7) (8) (9) (10) 

The elements of P have been labeled from left to right for easy reference.Fig 

below shows the contents of STACK as each element of P is scanned.The final 

number in STACK,37,which is assigned to VALUE when the sentinel “)” is 

scanned,is the value of P. 

SYMBOL SCANNED STACK 

(1) 5 5 

(2) 5,6 5,6 

(3) 2 5,6,2 

(4) + 5,8 

(5) * 40 

(6) 12 40,12 

(7) 4 40,12,4 

(8) / 40,3 

(9) ‐ 37 

(10) ) 

Conversion of infix expression to post‐fix expression:‐ 

E= input infix expression 

P= output postfix expression 

ALGORITHM 

Prepared By : 




STEP 1: Push left parenthesis on to stack‐ "(" and add right parenthesis ‐")" to 

the end of expression E until the stack is empty. 

STEP 2: If element = operand then 

add elements to expression P 

end of if statement. 

STEP 3: If element = left parenthesis then 

push element on stack. 


STEP 4: If element = operator then 

1. repeatedly pop from stack and add to expression P.Each operator which 

have the same or higher precedence. 

2. Push the element on stack. 


STEP 5: If element = right parenthesis then 

1. Repeatedly pop from stack and add to expression P, each element until 

a left parenthesis is encountered. 

2. Remove left parenthesis and do not add this to the resultant expression 

P. 


end of step 2nd loop. 

STEP 6: Exit. 

Prepared By : 




Infix to Prefix Conversion 

The input for this conversion is infix expression E and output of this is equal to 

expression P.This can be done by the use of stacks. 

ALGORITHEM FOR CONVERSION: 

1. Reverse the input string. 

2.Examine the next element in the input . 

3.If it is operand ,add it to the output string. 

4.If it closing paranthesis,push it on stacks. 

5.If it is an opertor ,then 

(a) If stackes is empty ,push‐operation on stackes. 

(b) If the top of stacks is closing paranthesis pus operation on stackes. 

(c) If it has same or higer priority then the top of stackes ,pus operator on 

stacks. 

(d) Else pop the operator from the stacks and add it to output string ,repeate 

S. 

6. If it opening paranthesis,pop operator from stackes and add them to S until a 

closing 

Paranthesis is encounter .pop and discard the closing paranthsis . 

7.If there is more input go to step 2. 

8.If there is no more input ,unstacks the remaining operators and add them. 

9.Reverse the output string . 

Prepared By : 




TREES 

Binary tree: A binary tree consists of a finite set of elements that can be 

partitioned into three distinct sub‐ sets called the root, the left and the right 

sub‐tree.If there are no elements in the binary tree ,it is known as empty binary 

tree.A binary tree ‘T’ is either empty or has a finite collections of 

elements.When the binary tree is not empty,one of its elements is called the 

root and the remaining elements,if any,are partitioned into two binary 

trees,which are known as left & right sub tree of T. 

The essential difference between a binary tree and a tree are 

A binary tree can be empty whereas a tree cannot.Each element in binary tree 

has at most two sub‐trees(one or both of these sub‐tree may be empty).Each 

element in a tree can have any number of sub‐trees. 

The sub‐trees of each element in a binary tree are ordered.That is,we 

distinguish between the left and right sub tree.The sub tree in a tree are 

unordered. 

Here are some of the binary trees that represents arithmetic expressions.Each 

operator(+, ‐, *, /) may have one or two operands.The left operand ,if any,is the 

left sub‐tree of the operator & the right operand is the right 

sub tree.The leaf elements in an expression tree are either constants or 

variables. 

Prepared By : 



a 


(a /c) + (b *d) ( (a *b) *c) *d) 

/ 

+ 

c b d 

a. b. 

* * 

Prepared By : 



a 

* 

b 

* 

c 

d


Some of the properties of binary tree : 

A binary tree with ‘n’ elements n>0,Has exactlyn‐1 edges. 

A binary tree of height ‘h’,h>0,has atleast h and atmost 2*..2 ‐1 

elements in it. 

The height of the binary tree that contains n elements ,n>0,is atmost n & 

atleast [log8..2(n+1)]. 

Let i,1n, then this element has no left child. Otherwise,its left child has been 

assigned the number 2i. 

If 2i+1>n, then this element has no right child.Otherwise,its right child has been 

assigned the number 2i+1. 

The number of nodes n in a perfect binary tree can be found using this formula: 

n = 2 h + 1 − 1 where ‘h’ is the height of the tree. 

The number of nodes n in a complete binary tree is minimum: n = 2 h and 

maximum: n = 2 h + 1 − 1 where h is the height of the tree. 

The number of nodes n in a perfect binary tree can also be found using this 

formula: n = 2L − 1 where L is the number of leaf nodes in the tree. 

The number of leaf nodes n in a perfect binary tree can be found using this 

formula: n = 2 h where h is the height of the tree. 

he number of NULL links in a Complete Binary Tree of n‐node is (n+1). 

The number of leaf node in a Complete Binary Tree of n‐node is UpperBound(n / 

2). 

Prepared By : 




For any non‐empty binary tree with n0 leaf nodes and n2 nodes of degree 2, n0 = 

n2 + 1. 

Definitions for rooted trees: 

A binary tree is a connected acyclic graph such that the degree of each vertex is 

not more than three. It can be shown that in any binary tree, there are exactly 

two or more nodes of degree one than there are of degree three, but there can 

be any number of nodes of degree two. A rooted binary tree is such a graph that 

has one of its vertices of degree not more than two singled out as the root. 

1) A directed edge refers to the link from the parent to the child (the 

arrows in the picture of the tree). 

2) The root node of a tree is the node with no parents. The is at the most 

one root node in a rooted tree. 

3) A leaf node has no children. 

4) The depth of a node n is the length of the path from the root to the 

node. The set of all nodes at a given depth is sometimes called a level 

of the tree. The root node is at depth zero. 

5) The height of a tree is the length of the path from the root to the 

deepest node in the tree. A (rooted) tree with only a node (the root) 

has a height of zero. 

6) Siblings are nodes that share the same parent node. 

7) In‐degree of a node is the number of edges arriving at that node. 

8) Out‐degree of a node is the number of edges leaving that node. 

Complete binary tree 

A tree consist of a finite set of elements called nodes and a finite set of directed 

lines called branches that connect the nodes. 

Prepared By : 




The number of branches associated with a node is the degree of the node. 

When the branch is directed toward the node, it is an indegree branch; when 

the branch is directed away from the node, it is an outdegree branch. 

If the tree is not empty, the first node is called the root, which has the indegree 

of zero. A leaf is a node with an outdegree of zero. 

An internal node is a node which is neither the root nor a leaf. A node can be a 

parent, a child or both. Two or more nodes with the same parent are called 

siblings. 

A path is a sequence of nodes in which each node is adjacent to the next one. 

An ancestor is any node in the path from the root of a given node. A 

descendent is any node in all of the paths from a given node to a leaf. 

The level of a node is its distance from the root. The height of the tree is the 

level of the leaf in the longest path from the root plus one. 

A subtree is any connected structure below the root. A tree is a set of nodes 

that is: 

a. either empty 

b. or has a designated node called the root from which hierarchically 

descend zero or more subtrees which are also trees. 

BINARY TREES 

A binary trees is a tree in which no node can have more than two subtrees. In 

other words, a node can have zero, one or two subtrees. These subtrees are 

designated as the left subtree and right subtree. 

Prepared By : 




The minimum and maximum height of a binary tree can be related to the 

number of nodes. Hmin = [log2 N] + 1 

H max = N 

Given the height of a binary tree, the minimum and maximum number of nodes 

in the tree can be calculated as Nmin = H; Nmax = 2 H ‐ 1 

A null tree is a tree with no nodes. The nodes at level 2 of a tree can all be 

accessed by following only two branches from the root. It stands to reason , 

that the shorter we can make the tree, the easier it is to locate the desired node 

in the tree. 

This leads us to a very important characteristic of a binary tree, its balance. To 

determine if a tree is balanced, we calculate its balance factor. The balance 

factor of a binary tree is the difference in height between its left and right 

subtrees. 

B= Hleft – Hright 

A tree is balanced if its balance factor is zero and its subtrees are also balanced. 

A binary tree is balanced if the height of its subtrees differs by no more than 

one (its balanced factor is –1,0, or +1) and its subtrees are also balanced. 

A binary tree traversal requires that each node of the tree be processed once 

and only once in a predetermined sequence. There are two general approaches 

to the depth first and breadth first. 

The depth first traversal, the processing proceeds along a path from the root 

through one child to the most distant descendent of that first child before 

processing a second child. All of the descendents of a child are processed 

before the next child. 

Prepared By : 




The breadth first traversal, the processing proceeds horizontally from the root 

to all its children, then to its children’s children and so forth until all nodes have 

been processed. 

In the preorder traversal, the root node, is processed first, followed by the left 

subtree, and then the right subtree. 

In the inorder traversal processes the left subtree first, then the root, and finally 

the right subtree. 

In the postorder traversal it processes the root node after (post) the left and 

right subtrees have been processed 

A. Full binary tree of height 3 

B. Complete binary tree 

1 1 

B. 

2 3 

2 3 

4 5 6 

Basic terminology: 

A. B. 

A A 

B B 

C 

Prepared By : 


Assist Prof., CSE, H.C.T.M (Kaithal) C 

Page ‐ 182 ‐ 

4

D 


G 

FATHER and SON: 

E 

Suppose A is the root node of a binary tree and B is the root of its left or right 

sub‐tree.in this case ‘A’ is said to be the father of B and B is said to be the LEFT 

or RIGHT SON of A. 

LEAF NODE:A node that does not have any sons(such as D,G,H,I) is called a leaf 

node. 

ANCESTOR AND DESCENDANT: A node ‘A’ is said to be an ancestor of node 

‘B’.If ‘A’ is either the father of ‘B’or the father of some ancestor of ‘B’.for eg;’A’ 

is an ancestor of ‘C’.A node ‘B’is said to be a left descendant of node’A’ if ‘B’is 

either the left son of ‘A’ or a descendant of the left son of A. 

CLIMBING and DESCENDING: 

When we are traversing the tree from the leaf node to the root node the 

operationis climbing.Similarly traversing the tree from the root to the leaves is 

called descending the tree. 

STRICTLY BINARY TREE: A binary tree is called a strictly binary tree if every non‐ 

leaf node in a binary tree has non‐empty left and right sub‐trees. For eg; the 

tree shown in fig. c. is a strictly binary tree,whereas ,the tree shown in D.is not a 

strictly binary tree since nodes C & E in it have one son each. 

B 

F 

A 

Prepared By : 



D 

C

c. 


Strictly binary tree 

DEGREE: The number of nodes connected to a particular node is called degree of 

that node .for eg;the node conataining data ‘D’ has a degree 3.The degree of a 

leaf node is always one 

LEVEL: The root node of the tree has level 0.The level of any other child node is 

one more than the level of its father.for eg;, in the binary tree as in fig; node ‘E’ 

is at level 2 and node ‘H’ is at level 3. 

DEPTH: The maximum level of any leaf node in the tree is called depth of the 

binary tree.for eg; the depth of the tree shown in fig; below 

Binary tree 

A 

Prepared By : 


Assist Prof., CSE, H.C.T.M B (Kaithal) C 

Page ‐ 184 ‐ 

E


COMPLETE BINARY TREE: 

A strictly binary tree all of whole leaf nodes are at the same level is called a 

complete binary tree.The depth of this tree is 2. 

A 

Prepared By : 



D 

B 

E 

E F G


D. Complete binary tree 

REPRESENTATION OF BINARY TREE IN MEMORY: tnode 

Left 

E. Node of a binary tree 

data right 

The structure of each node of a binary tree contains the data field,a pointer to 

the left child and a ponter to the right child.as shown in fig; above. 

This structure can be defined as 

Struct tnode 

{ 

Struct tnode*left; 

Int data; 

Prepared By : 



1 

3 


Struct tnode*right; 

}; 

TWO OF REPRESENTING BINARY TREE ARE 

Linked representation of binary tree 

Array representation of binary tree 

Insertion in binary tree: 

A binary tree is constructed by the repeated insertion of new nodes into a 

binary tree structure. Insertion must maintain the order of the tree. That is, 

values to the left of a given node must be less than that node, and values to the 

right must be greater. Inserting into a non‐empty tree.: 

before insertion 5 after insertion 5 

4 

7 

Deletion in binary tree: 

8 

6 3 

1 

Prepared By : 



4 

5 

7 

6 

8


The algorithm to delete an arbitrary node from a binary tree is deceptively 

complex, as there are many special cases. The algorithm used for the delete 

function splits it into two separate operations, searching and deletion. Once the 

node which is to be deleted has been determined by the searching algorithm, it 

can be deleted from the tree. The algorithm must ensure that when the node is 

deleted from the tree, the ordering of the binary tree is kept intact. 

1) The node to be deleted has no children. 

In this case the node may simply be deleted from the tree. 

before deletion of 2 after deletion of 2 

 

node to be deleted 

A tree may be defined as a finite set ‘T’ of one or more nodes such that there 

is a node designated as the root of the tree and the other nodes (excluding the 

root) are divided into n≥0 disjoint sets T1,T2,………….,Tn and each of these sets is 

a tree in turn.The trees T1,T2,…………..,Tn are called the sub‐trees or children of 

the root. Generally, it is a convention to draw root node at the top and let the 

tree grow downwards. 

FIGURE:‐ 

2 

4 4 

7 7 

suresh 

sunita nikita 

Prepared By : 




pooja mala 

DEFINITION OF BINARY TREE:‐ 

Binary tree is a special type of tree in which every node or vertex has either no 

children, one child or two children. A binary tree is an important class of tree 

data structure in which a node can have atmost two children (which are sub‐ 

trees). Child of a node in a binary tree on the left is called the “left child” and 

the node in the right is called the “right child”. 

Similarly, a binary tree may also be defined as follows:‐ 

A binary tree is an empty tree. 

A binary tree consists of a node called root, a left sub tree and a right sub 

tree both of which are binary trees once again. 

ARRAY IMPLEMENTATION:‐ 

raj 

tina sita 

In an array binary tree, the nodes of the tree are stored in an array. 

Position 0 is left empty. 

The root is stored in position 1. 

For the element in position n, 

the left child is in position 2n 

the right child is in position 2n+1 

the parent is in position n/2. 

Prepared By : 




EXAMPLE:‐ 

1. 

Unused 

2. root 

3. 

10 20 30 40 50 60 70 

10 20 30 40 50 60 70 

10 20 30 40 50 60 70 

Parent 

Parents,do you know where your children are? 

4. 

5. 

10 20 30 

Parent 

40 50 60 70 

Yes, they are at 2n and 2n+1 

10 20 30 40 50 60 70 

Prepared By : 




ADVANTAGES:‐ 

This representation is very efficient when 

i. The tree is complete 

ii. The structure of the tree will notbe modified 

ALGORITHM:‐ 

Binary tree : an array implementation 

STEP 1:‐root is A[1] 

STEP 2:‐for element A[i] 

Left child is in position A[2i] 

Right child is in position A[2i+1] 

STEP 3:‐parent is in A[i/2] 

LINKED BINARY TREE IMPLEMENTATION:‐ 

Children 

A non‐empty binary tree consists of a root and two children which are 

binary trees once again. Since the definition of this data structure is 

recursive,an appropriate rep. could be self‐referential structure. Each node 

of a tree is represented by a structure.each node contains two links to the 

same structure:‐left and right. If tree is NULL then the tree is empty 

Prepared By : 




otherwise tree points to the root node of the tree, left link points to the left 

sub‐tree of the tree and right link points to the right subtree of the tree. The 

structure used to rep. binary tree in a linked list is:‐ 

Struct Node 

{ in data; 

Struct node*left; 

Struct node*right; 

} node 1; 

SOME IMPORTANT POINTS:‐ 

EXAMPLE:‐ 

D 

As we have seen the linked implementation uses binary tree nodes. 

Each binary tree node has two node pointers,one to the left subtree 

and one to the right subtree. 

The binary tree itself consists of a single node pointer to the root 

node. 

G H 

Linked representation 

B C 

E 

A 

Prepared By : 



F 

I


In linked representation,each element is represented by a node that has exactly 

two link fields. Let us call these fields left and right. In addition to these two link 

fields, each node has a data field called info. 

Diagramatic Representation of Binary tree:‐ 

A simple binary tree of size 9 and height 3, 

with a root node whose value is 2. 

Prepared By : 



Traversal 


The above tree is neither a sorted nor a balanced binary tree 

Compared to linear data structures like linked lists and one dimensional 

arrays, which have only one logical means of traversal, tree structures can be 

traversed in many different ways. Starting at the root of a binary tree, there are 

three main steps that can be performed and the order in which they are 

performed defines the traversal type. These steps (in no particular order) are: 

performing an action on the current node (referred to as "visiting" the node), 

traversing to the left child node, and traversing to the right child node. Thus the 

process is most easily described through recursion. 

Traversing Operations:‐ 

1. Pre‐Order Traversal 

2. In‐Order Traversal 

3. Post‐Order Traversal 

Pre‐Order Traversal: To traverse a non‐empty binary tree in preorder, perform 

the following operations recursively at each node, starting with the root node: 

1. Visit the node. 

2. Traverse the left subtree. 

3. Traverse the right subtree. 

(This is also called Depth‐first traversal.) 

In‐Order Traversal: To traverse a non‐empty binary tree in inorder, perform the 

following operations recursively at each node: 

1. Traverse the left subtree. 

2. Visit the node. 


(This is also called Symmetric traversal.) 

Prepared By : 




Post‐Order Traversal: To traverse a non‐empty binary tree in postorder, perform 

the following operations recursively at each node: 

1. Traverse the left subtree. 


3. Visit the node. 

Finally, trees can also be traversed in level‐order, where we visit every node on 

a level before going to a lower level. This is also called Breadth‐first traversal 

Example: 

Example: 

Output of Pre‐Order Traversal: 

F, B, A, D, C, E, G, I, H (root, left, right) 

Prepared By : 



Example: 

Uses 


Inorder traversal 

Output of In‐Order Traversal: 

A, B, C, D, E, F, G, H, I (left, root, right) 

Output of Post‐Order Traversal: 

A, C, E, D, B, H, I, G, F (left, right, root) 

It is particularly common to use an inorder traversal on a binary search tree 

because this will return values from the underlying set in order, according to the 

Prepared By : 




comparator that set up the binary search tree (hence the name).To see why this 

is the case, note that if n is a node in a binary search tree, then everything in n 's 

left subtree is less than n, and everything in n 's right subtree is greater than or 

equal to n. Thus, if we visit the left subtree in order, using a recursive call, and 

then visit n, and then visit the right subtree in order, we have visited the entire 

subtree rooted at n in order. We can assume the recursive calls correctly visit 

the subtrees in order using the mathematical principle of structural induction. 

Traversing in reverse inorder similarly gives the values in decreasing order. 

Preorder traversal 

Traversing a tree in preorder while inserting the values into a new tree is 

common way of making a complete copy of a binary search tree.One can also 

use preorder traversals to get a prefix expression (Polish notation) from 

expression trees: traverse the expression tree preorderly. To calculate the value 

of such an expression: scan from right to left, placing the elements in a stack. 

Each time we find an operator, we replace the two top symbols of the stack 

with the result of applying the operator to those elements. For instance, the 

expression + 2 3 4, which in infix notation is (2 + 3) 4, would be evaluated 

like this: 

Using prefix traversal to evaluate an expression tree 

Expression (remaining) Stack 

+ 2 3 4 

Prepared By : 




+ 2 3 4 

+ 2 3 4 

+ 2 3 4 

5 4 

Binary Search tree. 

Answer 20 

A binary search tree is a binary tree with the nodes arranged so as to support 

binary search, that is: 

1. THE LEFT CHILD’S KEY IS ALWAYS LESS THAN THE PARENT’S KEY; 

2. THE RIGHT CHILD’S KEY IS ALWAYS GREATER THAN THE PARENT’S KEY. 

We can visualize each node as having two pointers – a Left pointer to the left 

child and a Right pointer to the right child. 

Prepared By : 




DELETING FROM A BINARY TREE. 

4 cases to consider, although some may be handled by the same strategy: 

1) Node is a leaf. 

2) Node has a left child only. 

3) Node has a right child. 

4) Node has two children. 

Case 1 is obviously simple: 

Case 1. Delete a leaf (node with 0 children). 

Easy: (a) Find node’s address and store it. 

(b) Set parent’s pointer to NULL. 

(c) delete leaf node. 

Case 2: Node has a left child only. 

Want to dispose of parent, but keep left child (and any of its children). 

Case 3: Node has a right child only. 

Prepared By : 




Similar to case 2 except want to keep left child and any of its children. 

Case 4: Delete a parent with 2 children. E.g. delete Q. 

Problem: Can’t guarantee that the parent of the node could point to both 

children, since the parent may have another child of its own. 

AVL Tree 

In an AVL, the difference between the right and left sub‐tree can never be more 

than 1, throughout the tree. 

A binary search tree (BST) is an AVL tree if and only if, for every node in the tree, 

the difference between maximum height of the right sub‐tree minus the 

maximum height of the left sub‐tree is less than 2. 

That is the difference can be ‐1, 0, or 1. 

AVL Trees is An ordered tree (binary search tree) is used when we wish to store 

objects with (numerical) keys in a binary tree so that lookups can be done in 

order log 2N time, where N is the number of objects in the tree. But an ordered 

tree that is seriously ``unbalanced,'' that is, where paths from the root to the 

leaves have dramatically different lengths, will ruin the desired lookup 

behavior. 

The worst‐case example of an unbalanced ordered tree is the tree built by 

inserting a sorted sequence of objects (we show the numerical keys only; the 

objects attached with the keys are unimportant): 

1 2 3 4 

The tree looks like this: 

1 

/ \ 

. 2 

Prepared By : 




/ \ 

. 3 

/ \ 

. 4 

/ \ 

. . 

Obviously, a lookup in this tree is just a linear search, which is slower than log‐ 

time. 

How can we maintain an ordered tree so that, regardless of the order of 

insertions, the tree remains balanced? There are several sophisticated 

technques for doing so; here we consider one of the most elegant, AVL trees. 

Definition of an AVL tree 

(For example, if the tree held 2048 An AVL‐tree is an ordered tree that has the 

height-balanced property. Here are the basic definitions: 

The height of a tree is the length of the longest path from the tree's root 

to one of its leaves. 

A Node is balanced if the height of its left subtree is plus‐or‐minus‐one 

the height of its right subtree. 

A binary tree has the height-balanced property if all of its Nodes are 

balanced 

According to this definition, the following is NOT an AVL tree, because the root 

node (A) has a balance of 2. Balances of 0 are not shown. 

A (3‐1 = 2) 

B C (2‐1 = 1) 

D E (1‐0 = 1) 

Prepared By : 




Likewise, the following is NOT an AVL tree. Note that negative values arise 

when the left sub‐tree is taller than the right sub‐tree. 

B 

A C 

F (1 – 3 = ‐2) 

D G 

F 

On the other hand, although not perfectly balanced the following is an AVL tree. 

Balances of 0 are not shown. 

10 (‐1) 

5 (‐1) 15 (‐1) 

3 (‐1) 6 (1) 13 (‐1) 20 

2 (‐1) 4 8 12 

1 

C. Node rotation. 

In order to maintain an AVL tree as an AVL tree, the normal insertion and 

deletion algorithms have to be supplemented with “node rotation” procedures. 

There are right rotations, left rotations and double rotations. 

1. A left rotation. 

Prepared By : 




Consider the following tree: 

5 

3 10 

2 4 6 15 

1 8 13 20 

12 

A left rotate of node 10 requires the following: 

1) 10’s right child (15) rises up to replace 10. 

2) This orphans 15’s left children (13 and 12), but… 

3) 10 becomes the left child of 15 and adopts 12 and 13, producing the following 

tree. 

5 

3 15 

2 4 10 20 

1 6 13 

8 12 

Prepared By : 




2. A right rotation. 

Suppose we begin with the following AVL tree. 

2 6 

8 

4 9 

Now suppose that we want to insert the value 3. 

If we do a normal insert, we now have a problem, because the resulting tree is 

not an AVL tree. 

8 (‐2) 

4 (‐1) 9 

2 (1) 6 

3 

To correct this situation, we need to do a right rotation of 8. 

This requires: 

(1) 4 is promoted, replacing 8. 

(2) This orphans 4’s right child (6), but: 

(3) 8 becomes 4’s right child and adopts 6 as a left child 

This yields the following tree: 

4 

Prepared By : 




3. A double rotation. 

2 8 

3 6 9 

For the gold medal, sometimes one rotation isn’t enough to fix the problem….. 

Suppose we begin again with the following AVL tree. 

8 

2 6 

4 9 

Now suppose we insert 5, which yields the non‐AVL tree: 

8 (‐2) 

4 (1) 9 

2 6 (‐1) 

5 

The only way this mess can be fixed is with a double rotation: 

A left rotation of node 4 and a right notation of node 8. 

1) After the left rotation of node 4 we still get a non‐AVL tree: 

8 (‐2) 

6 9 

Prepared By : 




4 

2 5 

2) After the right notation of node 8 we finally get an AVL tree again. 

6 

4 8 

2 5 9 

Threaded binary tree 

A threaded tree, with the special threading links shown by dashed arrows 

A threaded binary tree may be defined as follows: 

"A binary tree is threaded by making all right child pointers that would normally 

be null point to the inorder successor of the node, and all left child pointers that 

would normally be null point to the inorder predecessor of the node." 

Prepared By : 




(Van Wyk, Christopher J. Data Structures and C Programs, Addison‐Wesley, 

1988, p. 175. ISBN 978‐0‐201‐16116‐8.) 

A threaded binary tree makes it possible to traverse the values in the binary 

tree via a linear traversal that is more rapid than a recursive in‐order traversal. 

It is also possible to discover the parent of a node from a threaded binary tree, 

without explicit use of parent pointers or a stack, albeit slowly. This can be 

useful where stack space is limited, or where a stack of parent pointers is 

unavailable (for finding the parent pointer via DFS). 

This is possible, because if a node (k) has a right child (m) then m's left pointer 

must be either a child, or a thread back to k. In the case of a left child, that left 

child must also have a left child or a thread back to k, and so we can follow m's 

left children until we find a thread, pointing back to k. The situation is similar for 

when m is the left child of k 

Multiway Search Trees 

A multiway search tree is one with nodes that have two or more children. 

Within each node is stored a given key, which is associated to an item we wish 

to access through the structure. 

Given this definition, a binary search tree is a multiway search tree. 

More Formal Definition 

Let T be a multiway search tree, then T has the following properties: 

• T is ordered, meaning that the all the elements in subtrees to the left of 

an item are less than the item itself, and all the elements in subtrees to 

the right of an item are greater. 

• Each internal node of T has at least 2 children. 

• Each d‐node (node with d children) v of T, with children v1,...,vd stores d‐1 

items (k1, x1),...,(kd‐1, xd‐1). Where the ki's are keys and xi is the element 

associated with key number i. 

Prepared By : 




• External nodes are empty 

Figure 6.1: A multiway search tree with a successful search path for the number 

6 (in green), and an unsuccessful search path for the number 26 (in red) 

Searching 

Searching in a general multiway search tree is analogous to searching in a binary 

search tree. Starting at the root, we trace a path in T as follows: 

1. For a d‐node v, compare the sought key with the keys k1,...,kd‐1 stored at 

v. 

2. If k is found then the search is a SUCCESS. 

3. Otherwise return to step 1 using the child vi such that ki‐1


I. SIZE: every node can have no more than 4 children. 

II. DEPTH: all external nodes have the same depth. 

Assuming that we are able to maintain these properties (which still remains to 

be seen!), then we can deduce a couple of useful properties of this structure: 

1. if follows from the the SIZE property that the number of items at each 

node is less than or equal to 4. Hence dmax is constant and our search time 

is already down to O(h)! 

2. luckily, the DEPTH property ensures that the tree is balanced, but also 

that the height is restricted to THETA(logn) (where n is the number of 

nodes in the tree). Click here if you want to see the proof 

Insertion 

In this section we will show that: 

• The SIZE and DEPTH depth properties of (2,4)‐trees can be maintained 

upon insertion of a new item. 

• The maintenance cost is bounded above by the height of the tree 

The insertion algorithm 

Let's begin with a basic algorithm for insertion and work from there. We would 

like to INSERT a key k into a (2,4)‐tree T. Here are the steps we follow: 

1. perform a SEARCH for k in T. 

if it succeeds then we don't need to INSERT the item and we're done, 

otherwise (if it fails) then the search terminates at an external node z. 

let v be the parent node of z, insert k into the appropriate place in v and add a 

new child w to v on the left of z 

Prepared By : 




Deletion 

In the previous section, we saw that the SIZE and DEPTH properties of (2,4)‐ 

trees can be maintained efficiently as new items are inserted into the tree. We 

now show that the same result holds as items are removed. 

The deletion algorithm 

Once again we'll begin with a basic algorithm that we'll adjust. We want to 

DELETE a key k from T. For now, we shall assume that k is stored in a node v 

whose children are all external nodes. Here are the steps we follow: 

perform a SEARCH for k in T, 

if it fails then we don't need to DELETE the item so we exit, 

otherwise (if it succeds) then we find k in a node v with only external 

children (by our assumption). 

now we simply remove k from v and delete the external node child to the left of 

k 

B‐Tree 

A B‐tree is a tree data structure that keeps data sorted and allows searches, 

insertions, deletions, and sequential access in logarithmic amortized time. The 

B‐tree is a generalization of a binary search tree in that more than two paths 

diverge from a single node. [1] Unlike self‐balancing binary search trees, the B‐ 

tree is optimized for systems that read and write large blocks of data. It is most 

commonly used in databases and filesystems. 

Overview 

In B‐trees, internal (non‐leaf) nodes can have a variable number of child nodes 

within some pre‐defined range. When data is inserted or removed from a node, 

its number of child nodes changes. In order to maintain the pre‐defined range, 

Prepared By : 




internal nodes may be joined or split. Because a range of child nodes is 

permitted, B‐trees do not need re‐balancing as frequently as other self‐ 

balancing search trees, but may waste some space, since nodes are not entirely 

full. The lower and upper bounds on the number of child nodes are typically 

fixed for a particular implementation. For example, in a 2‐3 B‐tree (often simply 

referred to as a 2‐3 tree), each internal node may have only 2 or 3 child nodes. 

Each internal node of a B‐tree will contain a number of keys. Usually, the 

number of keys is chosen to vary between d and 2d. In practice, the keys take 

up the most space in a node. The factor of 2 will guarantee that nodes can be 

split or combined. If an internal node has 2d keys, then adding a key to that 

node can be accomplished by splitting the 2d key node into two d key nodes 

and adding the key to the parent node. Each split node has the required 

minimum number of keys. Similarly, if an internal node and its neighbor each 

have d keys, then a key may be deleted from the internal node by combining 

with its neighbor. Deleting the key would make the internal node have d − 1 

keys; joining the neighbor would add d keys plus one more key brought down 

from the neighbor's parent. The result is an entirely full node of 2d keys. 

The branches (or child nodes) from a node will be one more than the number of 

keys stored in the node. In a 2‐3 B‐tree, the internal nodes will store either one 

key (with two child nodes) or two keys (with three child nodes). A B‐tree is 

sometimes described with the parameters (d + 1) — (2d + 1) or simply with the 

highest branching order, (2d + 1). 

A B‐tree is kept balanced by requiring that all leaf nodes are at the same depth. 

This depth will increase slowly as elements are added to the tree, but an 

increase in the overall depth is infrequent, and results in all leaf nodes being 

one more node further away from the root. 

B‐trees have substantial advantages over alternative implementations when 

node access times far exceed access times within nodes. This usually occurs 

when the nodes are in secondary storage such as disk drives. By maximizing the 

number of child nodes within each internal node, the height of the tree 

decreases and the number of expensive node accesses is reduced. In addition, 

rebalancing the tree occurs less often. The maximum number of child nodes 

Prepared By : 




depends on the information that must be stored for each child node and the 

size a full disk block or an analogous size in secondary storage. While 2‐3 B‐trees 

are easier to explain, practical B‐trees using secondary storage want a large 

number of child nodes to improve performance. 

The term B‐tree may refer to a specific design or it may refer to a general class 

of designs. In the narrow sense, a B‐tree stores keys in its internal nodes but 

need not store those keys in the records at the leaves. The general class includes 

variations such as the B + ‐tree and the B * ‐tree. In the B + ‐tree, copies of the keys 

are stored in the internal nodes; the keys and records are stored in leaves; in 

addition, a leaf may include a pointer to the next leaf to speed sequential 

access [2] . The B * ‐tree balances more neighboring internal nodes to keep the 

internal nodes more densely packed [2] . For example, a non‐root node of a B‐tree 

must be only half full, but a non‐root node of a B * ‐tree must be two‐thirds full. 

Definition 

A B‐tree of order m (the maximum number of children for each node) is a tree 

which satisfies the following properties: 

1. Every node has at most m children. 

2. Every node (except root and leaves) has at least m ⁄2 children. 

3. The root has at least two children if it is not a leaf node. 

4. All leaves appear in the same level, and carry information. 

5. A non‐leaf node with k children contains k–1 keys. 

Each internal node's elements act as separation values which divide its subtrees. 

For example, if an internal node has three child nodes (or subtrees) then it must 

have two separation values or elements a1 and a2. All values in the leftmost 

subtree will be less than a1 , all values in the middle subtree will be between a1 

and a2, and all values in the rightmost subtree will be greater than a2. 

Prepared By : 




Internal nodes in a B‐tree — nodes which are not leaf nodes — are usually 

represented as an ordered set of elements and child pointers. Every internal 

node contains a maximum of U children and — other than the root — a 

minimum of L children. For all internal nodes other than the root, the number of 

elements is one less than the number of child pointers; the number of elements 

is between L‐1 and U‐1. The number U must be either 2L or 2L‐1; thus each 

internal node is at least half full. This relationship between U and L implies that 

two half‐full nodes can be joined to make a legal node, and one full node can be 

split into two legal nodes (if there is room to push one element up into the 

parent). These properties make it possible to delete and insert new values into a 

B‐tree and adjust the tree to preserve the B‐tree properties. 

Leaf nodes have the same restriction on the number of elements, but have no 

children, and no child pointers. 

The root node still has the upper limit on the number of children, but has no 

lower limit. For example, when there are fewer than L‐1 elements in the entire 

tree, the root will be the only node in the tree, and it will have no children at all. 

A B‐tree of depth n+1 can hold about U times as many items as a B‐tree of depth 

n, but the cost of search, insert, and delete operations grows with the depth of 

the tree. As with any balanced tree, the cost grows much more slowly than the 

number of elements. 

Some balanced trees store values only at the leaf nodes, and so have different 

kinds of nodes for leaf nodes and internal nodes. B‐trees keep values in every 

node in the tree, and may use the same structure for all nodes. However, since 

leaf nodes never have children, a specialized structure for leaf nodes in B‐trees 

will improve performance. 

Best case and worst case heights 

The best case height of a B‐Tree is: 

Prepared By : 




The worst case height of a B‐Tree is: 

where M is the maximum number of children a node can have. 

The m‐way tree has the potential to greatly reduce the height of a tree. A B‐ 

Tree is an m‐way search tree with the following additional properties: 

The root is either a leaf or it has 2…..m subtrees. 

All internal nodes have at least [m/2] nonnull subtrees at most m nonnull 

subtrees. 

All leaf nodes are at the same level; that is , the tree is perfectly balanced. 

A leaf node has at least [m/2] – 1 and at the most m‐1 entries. 

When the leaf node is full, we have a condition known as overflow. Overflow 

requires that the leaf node be split into two nodes, each containing half of the 

data. 

For example: 

a. 

b. Original node new node 

c. 

11 14 21 78 97 

11 14 21 78 78 97 

create new right subtree 

21 

11 

Prepared By : 

14 78 97 




Given a B‐Tree structure with an order of 5, we begin inserting 11,21,14 and 78. 

The first insert creates a node that becomes the root. The next three inserts 

simply place the data in the node in ascending key sequence. (a) When we try to 

insert 97, we discover that the node if full. We therefore create a new right 

subtree and move the larger half of the data to it, leaving the rest of the data in 

the original node (b). 

After creating the new node, we insert the median value data (21) into the 

parent of the original node. Because the original node was a root, we create a 

new root and insert 21 into it. 

Algorithms 

Search 

Searching is similar to searching a binary search tree. Starting at the root, the 

tree is recursively traversed from top to bottom. At each level, the search 

chooses the child pointer (subtree) whose separation values are on either side 

of the search value.Binary search is typically (but not necessarily) used within 

nodes to find the separation values and child tree of interest. 

Insertion 

In order to insert a key into a B‐tree, first a B‐Tree search is performed to find 

the correct location for the key. Then the key is inserted. Note that a node 

usually may have a space available for another key and pointer. However, the 

node may be already full and cannot accommodate another key. In that case, 

Prepared By : 




the node is split into two nodes, with half the key values and pointer going into 

one node while the other half going into another node. 

These twin nodes have the same parent, which is modified for the additional 

key value and pointer. In the worst case, the splitting procedure may need to be 

carried all the way up the root of the tree. In that case, the height of the tree 

increases by one level. This insertion procedure is implemented as a recursion 

since the splitting procedure is the same, irrespective of the level. 

A B Tree insertion example with each iteration. 

All insertions start at a leaf node. To insert a new element 

Search the tree to find the leaf node where the new element should be added. 

Insert the new element into that node with the following steps: 

1. If the node contains fewer than the maximum legal number of elements, 

then there is room for the new element. Insert the new element in the 

node, keeping the node's elements ordered. 

2. Otherwise the node it is full, so evenly split it into two nodes. 

1. A single median is chosen from among the leaf's elements and the 

new element. 

Prepared By : 




2. Values less than the median are put in the new left node and values 

greater than the median are put in the new right node, with the 

median acting as a separation value. 

3. Insert the separation value in the node's parent, which may cause it 

to be split, and so on. If the node has no parent (i.e., the node was 

the root), create a new root above this node (increasing the height 

of the tree). 

If the splitting goes all the way up to the root, it creates a new root with a single 

separator value and two children, which is why the lower bound on the size of 

internal nodes does not apply to the root. The maximum number of elements 

per node is U‐1. When a node is split, one element moves to the parent, but one 

element is added. So, it must be possible to divide the maximum number U‐1 of 

elements into two legal nodes. If this number is odd, then U=2L and one of the 

new nodes contains (U‐2)/2 = L‐1 elements, and hence is a legal node, and the 

other contains one more element, and hence it is legal too. If U‐1 is even, then 

U=2L‐1, so there are 2L‐2 elements in the node. Half of this number is L‐1, which 

is the minimum number of elements allowed per node. 

An improved algorithm supports a single pass down the tree from the root to 

the node where the insertion will take place, splitting any full nodes 

encountered on the way. This prevents the need to recall the parent nodes into 

memory, which may be expensive if the nodes are on secondary storage. 

However, to use this improved algorithm, we must be able to send one element 

to the parent and split the remaining U‐2 elements into two legal nodes, 

without adding a new element. This requires U = 2L rather than U = 2L‐1, which 

accounts for why some textbooks impose this requirement in defining B‐trees. 

Deletion 

There are two popular strategies for deletion from a B‐Tree. 

• locate and delete the item, then restructure the tree to regain its 

invariants 

Prepared By : 




• do a single pass down the tree, but before entering (visiting) a node, 

restructure the tree so that once the key to be deleted is encountered, it 

can be deleted without triggering the need for any further restructuring 

The algorithm below uses the former strategy. 

There are two special cases to consider when deleting an element: 

1. the element in an internal node may be a separator for its child nodes 

2. deleting an element may put its node under the minimum number of 

elements and children. 

Each of these cases will be dealt with in order. 

Deletion from a leaf node 

• Search for the value to delete. 

• If the value is in a leaf node, it can simply be deleted from the node, 

• If underflow happens, check siblings to either transfer a key or fuse the 

siblings together. 

Deletion from an internal node 

Each element in an internal node acts as a separation value for two subtrees, 

and when such an element is deleted, two cases arise. In the first case, both of 

the two child nodes to the left and right of the deleted element have the 

minimum number of elements, namely L‐1. They can then be joined into a single 

node with 2L‐2 elements, a number which does not exceed U‐1 and so is a legal 

node. Unless it is known that this particular B‐tree does not contain duplicate 

data, we must then also (recursively) delete the element in question from the 

new node. 

In the second case, one of the two child nodes contains more than the minimum 

number of elements. Then a new separator for those subtrees must be found. 

Note that the largest element in the left subtree is still less than the separator. 

Likewise, the smallest element in the right subtree is the smallest element 

Prepared By : 




which is still greater than the separator. Both of those elements are in leaf 

nodes, and either can be the new separator for the two subtrees. 

• If the value is in an internal node, choose a new separator (either the 

largest element in the left subtree or the smallest element in the right 

subtree), remove it from the leaf node it is in, and replace the element to 

be deleted with the new separator. 

• This has deleted an element from a leaf node, and so is now equivalent to 

the previous case. 

Inserting Key 33 into a B‐Tree (w/ Split) 

Sample B‐Tree 

Searching a B‐Tree for Key 21 

Prepared By : 



B + TREES 


A simple B+ tree example linking the keys 1–7 to data values d1‐d7. Note the 

linked list (red) allowing rapid in‐order traversal. 

In computer science, a B+ tree (BplusTree) is a type of tree which represents 

sorted data in a way that allows for efficient insertion, retrieval and removal of 

records, each of which is identified by a key. It is a dynamic, multilevel index, 

with maximum and minimum bounds on the number of keys in each index 

segment (usually called a "block" or "node"). In a B+ tree, in contrast to a B‐ 

tree, all records are stored at the leaf level of the tree; only keys are stored in 

interior nodes. 

The order (branching factor) of a B+ tree measures the capacity of nodes (i.e. 

the number of children nodes) in the tree. It is defined as a number d such that 

, where m is the number of children in each node. For example, 

if the order of a B+ tree is 7, each internal node (except for the root) may have 

between 4 and 7 children; the root may have between 2 and 7 

Prepared By : 



Search 


The algorithm to perform a search for a record r follows pointers to the correct 

child of each node until a leaf is reached. Then, the leaf is scanned until the 

correct record is found (or until failure). 

Function search (record r) 

u := root 

While (u is not a leaf) do 

Choose the correct pointer in the node 

move to the first node following the pointer 

u := current node 

scan u for r 

This pseudocode assumes that no repetition is allowed. 

Insertion 

• do a search to determine what bucket the new record should go in 

• if the bucket is not full, add the record. 

• otherwise, split the bucket. 

• allocate new leaf and move half the bucket's elements to the new bucket 

• insert the new leaf's smallest key and address into the parent. 

• if the parent is full, split it also 

• now add the middle key to the parent node 

• repeat until a parent is found that need not split 

• if the root splits, create a new root which has one key and two pointers. 

Characteristics 

For a b‐order B+ tree with h levels of index: 

• The maximum number of records stored is n = b h 

• The minimum number of keys is 2(b / 2) 

Prepared By : 



h − 1


• The space required to store the tree is O(n) 

• Inserting a record requires O(logbn) operations in the worst case 

• Finding a record requires O(logbn) operations in the worst case 

• Removing a (previously located) record requires O(logbn) operations in 

the worst case 

• Performing a range query with k elements occurring within the range 

requires O(logbn + k) operations in the worst case. 

Implementation 

The leaves (the bottom‐most index blocks) of the B+ tree are often linked to one 

another in a linked list; this makes range queries simpler and more efficient 

(though the aforementioned upper bound can be achieved even without this 

addition). This does not substantially increase space consumption or 

maintenance on the tree. 

If a storage system has a block size of B bytes, and the keys to be stored have a 

size of k, arguably the most efficient B+ tree is one where b = (B / k) − 1. 

Although theoretically the one‐off is unnecessary, in practice there is often a 

little extra space taken up by the index blocks (for example, the linked list 

references in the leaf blocks). Having an index block which is slightly larger than 

the storage system's actual block represents a significant performance decrease; 

therefore erring on the side of caution is preferable. 

If nodes of the B+ tree are organised as arrays of elements, then it may take a 

considerable time to insert or delete an element as half of the array will need to 

be shifted on average. To overcome this problem, elements inside a node can be 

organized in a binary tree or a B+ tree instead of an array. 

B+ trees can also be used for data stored in RAM. In this case a reasonable 

choice for block size would be the size of processor's cache line. However some 

studies have proved that a block size few times larger than processor's cache 

line can deliver better performance if cache prefetching is used. 

Space efficiency of B+ trees can be improved by using some compression 

techniques. One possibility is to use delta encoding to compress keys stored into 

Prepared By : 




each block. For internal blocks, space saving can be achieved by either 

compressing keys or pointers. For string keys, space can be saved by using the 

following technique: Normally the ith entry of an internal block contains the 

first key of block i+1. Instead of storing the full key, we could store the shortest 

prefix of the first key of block i+1 that is strictly greater (in lexicographic order) 

than last key of block i. There is also a simple way to compress pointers: if we 

suppose that some consecutive blocks i, i+1...i+k are stored contiguously, then it 

will suffice to store only a pointer to the first block and the count of consecutive 

blocks. 

All the above compression techniques have some drawbacks. First, a full block 

must be decompressed to extract a single element. One technique to overcome 

this problem is to divide each block into sub‐blocks and compress them 

separately. In this case searching or inserting an element will only need to 

decompress or compress a sub‐block instead of a full block. Another drawback 

of compression techniques is that the number of stored elements may vary 

considerably from a block to another depending on how well the elements are 

compressed inside each block. 

Deletion 

Before presenting pseudocode we provide a basic flowchart and algorithm to 

illuminate its function. Figure 1 shows how the initial downwards recursive 

search is followed by an upwards unwinding of the recursion, during which the 

deletion, and potentially the rebalancing of the tree, takes place. The second 

phase corresponds to the shaded area of the figure. A set of immediate 

neighbors and anchors, defined below, is calculated during the search phase, for 

use during the tree rebalancing. 

The algorithm outline is as follows: 

1. recurse to a leaf node from root to find deletable entry: for nodes in the 

search path, calculate immediate neighbors and their anchors. 

2. if entry found at leaf node continue else stop 

3. remove appropriate entry fiom current node 

Prepared By : 




4. if there is underflow continue else done 

5. if current node isn’t root, continue else collapse root: make its only child into 

the new root so tree height decreases, done 

6.check number of entries in immediate neighbours. 

7. if both are minimal sized continue else balance current node: shift over half 

of a neighbor’s surplus keys, adjust anchor, done 

8. merge with a neighbor whose anchor is the current node’s parent, unwind to 

parent node and continue at 3. 

recurse to a leaf node from root to find deletable entry: for nodes in the search 

path, calculate immediate neighbors and their anchors if entry found at leaf 

node continue else stop remove appropriate entry fiom current node ;f there is 

underflow continue else done if current node isn’t root, continue else collapse 

root: make its only child into the new root so tree height decreases, done check 

number of entries in immediate neighbors if both are minimal sized continue 

ebe balance current node: shift over half of a neighbor’s surplus keys, adjust 

anchor, done merge with a neighbor whose anchor is the current node’s parent, 

unwind to parent. 

Prepared By :

1. Advanced Data Structure using C++

Create successful ePaper yourself

Delete template?

Save as template?