Data StructuresPlacement Lectures 2012

Pranav Gupta

Why we need Data Structures?

• Efficient and Intuitive representation of data• Tree using arrays vs tree using pointers

• To solve real life problems efficiently• Insertion• Deletion• Search• Sort

• Applications• Social networks• Employee hierarchy• Recommended items

Basic Operations

1. traverse2. insert3. delete4. find

Data Structures (Basic)

• Arrays• Linked Lists• Stacks• Queues• Recursion• Trees – Basic• Practice Problems

Arrays

• Contiguous and fixed memory allocation (independent of language)

• Random access and modification

• List of (index, value); index is non-negative integer; all values in a given array are of the same data type

• To hold various types of values or have non-numerical indices, use associative arrays/dictionaries – The Dictionary Problem?

• Arrays may also be:• 2-D : array of 1-D arrays (a 1-D array is a data type in itself)• 3-D : array of 2-D arrays (a 2-D array is a data type in itself)

• Memory placement of multi-dimensional arrays1.row-major2.column-major

• Useful Operationa. Modifyb. Accessc. Swapd. In-place reverse

Structure of an Arraytemplate<class T> class Array{int size;T *arr;void put();void get();…….};

Useful Libraries#include <vector>

Irregular Arrays• Languages known to students at IITG1.2-D Array

2.Irregular Array

Student

Languages

Student

Special (Arrays ??)

• Diagonal matrix, upper/lower triangular matrix, trigonal matrix, symmetric/asymmetric matrices

• Generally deal with 2-D matrices, but 3-D or higher cases are also possible. Generally deal with square matrix, but rectangular (non-square) are also possible

• More like functions

Special (Arrays ??)

int spec_matrix(int i, int j){return no_cols*i + j + 1;

}

• Performance ??

One Dimensional Sparse Array

4 17 7 23 8 14ary

0 0 0 0 17 0 0 23 14 0 0 0

0 1 2 3 4 5 6 7 8 9 10 11ary

Two Dimensional Sparse Array

8

12

33

17

0 1 2 3 4 50

1

2

3

4

5

5 120

1

2

3

4

5

1 8 5 33

3 17

Row elements can be accessed efficiently

Two Dimensional Sparse Array

8

12

33

17

0 1 2 3 4 50

1

2

3

4

5

5 120

1

2

3

4

5

1 8 5 33

3 17

0 1 2 3 4 5

0

33

4

rows

cols

Efficient row and column elements access

Efficient Representation

8

12

3317

0 1 2 3 4 50

1

2

3

4

5

5 12

1 8 5 33

3 17

5

0

33

4

rows

cols

0

3

4

31

Linked Lists

Why?

• To store heterogeneous data• To store sparse data• Flexibility of increase/decrease in size; easy insertion and

deletion of elements

• Useful Operations• insertion• deletion

Logical Arrangement

First element

Second element

Third element Null

Head nodeFinal node

Tail node

Address of second node

Address of third node

Address of final node

The Structuretemplate <class T> class node{

T data;node<T> *next; // Extra (4?) bytes; size of a pointer

};

template <class T> LinkedList{node<T> *head;int size; // …..etc etc etc

};

Useful Libraries#include <list>

View of the Memory

*Struct is stored in contiguous memory

Insertion/Deletion

Time Complexity:Insertion : O(1) / O(n)Deletion : O(1) / O(n)

Space Complexity:Insertion : O(1)Deletion : O(1)

Tweak some more !

• Doubly Linked Lists• Extra (4?) bytes space vs better accessibility• Insertion/deletion ?

• Circular Linked Lists• How to find the end?

• Tail pointer• Null ‘next’ pointer from last node• Last node points to first (circular)

Practice (Linked List)Linked List 1)Linked List 2)

Recursion

• To solve a task using that task itself• ; a task should have recursive nature• ; generally can be transformed by tweaking some parts of the

task

• Example: task of piling up n coins vs picking up a suitcase.

• Let the task be a C function. What are the parts of the task:1.Input it takes2.What it does3.Output it gives

• A task is performed recursively when generally a large input can’t be handled directly.

• So, recursion is all about simplifying the input at every step till it becomes trivial (base case)

Implementation – run time stack

• Activation Records (AR)• Store the state of a method

1.input parameters2.return values3.local variables4.return addresses

2

25.6

(136)?

2

...…y…

2

25.6

(136)?

2

...…y…

2

15.6

(105)?

2

25.6

(136)?

2

...…y…

2

15.6

(105)?

2

05.6

(105)?

2

25.6

(136)?

2

...…y…

2

15.6

(105)?

2

05.6

(105)1.0

2

25.6

(136)?

2

...…y…

2

15.6

(105)5.6

2

25.6

(136)31.36

2

...…y…

power(5.6, 2)

power(5.6, 1)power(5.6, 2)

power(5.6, 0)power(5.6, 1)power(5.6, 2)

power(5.6, 1)power(5.6, 2)

power(5.6, 2)

• AR is formed on run-time stack and is private to a method.• run-time stack is 1 only.

Stack pointer

Stack pointer

Stack pointer

Stack pointer

Advantages/Disadvantages

1.more readable/understandable/consistent with the the definition

2.memory requirements increase due to runtime stack3.difficult to open and debug

Types of Recursion

• Tail (vs loop?)int factn;While (n > 0) factn *= n--;

• Indirect• A() -> B() -> C() -> A()

• Nested:• h(n) = h(2 + h(n-1))

Types of Recursion

• Excessive: exponential time complexity!

• Questionable: will it terminate??

2)2()1(

11

00)(

nnFibnFibnif

nifnFib

otherwisenf

evenisnifnf

nif

nf

)1*3(

)2/(

11

)(

Hashes

Why?

• Want to store dictionaries?, associative arrays?• arrays with non-numerical indices

• String operations made easy• Ex: Finding anagrams• Ex: Counting frequency of words in a string

Associative Arrays• (key, value) pairs where key is not necessarily a non-negative

integer; can be string etc.

• Ex: no. of students in each department• “cse” => 68• “eee” => 120• “mech” => 70• “biotech” => 30

• Do not allow duplicate keys• Dict (“cse”) = “data structures”• Dict (“cse”) = “algorithms”

Dict(“cse”) = {“data structures”, “algorithms”}

Hash Functions1.HashTable : an array of fixed size

• TableSize - preferably prime and large2.Hash function (map to an index of the HashTable)Techniques

• use all characters• use aggregate properties - length, frequencies of characters• first 3 characters, odd characters

Evaluation• Uniform distribution; load factor λ?• Utilize table space• Quickly computable

3. Collision resolution1.separate chaining

• Linked list at each index• Insertion (at head?)• Desired length of a chain : close to λ• Avg. time for Successful search = 1 + 1 + λ/2• Disadvantages

• slow?• different data structures - array/linked lists?

1.open addressing• Single table• Desired λ ~ 0.5• Apply h0(x), h1(x), h2(x) …

• hi(x) = h(x) + f(i); f(0) = 03 ways to do it

1.linear probing : f(i) is linear in i• f(i) = i (quickly computable vs primary clustering?)

2.quadratic probing : f(i) is quadratic in i3.double hashing

• H(x) = h(x) + f(i).h2(x)Rehashing

• What if the table gets full (70%, …. , 100%)• Create a new HashTable double? the size

Structure

template<class T> class Hash{int TableSize;T *arr;

};

Useful Libraries#include <hash>

Practice (Hashes)Trie 7)

Graphs

What is it?

In simple words, G = (V, E)V = (v0, v1, v2, v3, .. vn) is the set of nodesE = (e0, e1, e2, e3 .. em) is the set of edges

*Any tree T = (V, E) as well; so most techniques in graph algorithms apply to trees as well.

v0

v3v2

v1

Representation1.Adjacency Matrix (|V| * |V|)

2.Adjacency List

Breadth First Traversal (BFT)

• Traverse the nodes depth-wise; nodes at depth 0 before nodes at depth 1 before nodes at depth 2 ....

• Done using a queue• Ex: 1,2,3,4,5,7,8,6

Depth First Traversal (DFT)

• Move to next child only after all nodes in the current child are marked

• Done using a stack• Ex: a, b, c, d, e, h, f, g

Trees (Advanced)

Retrieval

• Stores the prefixes of a set of strings in an efficient manner• Used to store associative arrays/dictionaries

How to create a Trie

• Ex: tin, ten, ted, tea, to, i, in, inn

Pairs of anagrams

• Sort all the strings• acute -> acetu• obtuse -> beostu … etc

• Insert them into the trie• Keep storing collisions i.e. multiple values for each key• Each set of values gives groups of anagrams

Suffix Tree/Patricia/Radix Tree

• Stores the suffixes of a string• O(n) space and time to build• Does not exist for all strings; add special symbol $ at the end

Advantages of Suffix Trees

• Store n suffixes in O(n) space.• Improved string operations. Eg. substring lookup, Longest

common substring operation (generalized suffix trees?)

Generalized Suffix Trees• Each string terminated by a different special symbol• More space efficient• Have different set of algorithms

Longest Common Substring

Longest Common Substring1.Make a “generalized suffix tree” for the (2?) strings2.Traverse the tree to mark all internal nodes as 1, 2 or (1,2)

depending on whether it is parent to a leaf node terminating with the special symbol of string 1 and string 2.

3.Find the deepest internal node marked 1,2

Pattern Matching ?