introduction data structures

8/13/2019 Introduction Data Structures

1/84

Course Name: DATA STRUCTURES

Course Code: 10B11CI211

Course Credits: 4 (3-1-2)Branch and Sem.: All Branches2nd Sem.

Session: JanJun 2012

Data Structu res Team :

Course Coordinator: Dr. Nitin

Team Members: Dr.Yashwant Singh

Dr.Ravi Rastogi

Miss. Shipra Sharma


2/84

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.


3/84

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


4/84

EVALUATION SCHEME

SNo. Exam. Marks Duration

1 T-1 15 1 Hr.

2 T-2 25 1 Hr. 30 Min.

3 T-3 35 2 Hr.

4Assignments,

Quizzes, Home

work and

Regularity in

Attendance

25 Assignment -10

Quizzes -10

Attendance - 5.


5/84


6/84

WHAT IS DATA STRUCTURE

A data structure is a logical andmathematical model of a particularorganization of data.

The choice of particular data structuredepends 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


7/84

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


8/84

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 beassigned values.

Eg. Student is an entity


9/84


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


10/84


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 andhence can be used for decision making


11/84

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


12/84

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.


13/84

ABSTRACT DATA TYPE

In computing, an abstract data type (ADT) is aspecification of a set of data and the set of

operations that can be performed on the data. Sucha data type is abstract in the sense that it isindependent of various concrete implementations.

The main contribution of the abstract data typetheory 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 andsemantics. This important advance in computer sciencetheory (motivated by software engineering challenges inprocedural programming) led to the emergence oflanguages and methodological principles of object-orientedprogramming.


14/84


15/84

THE STUDY OF DATA

STRUCTURE INCLUDE:

Logical description of data structure

Implementation of data structure

Quantative analysis of data structure, thisinclude amount of memory, processing

time


16/84

TYPES OF DATA STRUCTURES

1. Linear data structure

2. Non linear data structure


17/84

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.


18/84

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


19/84

ARRAYS

Collection of homogenous data elements.

Arrays can be:

1. One dimensional2. Two dimensional

3. Multi dimensional


20/84

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 thelists 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


21/84

The Linked List data structure

[0] [1] [2]array

A B CArray

linked

A B CLinked list

Linked lists are unbounded

(maximum number of items limited only by memory)

node


22/84

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 andbackward pointer of the first node points to the last node


23/84

LINKED LISTS (VARIATIONS)

Basic elements:

Head

Node

Simplest form: Linear-Singly-linked

head

A

data pointer

node

A

Head

B C


24/84


Circular-linked Lists

The last node points to the first node of the list

Strengths

Able to traverse the list starting from anypointAllow quick accessto first and last records througha single pointer

Weakness

A bit complicatedduring insertion, needs carefulsetting of pointer for empty or one-node list

A

Head

B C


25/84

LINKED LISTS (VARIATIONS) Doubly-linked Lists

Each inner node points to BOTH successorand thepredecessor

Strengths

Able to traverse the list in anydirection

Can insert or delete a node very quicklygiven only thatnodes address

Weakness

Requires extramemory and handling for additional

pointers

A

Head

B C


26/84


Putting together

Circular-doubly-linked lists!

A

Head

B C


27/84

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 toNULL 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 trueifpopwas successful


28/84

DATA STRUCTURES -- STACKS

A stackis a listin which insertion and

deletion take place at the sameend

This end is called top

The other end is called bottom


29/84

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)


30/84

The Queue Operations

A queue is like a lineof people waiting for abank teller. Thequeue has a frontand a rear.

$$

Front

Rear


31/84

TREES

Tree nodes contain two or more links

All other data structures we have discussedonly contain one

Binary treesAll 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


32/84

TREE TERMINOLOGY

There is a uniquepath from the root

to each node.

Root is a level 0, childis at level(parent) + 1.

Depth/height of a treeis the length of thelongest path.

leve

0

1

2

3

4


33/84

BINARY TREE

Each node has twosuccessors

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 twobinary trees, one calledthe left subtree and onecalled the right subtree


34/84

GRAPHS

G = (V, E)

a vertex may have:0 or more predecessors0 or more successors


35/84

abstract containers

hierarchical(1 to many)

graph (many to many)first ith last

sequence/linear (1 to 1)

set


36/84

HEAPS

Heap is a binary tree that satisfy the followingproperty:

Shape property

Order property

Shape property states that heap is complete ornearly complete binary tree.

Order property states that:

1. Either the element at any node is smallest of

all of its children, called min heap2. Element at any node is largest of all of its

children, called max heap.


37/84

HASH TABLES

There are many application that require a

dynamic structure that support only insert,

search and delete operations. These

operations are commonly known asdictionary operations. A hash table is an

effective data structure for implementing

dictionaries.


38/84

COMMON OPERATIONS ON

DATA STRUCTURE

1. Traversal:-Accessing each element exactlyonce in order to process it.

2. Searching:-Finding the location of a givenelement.

3. Insertion:-Adding the new element to thestructure.

4. Deletion:-Removing a existing element fromthe structure.

5. Sorting:-Arranging the elements in logicalorder.

6. Merging:-Combining the elements of twosimilar sorted structures into a single structure.


39/84

ENUMERATED DATA TYPE

Variable of enumerated data type enhance thereadability of the program.

enum boolean {false, true};

Here boolean is called tag name for the userdefined data type. Then we can declare variableof this type as follows:

enum boolean flag;

Then we can assign value false or true to variableflag, and also we can compare the value of flagwith these values.

void DATA TYPE


40/84

void DATA TYPE This is also known as empty data type, is useful in many situation;

1. 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. Thisis because the compiler cannot determie the size of the value thepointer points to.


41/84

REDEFINING DATA TYPES

Using typedef statement we can make itpossible to declare variables of user defineddata types as with built in data types byredefining the user defined data type and giving

our own name.typedef enum{false, true} boolean;

The word boolean becomes name of the newdefined data type.

boolean flag;


42/84

CONTROL STATEMENTS

1. Decision making statements if statement

if-else statement

switch statement

2. Looping Statements for statement

while statement

do while statement

3. Jumping statements

brake statement

continue statement

goto statement

MEMORY USE IN C


43/84

MEMORY USE IN C

STACK

HEAP

BSS

CONST

DATA

TEXT

High Memory

Low Memory

Initialized and un initialized local

variable

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


44/84

POINTER

Pointer is a variable which contains

reference of another variable

Address of x value of x

px x

Pointerpx=&x

DECLARATION OF POINTER


45/84

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 ippoints*/

address 5

ip


46/84

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


47/84

ASSIGNMENT IN POINTER

GivenInt 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 apoints */

c=&y; /* c points to y */


48/84

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


49/84

DYNAMIC MEMORY

MANAGEMENT

Memory management functions

Functio

n name

Description

malloc Allocate memory from heap

calloc Allocate memory from heap and initializes

the allocated memory to zeros

realloc Readjusts the existing block and copiesthe contents to new location

free Deallocates block allocated by malloc,

calloc and realloc fuctions

DYNAMIC MEMORY


50/84

DYNAMIC MEMORY

ALLOCATION Dynamic memory allocation

Obtain and release memory during execution

malloc

Takes number of bytes to allocate Use sizeofto determine the size of an object

Returns pointer of type void* A void*pointer may be assigned to any pointer

If no memory available, returnsNULL

ExamplenewPtr = malloc( sizeof( struct node ) );

free Deallocates memory allocated bymalloc

Takes a pointer as an argument

free( newPtr );


51/84

calloc()

The calloc() function dynamically allocates

memory and automatically initializes the

memory to zeroes. Example

newPtr = calloc( 5,sizeof( struct node) );


52/84

realloc()

The realloc() function changes the size ofpreviously dynamically allocated memorywith 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 ispointer to the original object and secondargument is new size of the object.


53/84

free()

The free() function deallocates a memory

block previously allocated with malloc(),

calloc(), or realloc() functions. Prototype

for free function isvoid free(void *block);

It takes one argument that specify the

pointer to the allocated block.


54/84

DEBUGGING POINTERS

The pointer can be the source of mysterious

and catastrophic program bugs.

Common bugs related to related to

pointer and memory management is1. Dangling pointer

2. Null pointer assignment

3. Memory leak

4. Allocation failure


55/84

STRUCTURES

A structure is a collection of data elements,

called fields which may be of different

type.

Individual elements of a structure variableare accessed using dot operator (.), if a

pointer is used to point to a structure

variable , then arrow operator (->) is used.


56/84

STRUCTURE

Example of complex data structures and the

corresponding self referential structure to

represent these data structure.

Next pointer field

Information field

head

1200 1201 1202 X


57/84

STRUCTURE

typedef struct nodetype{

int info;

struct nodetype *next;

} node;

node * head;


58/84

Recursion


59/84

Divide-and-conquer


60/84

What is recursion?


61/84

Recursive functions


62/84

Nature of recursion


63/84


64/84

Types of Recursion

Direct Recursion

Indirect Recursion


65/84

Iteration vs. recursion

Recursion: sum()


66/84

()


67/84

Recursion: sum()


68/84

How does recursion work?


69/84



70/84


Recursion


71/84

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


72/84

RecursionExample: factorials

5! = 5 * 4 * 3 * 2 * 1Notice that

5! = 5 * 4!

4! = 4 * 3! ...

Can compute factorials recursively

Solve base case (1! = 0! = 1)

then plug in2! = 2 * 1! = 2 * 1 = 2;

3! = 3 * 2! = 3 * 2 = 6;

Recursion


73/84

Recursion

5!

(a ) Seq uenc e of rec ursive c alls. (b ) Values returned from ea c h recursive c all.

Final va lue = 120

5! = 5 * 24 = 120 is returned

4! = 4 * 6 = 24 is returned

2! = 2 * 1 = 2 is returned

3! = 3 * 2 = 6 is retu rned

1 returned

5 * 4!

1

4 * 3!

3 * 2!

2 * 1!

5!

5 * 4!

1

4 * 3!

3 * 2!

2 * 1!

1

2 Recursive factorial function */


74/84

3 #include4

5 longfactorial( longnumber ); /* function prototype */6

7 /* function main begins program execution */8 intmain()9 {10 inti; /* counter */11

12 /* loop 10 times. During each iteration, calculate13 factorial( i ) and display result */14 for( i = 1; i


75/84

1 = 12 = 23 = 64 = 245 = 1206 = 7207 = 50408 = 403209 = 36288010 = 3628800

24 {25 /* base case */26 if( number


76/84

p g

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 thefibonaccifunctionlong fibonacci( long n )

{

if (n == 0 || n == 1) // base casereturn n;

else

return fibonacci( n - 1) + fibonacci( n 2 );

}

Example Using Recursion: The


77/84

p g

Fibonacci Series

f( 3 )

f( 1 )f( 2 )

f( 1 ) f( 0 ) return 1

return 1 return 0

return +

+return

1

2 Recursive fibonacci function */


78/84

3 #include4

5 longfibonacci( longn ); /* function prototype */6

7 /* function main begins program execution */8 intmain()9 {10 longresult; /* fibonacci value */11 longnumber; /* number input by user */12

13 /* obtain integer from user */14 printf( "Enter an integer: ");15 scanf( "%ld", &number );16

17 /* calculate fibonacci value for number input by user */18 result = fibonacci( number );19

20 /* display result */21 printf( "Fibonacci( %ld ) = %ld\n", number, result );22

23 return0; /* indicates successful termination */24

25 } /* end main */26

27 /* Recursive definition of function fibonacci */28 longfibonacci longn )


79/84

Enter an integer: 0Fibonacci( 0 ) = 0Enter an integer: 1Fibonacci( 1 ) = 1Enter an integer: 2Fibonacci( 2 ) = 1Enter an integer: 3Fibonacci( 3 ) = 2Enter an integer: 4Fibonacci( 4 ) = 3

29 {30 /* base case */31 if n == 0|| n == 1) {32 returnn;33 } /* end if */34 else{ /* recursive step */35 returnfibonacci n - 1) + fibonacci n - 2);36 } /* end else */37

38 } /* end function fibonacci */

Enter an integer: 5Fibonacci( 5 ) = 5


80/84

Enter an integer: 6

Fibonacci( 6 ) = 8

Enter an integer: 10Fibonacci( 10 ) = 55

Enter an integer: 20

Fibonacci( 20 ) = 6765


Fibonacci( 30 ) = 832040


Fibonacci( 35 ) = 9227465

Recursion vs. Iteration


81/84

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)


82/84

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


83/84


84/84

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

introduction data structures

Documents