Course Name: Course Code: Course Credits: Branch and Sem.
: Session:
DATA STRUCTURES 10B11CI211 4 (3-1-2) All Branches 2nd Sem. Jan Jun 2012
Data Structures Team:
Course Coordinator: Dr. Nitin Team Members: Dr.Yashwant Singh Dr.Ravi Rastogi Miss. Shipra Sharma
WHAT THE COURSE IS ABOUT
Data structures is concerned with the representation and manipulation of data. All programs manipulate data. So, all programs represent data in some way. Data manipulation requires an algorithm. We shall study ways to represent data and algorithms to manipulate these representations. The study of data structures is fundamental to Computer Science & Engineering.
PREREQUISITE
C Enumerated data type, void data type typedef statement Control statements Use of memory by a program Specification of pointers Memory management functions Problems with pointers Various aspects of user defined functions
EVALUATION SCHEME
SNo. Exam. 1 2 3 4 T-1 T-2 T-3
Assignments, Quizzes, Home work and Regularity in Attendance
Marks 15 25 35 25
Duration 1 Hr. 1 Hr. 30 Min. 2 Hr. Assignment -10 Quizzes -10 Attendance - 5.
WHAT IS DATA STRUCTURE
A Conceptual and concrete way to organize data for efficient storage and manipulation
WHAT IS DATA STRUCTURE
A data structure is a logical and mathematical model of a particular organization of data. The choice of particular data structure depends upon following consideration: 1.It must be able to represent the inherent relationship of data in the real world. 2.It must be simple enough so that it can process efficiently as and when necessary
OVERVIEW OF DATA STRUCTURE
Basic Terms related to data organization Data type Meaning of data structure Factor that influence the choice of data structure Different data structure Various operation performed on data structure
BASIC TERMS RELATED TO DATA ORGANIZATION
Data: Values or set of values. Eg. Observation of experiment, marks obtained by student. Data item: A data item refers to a single unit of values. Eg. Roll no. name etc. Entity: That has certain attribute or properties which may be assigned values. Eg. Student is an entity
BASIC TERMS RELATED TO DATA ORGANIZATION
Entity set: Collection of similar entity. Eg. Student of a class Record: Collection of related data items. Eg. Rollno, Dob, gender, class of a particular student. File: Collection of related record. Eg. A file containing records of all students in a class
BASIC TERMS RELATED TO DATA ORGANIZATION
Key: A key is a data item in a record that takes unique values and can be used to distinguish a record from other records. Information: Meaningful data, coveys some meaning and hence can be used for decision making
DATA TYPE
A data type is a collection of values and a set of operation that act on those values Classification of data type: 1. Primitive data type 2. Abstract data type 3. Polymorphic data type
PRIMITIVE DATA TYPE
That is predefined. It is also known as built in data type. Eg. C have built in data type int, long int, float, double, char.
ABSTRACT DATA TYPE
In computing, an abstract data type (ADT) is a specification of a set of data and the set of operations that can be performed on the data. Such a data type is abstract in the sense that it is independent of various concrete implementations. The main contribution of the abstract data type theory is that it
(1) formalizes a definition of type (which was only intuitively hinted on procedural programming) (2) on the basis of the information hiding principle and (3) in a way that such formalization can be explicitly represented in programming language notations and semantics. This important advance in computer science theory (motivated by software engineering challenges in procedural programming) led to the emergence of languages and methodological principles of object-oriented programming.
POLYMORPHIC DATA TYPE
Very often in programs, a generic operation must be performed on data of different types. For example, in our bubble sort algorithm for the payroll records, when elements were found out of order in the id[] array, we needed to swap the integer elements in that array as well as the float elements in the hrs[] and rate[] arrays. If we decided to implement this swapping operation as a function, we would need to write two functions: one to swap integers, and another to swap floating point values; even though the algorithm for swapping is the same in both cases. The C language provides a mechanism which allows us to write a single swapping function which can be used on any data type. This mechanism is called a polymorphic data type, i.e. a data type which can be transformed to any distinct data type as required..
THE STUDY OF DATA STRUCTURE INCLUDE:
Logical description of data structure Implementation of data structure Quantative analysis of data structure, this include amount of memory, processing time
TYPES OF DATA STRUCTURES
1. Linear data structure 2. Non linear data structure
LINEAR DATA STRUCTURE
A data structure whose elements form a sequence, and every element in the structures has a unique predecessor and unique successor. Eg. Array, linked list, stack and queues.
NON LINEAR DATA STRUCTURE
A data structure whose elements do not form a sequence, and there is no predecessor and unique successor. Eg. Trees, graphs
ARRAYS
Collection of homogenous data elements. Arrays can be: 1. One dimensional 2. Two dimensional 3. Multi dimensional
LINKED LIST
Linked list
Linear collection of self-referential class objects, called nodes Connected by pointer links Accessed via a pointer to the first node of the list Subsequent nodes are accessed via the link-pointer member of the current node Link pointer in the last node is set to null to mark the lists end
Use a linked list instead of an array when
You have an unpredictable number of data elements Your list needs to be sorted quickly
The Linked List data structure
array [0] [1] [2] A B C
Array
node
linked
Linked list
Linked lists are unbounded (maximum number of items limited only by memory)
LINKED LIST
Types of linked lists:
Singly linked list
Begins with a pointer to the first node Terminates with a null pointer Only traversed in one direction
Circular, singly linked
Pointer in the last node points back to the first node
Doubly linked list
Two start pointers first element and last element Each node has a forward pointer and a backward pointer Allows traversals both forwards and backwards
Circular, doubly linked list
Forward pointer of the last node points to the first node and backward pointer of the first node points to the last node
LINKED LISTS (VARIATIONS)
Basic elements:
Head Node
head node
A
data pointer
Simplest form: Linear-Singly-linked
A Head B C
LINKED LISTS (VARIATIONS)
Circular-linked Lists
A Head B C
The last node points to the first node of the list
Strengths
Able to traverse the list starting from any point Allow quick access to first and last records through a single pointer
Weakness
A bit complicated during insertion, needs careful setting of pointer for empty or one-node list
LINKED LISTS (VARIATIONS)
Doubly-linked Lists
A B
C
Head
Each inner node points to BOTH successor and the predecessor
Strengths
Able to traverse the list in any direction Can insert or delete a node very quickly given only that nodes address
Weakness
Requires extra memory and handling for additional pointers
LINKED LISTS (VARIATIONS)
Putting together Circular-doubly-linked lists!
Head
STACK
Stack
New nodes can be added and removed only at the top Similar to a pile of dishes Last-in, first-out (LIFO) Bottom of stack indicated by a link member to NULL Constrained version of a linked list
push
Adds a new node to the top of the stack
pop
Removes a node from the top Stores the popped value Returns true if pop was successful
DATA STRUCTURES -- STACKS
A stack is a list in which insertion and deletion take place at the same end
This end is called top The other end is called bottom
QUEUES
Queue
Similar to a supermarket checkout line First-in, first-out (FIFO) Nodes are removed only from the head Nodes are inserted only at the tail
Insert and remove operations
Enqueue (insert) and dequeue (remove)
The Queue Operations
A queue is like a line of people waiting for a bank teller. The queue has a front and a rear.
$ $
Front Rear
TREES
Tree nodes contain two or more links
All other data structures we have discussed only contain one
Binary trees
All nodes contain two links
None, one, or both of which may be NULL
The root node is the first node in a tree. Each link in the root node refers to a child A node with no children is called a leaf node
TREE TERMINOLOGY
There is a unique path from the root to each node. Root is a level 0, child is at level(parent) + 1.
level 0 1 2 3 4
Depth/height of a tree is the length of the longest path.
BINARY TREE
Each node has two successors
one called the left child one called the right child left child and/or right child may be empty
A binary tree is either - empty or - consists of a root and two binary trees, one called the left subtree and one called the right subtree
GRAPHS G = (V, E)
a vertex may have: 0 or more predecessors 0 or more successors
abstract containers
sequence/linear (1 to 1)
first ith last
hierarchical (1 to many)
graph (many to many)
set
HEAPS
Heap is a binary tree that satisfy the following property: Shape property Order property Shape property states that heap is complete or nearly complete binary tree. Order property states that: 1. Either the element at any node is smallest of all of its children, called min heap 2. Element at any node is largest of all of its children, called max heap.
HASH TABLES
There are many application that require a dynamic structure that support only insert, search and delete operations. These operations are commonly known as dictionary operations. A hash table is an effective data structure for implementing dictionaries.
COMMON OPERATIONS ON DATA STRUCTURE
1. Traversal:-Accessing each element exactly once in order to process it. 2. Searching:-Finding the location of a given element. 3. Insertion:-Adding the new element to the structure. 4. Deletion:-Removing a existing element from the structure. 5. Sorting:-Arranging the elements in logical order. 6. Merging:-Combining the elements of two similar sorted structures into a single structure.
ENUMERATED DATA TYPE
Variable of enumerated data type enhance the readability of the program. enum boolean {false, true}; Here boolean is called tag name for the user defined data type. Then we can declare variable of this type as follows: enum boolean flag; Then we can assign value false or true to variable flag, and also we can compare the value of flag with these values.
void DATA TYPE
1. This is also known as empty data type, is useful in many situation; Void functionname(int x, int y) { } Functionname() does not return any value. 2. Int functionname(void) { } Functionname() does not take any rgument. 3. Void main() { void *ptr; int x=5; ptr=&x; printf(value pointed to pointer is now %d,*(int*)ptr); } Void pointer cannot be directly dereferenced without type casting. This is because the compiler cannot determie the size of the value the pointer points to.
REDEFINING DATA TYPES
Using typedef statement we can make it possible to declare variables of user defined data types as with built in data types by redefining the user defined data type and giving our own name. typedef enum{false, true} boolean; The word boolean becomes name of the new defined data type. boolean flag;
CONTROL STATEMENTS
1. 2. 3. Decision making statements if statement if-else statement switch statement Looping Statements for statement while statement do while statement Jumping statements brake statement continue statement goto statement
MEMORY USE IN C
High Memory STACK Initialized and un initialized local variable
HEAP BSS CONST DATA Low Memory TEXT
Memory allocated with malloc(). Calloc(), and realloc() functions
Un initialized static variable
Read only variable
Initialized & un initialized global variables & initialized static variables
Program code
POINTER
Pointer is a variable which contains reference of another variable
Address of x
px
value of x
x
Pointer
px=&x
DECLARATION OF POINTER
* is used to declare and dereference the pointers. data type *ptvar; int *ip; /*declare ip to be pointer to an integer*/ *ip=5; /* assign 5 to the integer pointer to which ip points*/
address ip 5
POINTER OPERATOR
Two operators: &-----address of *------at address in X=8 let x be at 100 (x at 100) Ip=&x ip contains 100 (ip at 200) a=*ip contains 8 (a at 250)
8
100 8
ASSIGNMENT IN POINTER
Given Int x; Double y; Int *a,*b; double *c; a=&x; /* a now points to x*/ b=a; /*b now points to the same variable as a points */ c=&y; /* c points to y */
POINTER TO A POINTER
Variable that hold an address of a another variable that in turn holds an address of another variable, this type of variable is know as pointer to pointer. Pointer to pointer will be declared as **ptr;
DYNAMIC MEMORY MANAGEMENT
Memory management functions Functio Description n name malloc Allocate memory from heap calloc realloc free Allocate memory from heap and initializes the allocated memory to zeros Readjusts the existing block and copies the contents to new location Deallocates block allocated by malloc, calloc and realloc fuctions
DYNAMIC MEMORY ALLOCATION
Dynamic memory allocation
Obtain and release memory during execution
malloc
Takes number of bytes to allocate
Use sizeof to determine the size of an object
Returns pointer of type void *
A void * pointer may be assigned to any pointer If no memory available, returns NULL
Example
newPtr = malloc( sizeof( struct node ) );
free
Deallocates memory allocated by malloc Takes a pointer as an argument free ( newPtr );
calloc()
The calloc() function dynamically allocates memory and automatically initializes the memory to zeroes. Example
newPtr = calloc( 5,sizeof( struct node ) );
realloc()
The realloc() function changes the size of previously dynamically allocated memory with malloc(),calloc() or realloc function() functions. The prototype of realloc() function is Void *realloc(void *block,size_t size); It takes two arguments, first argumant is pointer to the original object and second argument is new size of the object.
free()
The free() function deallocates a memory block previously allocated with malloc(), calloc(), or realloc() functions. Prototype for free function is void free(void *block); It takes one argument that specify the pointer to the allocated block.
DEBUGGING POINTERS
The pointer can be the source of mysterious and catastrophic program bugs. Common bugs related to related to pointer and memory management is 1. Dangling pointer 2. Null pointer assignment 3. Memory leak 4. Allocation failure
STRUCTURES
A structure is a collection of data elements, called fields which may be of different type. Individual elements of a structure variable are accessed using dot operator (.), if a pointer is used to point to a structure variable , then arrow operator (->) is used.
STRUCTURE
Example of complex data structures and the corresponding self referential structure to represent these data structure.
head
1200 1201 1202 X
Next pointer field Information field
STRUCTURE
typedef struct nodetype{ int info; struct nodetype *next; } node; node * head;
Recursion
Divide-and-conquer
What is recursion?
Recursive functions
Nature of recursion
Nature of recursion
Types of Recursion
Direct Recursion Indirect Recursion
Iteration vs. recursion
Recursion: sum()
Recursion: sum()
How does recursion work?
How does recursion work?
How does recursion work?
Recursion
Recursive functions
Functions that call themselves Can only solve a base case Divide a problem up into
What it can do What it cannot do
What it cannot do resembles original problem The function launches a new copy of itself (recursion step) to solve what it cannot do
Eventually base case gets solved
Gets plugged in, works its way up and solves whole problem
Recursion
Example: factorials
5! = 5 * 4 * 3 * 2 * 1
Notice that
5! = 5 * 4! 4! = 4 * 3! ...
Can compute factorials recursively Solve base case (1! = 0! = 1) then plug in
2! = 2 * 1! = 2 * 1 = 2; 3! = 3 * 2! = 3 * 2 = 6;
Recursion
5! 5 * 4! 4 * 3! 3 * 2! 2 * 1! 1 (a) Sequenc e of rec ursive c alls. 5! Final value = 120 5! = 5 * 24 = 120 is returned 5 * 4! 4! = 4 * 6 = 24 is returned 4 * 3! 3! = 3 * 2 = 6 is returned 3 * 2! 2! = 2 * 1 = 2 is returned 2 * 1! 1 returned 1 (b) Values returned from eac h recursive c all.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 } /* end main */ return 0; /* indicates successful termination */ /* loop 10 times. During each iteration, calculate factorial( i ) and display result */ for ( i = 1; i <= 10; i++ ) { printf( "%2d! = %ld\n", i, factorial( i ) ); } /* end for */ /* function main begins program execution */ int main() { int i; /* counter */ long factorial( long number ); /* function prototype */ Recursive factorial function */ #include <stdio.h>
22 /* recursive definition of function factorial */ 23 long factorial( long number ) 24 { 25 26 27 28 29 30 31 32 33 } /* end function factorial */
1! 2! 3! 4! 5! 6! 7! 8! 9! 10! = = = = = = = = = = 1 2 6 24 120 720 5040 40320 362880 3628800
/* base case */ if ( number <= 1 ) { return 1; } /* end if */ else { /* recursive step */ return ( number * factorial( number - 1 ) ); } /* end else */
Example Using Recursion: The Fibonacci Series
Fibonacci series: 0, 1, 1, 2, 3, 5, 8...
Each number is the sum of the previous two Can be solved recursively:
fib( n ) = fib( n - 1 ) + fib( n 2 )
Code for the fibonacci function
long fibonacci( long n ) { if (n == 0 || n == 1) // base case return n; else return fibonacci( n - 1) + fibonacci( n 2 ); }
Example Using Recursion: The Fibonacci Series
f( 3 )
return
f( 2 )
f( 1 )
return
f( 1 )
f( 0 )
return 1
return 1
return 0
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 } /* end main */ return 0; /* indicates successful termination */ /* display result */ printf( "Fibonacci( %ld ) = %ld\n", number, result ); /* calculate fibonacci value for number input by user */ result = fibonacci( number ); /* obtain integer from user */ printf( "Enter an integer: " ); scanf( "%ld", &number ); /* function main begins program execution */ int main() { long result; /* fibonacci value */ long number; /* number input by user */ long fibonacci( long n ); /* function prototype */ Recursive fibonacci function */ #include <stdio.h>
27 /* Recursive definition of function fibonacci */ 28 long fibonacci( long n ) 29 { 30 31 32 33 34 35 36 37 38 } /* end function fibonacci */ /* base case */ if ( n == 0 || n == 1 ) { return n; } /* end if */ else { /* recursive step */ return fibonacci( n - 1 ) + fibonacci( n - 2 ); } /* end else */
Enter an integer: 0 Fibonacci( 0 ) = 0 Enter an integer: 1 Fibonacci( 1 ) = 1 Enter an integer: 2 Fibonacci( 2 ) = 1 Enter an integer: 3 Fibonacci( 3 ) = 2 Enter an integer: 4 Fibonacci( 4 ) = 3
Enter an integer: 5 Fibonacci( 5 ) = 5 Enter an integer: 6 Fibonacci( 6 ) = 8 Enter an integer: 10 Fibonacci( 10 ) = 55 Enter an integer: 20 Fibonacci( 20 ) = 6765 Enter an integer: 30 Fibonacci( 30 ) = 832040 Enter an integer: 35 Fibonacci( 35 ) = 9227465
Recursion vs. Iteration
Repetition
Iteration: explicit loop Recursion: repeated function calls
Termination
Iteration: loop condition fails Recursion: base case recognized
Both can have infinite loops Balance
Choice between performance (iteration) and good software engineering (recursion)
GCD
else { r=x%y; return (recgcd(y,r)); }
Output: Enter the two number 5 8 G.C.D. of the 5 and 8 is 1
Problems on recursion
Factorial Fibonacci number generation Fibonacci series generation Reversing an integer number Calculating power of a number Prime Number checking Generating prime number series Calculating GCD of two numbers Generating table of a number