# Data Structure - trees and queues - Notes, Study notes for Data Structures and Algorithms. Indian Institute of Information Technology (IIIT)

PPT (1 MB)
32 pages
1000+Number of visits
Description
This document about Data and File Structures , Queue, Queue Implementations, Circular Queue, Graph: Definition, Representing Graphs.
20points
this document
Preview3 pages / 32
Data and File Structures Lecture-

Data and File Structures

Queue • Properties

– Elements removed in order of insertion – First-in, First-out (FIFO) – Must track Front (first in) and Back (last in)

• Queue operations – Enqueue = add element (to back) – Dequeue = remove element (from front)

Queue Implementations

• Linked list – Add to tail (Back) of list – Remove from head (Front) of list

• Array • Circular array

Circular Queue

• Circular array (ring) – q[ 0 ] follows q[ MAX – 1 ] – Index using q[ i % MAX ]

• Problem – Detecting difference

between empty and nonempty queue

Circular Queue • Approach 1

– Keep Front at first in – Keep Back at last in

• Problem – Empty queue identical to queue with 1 element

Circular Queue • Approach 2

– Keep Front at first in – Keep Back at last in – 1

• Problem – Empty queue identical to full queue

Circular Queue • Inherent problem for queue of size N

– Only N possible (Front – Back) pointer locations – N+1 possible queue configurations

• Queue with 0, 1, … N elements

• Solutions – Maintain additional state information

• Use state to recognize empty / full queue • Examples

– Record Size – Record QueueEmpty flag

– Leave empty element in queue – Store marker in queue

Graph: Definition • A graph G consists of two sets

– a finite, nonempty set of vertices V(G) – a finite, possible empty set of edges E(G) – G(V,E) represents a graph

• An undirected graph is one in which the pair of vertices in a edge is unordered, (v0, v1) = (v1,v0)

• A directed graph is one in which each edge is a directed pair of vertices, <v0, v1>  <v1,v0>

Data Structures - Graph

THESE ARE ALL GRAPHS.

Graph Terms Path

– A path from vertex u and v of a graph G exists if there exists a set adjacent edges that starts with u and ends with v

Simple Graph – – A graph without loops and with at most one edge between any two

vertices is called a simple graph • Length of a path

– The number of edges in the aforementioned set

Graph Terms • Connected –

– iff, for every pair of its vertices, <u,v>, there is a path from u to v. • Connected Components –

– If a graph is not connected, it is made of two or more connected components. – The “maximal” connected subgraph of a given graph.

Cycle – – A simple path, of non-zero length, that starts & ends at the same vertex.

Acyclic Graph – – A graph with no cycles

Connected graph Connected components Cyclic graph Acyclic graph

Examples 0

1 2

3

0

1

2

0

1 2

3 4 5 6G1 G2 G3

V(G1)={0,1,2,3} E(G1)={(0,1),(0,2),(0,3),(1,2),(1,3),(2,3)} V(G2)={0,1,2,3,4,5,6} E(G2)={(0,1),(0,2),(1,3),(1,4),(2,5),(2,6)} V(G3)={0,1,2} E(G3)={<0,1>,<1,0>,<1,2>}

complete undirected graph: n (n–1)/2 edges complete directed graph: n (n–1) edges

complete graph incomplete graph

Representing Graphs • Graphs –

– Inherently abstract – Directed or Undirected – Two common representations:

A B C A 0 1 1 B 1 1 0 C 0 0 1

{ (A,B),(A,C),(B,A),(B,B),(C,C) }

Adjacency Matrices – A graph with n vertices: G = (V,E) – Adjacency matrix of G (nn array): adj_mat

• If the edge (vi, vj) is in E(G), adj_mat[i][j]=1 • If there is no such edge in E(G), adj_mat[i][j]=0 • adj_mat of an undirected graph is symmetric • adj_mat of a digraph need not be symmetric

0 1 1 1

1 0 1 1

1 1 0 1

1 1 1 0

   

   

0 1 0

1 0 0

0 1 0

  

  

0

1 2

3

0

1

2

[1]

[2]

0

1

2

0 2

1

NULL

NULL

NULL

Weighted Graphs • Weighted Graph –

– A graph G, with the added property that the edges between nodes is assigned a “weight”

– Edge weight may represent: cost, distance, time…

A B C A 0 1.5 2.3 B 1.3 2.0 0 C 0 0 1.1

{ (A,B,1.5),(A,C,2.3), (B,A,1.3), (B,B,2.0),(C,C,1.1) }

Tree – A connected graph with n-1 nodes and n edges – A graph in which any two vertices are connected by

exactly one path. • Forest

– A set of trees – An acyclic graph that not necessarily connected

Rooted Trees • Rooted Tree

– A tree, with a “root” node – Root nodes are selected arbitrarily (any vertex)

• Tree genealogy – Ancestors – Children – Siblings – Parents – Descendents – Leaf nodes

Height & Depth of Trees • Depth

– Depth of vertex v is the length of the simple path from the root to v

– Count the edges • Height

– Height of a tree is the length of the longest simple path from the root to the deepest leaf nodes

HEAP & PRIORITY QUEUE

Max-Heapify routine Max-Heapify(A, i) l = left(i) r = right(i) if (l <=heapsize[A]) && (A[l] > A[i])

largest = l else

largest = r if (r <=heapsize[A]) && (A[r] > A[largest])

largest = r if (largest != i)

exchange(A[i],A[largest]) Max-Heapify(A,largest)

Build-Max-Heap(A) heapsize[A] = length(A) for i =to 1

Max-Heapify(A,i)  2/][Alength

Heap-Sort

Heap-Sort(A) Build-Max-Heap(A) heapsize[A] = length(A) for i = length[A] to 2

exchange(A[1],A[i])heapsize[A] = length(A) –1 Max-Heapify(A,1)

put maximum at the root

Heap-Maximum(A)

returnA[1]

Heap-Extract-Max(A) if (heapsize[A] < 1)

error “heap underflow”max = A[1]A[1] = A[heapsize[A]] heapsize[A]= heapsize[A] –1 Max-Heapify(A,1) returnmax

Heap-Increase-key(A, i, key) if (key < A[i] )

error “new key smaller than existing one”A[i] = key while(i > 1) &&(A[parent(i)] <A[i])

exchange(A[i], parent(A[i])) i = parent(i)

Max-Heap-Insert (A, key) heapsize[A]= heapsize[A] + 1

A[heapsize[A]] = Heap-Increase-Key(A, heapsize[A], key)