729 views

Uploaded by api-3801329

Attribution Non-Commercial (BY-NC)

- Designing Classes and Programs
- DB Driven Vertical Menu
- PGF and tikZ manual
- ee2209 viva questions
- Decision Trees
- Splay and Join Operation
- Data Structure
- UNIT - IV
- Final Proposal
- 5.printerscheduling.doc
- Parse Trees
- Incremental Induction of Decision Trees
- A Simple Fast Dominance Algorithm
- 15122 Final Exam Sheet
- DS Viva Questions
- binary tree 2
- An LP NLP based branch and bound algorithm for MINLP optimization.pdf
- heapsortx
- a3-sagiv
- dsa5

You are on page 1of 91

Rabea Aden

Friday, 1st May, 2007

Leftist Tree

• Invented by Clark Allan Crane

Rightmost path is the Shortest

Null Path Length

• denoted by npl(X)

• Length of shortest path from X to an external

node

npl(NULL) = -1

If X has zero or one child, npl(X) = 0

Otherwise

Null Path Length

1

1 0

0 0 0 -1

Null

0 -1 -1 -1 0 -1

Null Null Null Null npl(NULL) = -1

-1 -1 -1 -1

Null Null Null Null

npl(X) = 0

else

npl(X) = 1 + min{ npl( leftChild(X) ), npl( rightChild(X) ) }

Structural Property

• Height-biased Leftist Property

• Tree is unbalanced

• Biased towards left

• Left paths are long, giving the name Leftist Tree

• Rightmost path is the shortest

Structural Property

T1 T2

2 2

npl(leftChild) < npl(rightChild)

0 0 0 0 0 0 0 1

0 0

Leftist Heap

• A Heap-ordered Leftist Tree

Heap-order Property

• Min Leftist Heap

If X is root

Parent (X) = root

Binary Heap vs. Leftist Heap

— Perfectly balanced — Very unbalanced

BuildHeap O(N) O(N)

FindMin O(1) O(1)

Merge Θ(N) O(log N)

Insert O(log N) O(log N)

DeleteMin O(log N) O(log N)

Binary Heap vs. Leftist Heap

— Perfectly balanced — Very unbalanced

BuildHeap O(N) O(N)

FindMin O(1) O(1)

Merge Θ(N) O(log N)

Insert O(log N) O(log N)

DeleteMin O(log N) O(log N)

Theorem

The number of nodes N in a leftist tree

with r nodes on the right path is ≥ 2r -1

Proof is by Induction

This gives

N ≥ 2r − 1 ⇒ r ≤ log2 (n + 1)

Structure of a Node

Left Right

Data NPL

Pointer Pointer

each node also contains the null path length

Design

• A Leftist Tree is a priority queue

implemented using a variant of the Binary

Tree

also maintained

Extended Binary Tree

Given: A Binary Tree TB

replace each empty subtree with an

external node

Binary Tree

Internal

Node

Extended Binary Tree

Since an External Node represents NULL

npl(External Node) = -1 1

Internal

1 0

Node

0 0 0 -1

0 -1 -1 -1 -1 0

-1 -1 -1 -1 External

Node

The number outside each node X is the npl(X)

Operations

• BuildHeap O(N)

• FindMin O(1)

• Merge O(log N)

• Insert O(log N)

• DeleteMin O(log N)

General Idea

• All insertions and merges are performed on the

rightmost path containing at most log2 (n + 1)

nodes

• Leftist Heap Property can be easily restored

Merge

• O(log N) time

• It is a fundamental operation

– Both Insert and DeleteMin are based on Merge

– Insert:

• The key to be inserted is a one-node heap

• Merge this one-node heap with the given min leftist heap

– DeleteMin

• Delete root, left and right child of root are two min leftist heaps

• Merge the two min leftist heaps

Merge Algorithm (Recursive)

Merge(H1, H2)

If both heaps are Leftist

If one heap is NULL then return the other

If data(H1) > data(H1) then swap H1 and H2

If leftChild(H1) is NULL then leftChild(H1) = H2

Otherwise,

Recursively Merge rightChild(H1) and H2

If Leftist Heap Property is violated i.e

If npl( leftChild(H1) ) < npl( rightChild(H1) ) then swap children of

H1

npl(H1) = npl(rightChild(H1)) + 1

Merge H1 & H2

H1 H2

2 2

2 3

1 1 1 1

6 9 5 8

0 0 0 0 0 0 0 0

7 13 17 37 15 11 19 23

0 0 0

41 29 26

Merge H1 & H2

H1

H1 H2

H2

22 2

Both H1 and H2 are not NULL

2 3

11 11 1 1

6 9 5 8

00 00 00 00 0 0 0 0

7 13 17 37 15 11 19 23

00 0 0

41 29 26

Merge H1 & H2

H1 H2

22 2

2 H1

3

1 1 1 1

6 9 5 8

00 0 00 00 0 0 0 0

7 13 17 37 15 11 19 23

00 0 0

41 29 26

H1 now points to its rightChild

Merge H1 & H2

H2

2 2

Both H1 and H2 are not NULL

2 3

H1

1 1 1 1

6 9 5 8

0 0 0 0 0 0 0 0

7 13 17 37 15 11 19 23

0 0 0

41 29 26

swap(H1, H2)

Now, root(H1) = '3' & root(H2) = '9'

Merge H1 & H2

H2

2 1

2 9

H1

0 0

1 22

6 3 17 37

0

0 0 1 1

1 1 41

7 13 5 8

5 8

0 0 0 0

0 0 0 0

15 11 19 23

15 11 19 23

0 0

0 0

29 26

29 26

Resizing H1

Merge H1 & H2

H2

2 1

2 9

H1

0 0

1 2

6 3 17 37

0

0 0 1 1

7 13 5 8 41

0 0 0 0

15 11 19 23

0 0

29 26

H1 now points to its rightChild

Merge H1 & H2

H2

2 1

Both H1 and H2 are not NULL

2 9

0 0

1 2

6 3 H1 17 37

0

0 0 1 1

7 13 5 8 41

0 0 0 0

15 11 19 23

0 0

29 26

Merge H1 & H2

H2

2 1

2 9

0 0

1 2

6 3 H1 17 37

0

0 0 1 1

7 13 5 8 41

0 0 0 0

15 11 19 23

0 0

29 26

H1 now points to its rightChild

Merge H1 & H2

H2

2 1

Both H1 and H2 are not NULL

2 9 0 091H2

17 37410

0 0

1 2

6 3 17 37

0

0 0 1 1

7 13 5 8 41

H1

0 0 0 0

15 11 19 23

0 0

29 26

swap(H1, H2)

Now, root(H1) = '9' & root(H2) = '23'

Merge H1 & H2

H2

2 0

2 23 0 091H2

17 37410

0

1 2

6 3 26

0 0 1 1

7 13 5 8 H1

0 0 0 1

15 11 19 9

0 0 0 0

2929 17 37

0

41

Resizing H1

Merge H1 & H2

H2

2 0

2 23 0 091H2

17 37410

0

1 2

6 3 26

0 0 1 1

7 13 5 8 H1

0 0 0 1

15 11 19 9

0 0 0

29 17 37

0

41

H1 now points to its rightChild

Merge H1 & H2

H2

2 0

Both H1 and H2 are not NULL

2 23 0 091H2

17 37410

0

1 2

6 3 26

0 0 1 1

7 13 5 8

0 0 0 1

15 11 19 9 H1

0 0 0

29 17 37

0

41

swap(H1, H2)

Now, root(H1) = '23' & root(H2) = '37'

Merge H1 & H2

H2

2 0

2 37 0 091H2

17 37410

0

1 2

6 3 41

0 0 1 1

7 13 5 8

0 0 0 1

15 11 19 9 H1

0 0 0

29 17 23

0

26

NULL

Since, leftChild(H1) ≠ NULL

H1 now points to its rightChild — NULL

Merge H1 & H2

H2

2 0

H1 is NULL

2 37

0

1 2

6 3 41

0 0 1 1

7 13 5 8

0 0 0 1

15 11 19 9

0 0 0

29 17 23 H1

0

26

NULL

Merge (H1, H2)

swap(H1, H2)

Now, root(H1) = '37' & root(H2) = 'NULL'

Merge H1 & H2

H2

2

H2 is NULL

2

NULL

1 2

6 3

0 0 1 1

7 13 5 8 Adjust Null Path Lengths

0 0 0 1 from the Last Node

15 11 19 9 on the Rightmost Path

0 0 0 to the Root

29 17 23 H1

0 0

26 37

0

41

NULL

Merge H1 & H2

Leftist Heap Property NOT Violated

2

2

1 2

6 3

0 0 1 1

7 13 5 8 Adjust Null

H1Path Lengths

points to '37'

0 0 0 1 from the Last Node

15 11 19 9 on the Rightmost Path

0 0 0 to the Root

29 17 23 H1

0 00

26 37

00

41

NULL npl (NULL) = -1

leftChild(H1)→npl ≥ rightChild(H1)→npl — 0 ≥ -1

H1→npl = rightChild(H1)→npl + 1 = '0'

Merge H1 & H2

Leftist Heap Property NOT Violated

2

2

1 2

6 3

0 0 1 1

7 13 5 8

H1 moves up to '23'

0 0 0 1

15 11 19 9

0 0 10*

0

29 17 23 H1

0 0

26 37

0

41

NULL npl (NULL) = -1

leftChild(H1)→npl ≥ rightChild(H1)→npl — 0 ≥ 0

H1→npl = rightChild(H1)→npl + 1 = '1'

Merge H1 & H2

Leftist Heap Property Violated

2

swap( leftChild(H1), rightChild(H1) )

2

1 2

6 3

0 0 1 1

7 13 5 8

H1 moves up to '9'

0 0 0 1*

1

15 11 19 9 H1

0 0 11

29 17 23

0 0

26 37

0

41

leftChild(H1)→npl ≥ rightChild(H1)→npl — 0 ≤ 1

Merge H1 & H2

Leftist Heap Property Violated

2

swap( leftChild(H1), rightChild(H1) )

2

1 2

6 3

0 0 1 1

7 13 5 8 H1

H1 moves up to '9'

0 0 0 11*

15 11 19 9

0 0 1

29 17 23

0 0

26 37

0

41

leftChild(H1)→npl ≥ rightChild(H1)→npl — 0 ≤ 1

H1→npl = rightChild(H1)→npl + 1 = '1'

Merge H1 & H2

Leftist Heap Property Violated

2

swap( leftChild(H1), rightChild(H1) )

2

1 2

6 3

0 0 1 11*

1

7 13 5 8 H1

H1 moves up to '8'

0 0 00 11

15 11 19 9

0 0 11 0

0

2929 23 17

17

00 00

37

26 37

26

00

41

41

leftChild(H1)→npl ≥ rightChild(H1)→npl — 0 ≤ 1

H1→npl = rightChild(H1)→npl + 1 = '1'

Merge H1 & H2

Leftist Heap Property NOT Violated

2

2

1 2

6 3 H1

0 0 1 11

7 13 5 8

0 0 0

H1 moves up to '3'

1

0

15 11 9 19

1 0 0

23 17 29

0 0

26 37

0

41

leftChild(H1)→npl ≥ rightChild(H1)→npl — 1 ≥ 1

H1→npl = rightChild(H1)→npl + 1 = '2'

Merge H1 & H2

Leftist Heap Property Violated

2*

2

2

swap( leftChild(H1), rightChild(H1) )

2 H1

1 2

6 3

0 0 1 1

7 13 5 8

0 0 0

H1 moves up to '2'

0

15 11 9 19

1 0 0

23 17 29

0 0

26 37

0

41

leftChild(H1)→npl ≥ rightChild(H1)→npl — 1 ≤ 2

H1→npl = rightChild(H1)→npl + 1 = '2'

Merge H1 & H2 H1

Root

22

2

2 1

3 6

1 1 0 0

5 8 7 13

H1 is returned

0 0 0 0

Root pointer now points to H1

15 11 9 19

1 0 0

23 17 29

0 0

26 37

0

41

Merge Algorithm (Iterative)

Merge(H1, H2)

Sort nodes on rightmost paths of H1 and H2 in ascending order

(leftChild of each node remains)

A new tree H is created by merging the sorted nodes

∀ nodes X Є rightmost path of H from leaf to the root

If Leftist Heap Property is violated i.e

If npl( leftChild(X) ) < npl( rightChild(X) ) then swap children of X

npl(X) = npl(rightChild(X) + 1

Time Complexity of Merge

• O(log n)

Insert

• O(log N) time

Existing min leftist heap — H1

The key to be inserted is a one-node heap — H2

Merge this one-node heap H1 with the given min

leftist heap H2

Insert 3

H1 H2

2 0

2 3

1 1

6 9

0 0 0 0

7 13 17 37

0

41

H1 — existing Heap

H2 — one-node heap containing node to be inserted

Both H1 and H2 are Min Leftist Heaps

Insert 3

H1

H1 H2

22

Both H1 and H2 are not NULL 0

2 3

11 11

6 9

00 00 00 00

7 13 17 37

00

41

Insert 3

H1

H2

2 0

2 3

H1

1 1

6 9

0 0 0 0

7 13 17 37

0

41

H1 now points to its rightChild

Insert 3

H2

2

Both H1 and H2 are not NULL 0

2 3

H1

1 1

6 9

0 0 0 0

7 13 17 37

0

41

swap(H1, H2)

Now, root(H1) = '3' & root(H2) = '9'

Insert 3

H2

22 1

2 9

H1

11 00 0 0

6 33 17 37

00 00 1 0

7 13 9

NULL 41

0 0

17 37

0

41

leftChild(H1) = H2

Insert 3

H2

2

H2 is NULL

Adjust Null Path Lengths

2

H1

from the last node NULL

1 0

on the Rightmost Path

6 3

to the Root

0 0 1

7 13 9

0 0

17 37

0

41

Insert 3

2

Adjust Null Path Lengths 2 H1 points to '3'

H1

from the last node

1 0

on the Rightmost Path

6 3

to the Root

0 0 1

7 13 9 NULL npl (NULL) = -1

0 0

17 37

Leftist Heap Property NOT Violated

0

41

leftChild(H1)→npl ≥ rightChild(H1)→npl — 1 ≥ -1

H1→npl = rightChild(H1)→npl + 1 = '0'

Insert 3

12*

2

2 H1 H1 moves up to '2'

1 0

6 3

0 0 1

7 13 9 NULL npl (NULL) = -1

0 0

17 37

Leftist Heap Property NOT Violated

0

41

leftChild(H1)→npl ≥ rightChild(H1)→npl — 1 ≥ 0

H1→npl = rightChild(H1)→npl + 1 = '1'

Insert 3

Root H1

11

2 H1 is returned

1 0 Root pointer now points to H1

6 3

0 0 1

7 13 9

0 0

17 37

0

41

Time Complexity of Insert

• O(log n)

• Merge — O(log n)

– As only shortest path is traversed

DeleteMin

• O(log N) time

Delete root — (minimum value is in root)

Left and right children of root are two min

leftist heaps — H1 and H2 respectively

Merge the two min leftist heaps H1 and H2

DeleteMin

Root

2

2

1 1

6 9

0 0 0 0

7 13 17 37

0

41

DeleteMin

oldRoot

Root

22

H1

22 H2

1 1

6 9

0 0 0 0

7 13 17 37

0

41

H1 = root→leftChild

H2 = root→rightChild

DeleteMin

oldRoot

H1

2

H2

1 1

6 Both H1 and H2 are not NULL 9

0 0 0 0

7 13 17 37

0

41

DeleteMin

oldRoot

H1

2

H2

1 1

6 H1 9

0 0 0 0

7 13 17 37

0

41

H1 now points to its rightChild

DeleteMin

oldRoot

2

2

H2

1 1

6 Both H1 and H2 are not NULL 9

H1

0 0 0 0

7 13 17 37

0

41

swap(H1, H2)

Now, root(H1) = '3' & root(H2) = '9'

DeleteMin

oldRoot

2

2

H2

1 0

6 H1 13

0 1

7 9

0 0

17 37

0

41

H1 now points to its rightChild

DeleteMin

oldRoot

2

2

H2

1 0

6 Both H1 and H2 are not NULL 13

0 1

7 9 H1

0 0

17 37

0

41

swap(H1, H2)

Now, root(H1) = '37' & root(H2) = '13'

DeleteMin

oldRoot

2

2

H2

1 0

6 37

0 1 0

7 9 H1 41

0 0

17 13

0

37

NULL

0

41

leftChild(H1) = H2

DeleteMin

oldRoot

2

Adjust Null Path Lengths 2

H2

from the last node

1

on the Rightmost Path H2 is NULL

6

to the Root NULL

0 1

7 9 H1

0 0

17 13

0

37

0

41

DeleteMin

oldRoot

2

Adjust Null Path Lengths 2 H1 points to '13'

from the last node

1

on the Rightmost Path

6

to the Root

0 1

7 9 H1

0 0

17 13

Leftist Heap Property NOT Violated

0

37 NULL npl (NULL) = -1

0

41

leftChild(H1)→npl ≥ rightChild(H1)→npl — 0 ≥ -1

H1→npl = rightChild(H1)→npl + 1 = '0'

DeleteMin

oldRoot

2

2 H1 moves up to '9'

1

6

0 1

7 9 H1

0 0

17 13

Leftist Heap Property NOT Violated

0

37 NULL npl (NULL) = -1

0

41

leftChild(H1)→npl ≥ rightChild(H1)→npl — 0 ≥ 0

H1→npl = rightChild(H1)→npl + 1 = '1'

DeleteMin

oldRoot

2

2 H1 H1 moves up to '6'

11*

1

6 H1

00 1

1

7 9

00 0

0

17 13

Leftist Heap Property Violated

0

swap( leftChild(H1), rightChild(H1) ) 0

37

00

41

leftChild(H1)→npl ≥ rightChild(H1)→npl — 0 ≤ 1

H1→npl = rightChild(H1)→npl + 1 = '1'

DeleteMin

oldRoot

2

2 H1

Root

11

6

1 0

9 7 H1 is returned

0 0 Root pointer now points to H1

17 13 Delete old value of Root

0

37

0

41

Time Complexity of DeleteMin

• O(log n)

• Initialize H1 with left child of root — O(1)

• Initialize H2 with right child of root — O(1)

• Merge — O(log n)

– As only shortest path is traversed

Brute Force BuildHeap

• O(N logN) time

Based on Insert

Given N elements, create N one-node min leftist heaps

and insert them into a Queue, Q

Size of Q, |Q| = N

Root = Remove first min leftist heap from queue

while( |Q| > 0 )

Remove one min leftist heaps from queue — H

Insert( H )

Brute Force BuildHeap

0 0 0 0 0 0 0

7 9 37 41 2 6 13

7, 9, 37, 41, 2, 6, 13

Create 7 one-node min leftist heaps and

insert them in a queue — |Q| = 7

Brute Force BuildHeap

Root H

000 00 0 0 0 0 0

77 99 37 41 2 6 13

00

99

Root = 7 |Q| = 6

H=9 |Q| = 5

Insert( H )

Brute Force BuildHeap

Root H

01 00 0 0 0 0

7 37

37 41 2 6 13

0 0

9 37

Root = 7 |Q| = 5

H = 37 |Q| = 4

Insert( H )

Brute Force BuildHeap

Root H

11 0 0 0 0

7 41 2 6 13

0 0

9 37

0

41

Root = 7 |Q| = 4

H = 41 |Q| = 3

Insert( H )

Brute Force BuildHeap

Root H

1

0 00 0 0

7

2 22 6 13

11

0 0

7

9 37

00 0

0

9 37

41

00

41

Root = 7 |Q| = 3

H=2 |Q| = 2

Insert( H )

Brute Force BuildHeap

Root H

011 00 0

22 66 13

111 00

77 6

000 000

99 37

37

000

41

41

Root = 7 |Q| = 2

H=6 |Q| = 1

Insert( H )

Brute Force BuildHeap

Root H

11 00

2 13

13

11 1 0 00

7 7 6 6

00 0 00 0 00

9 9 37 37 13

00 0

41 41

Root = 7 |Q| = 1

H = 13 |Q| = 0

Insert( H )

Time Complexity of

Brute Force BuildHeap

• O(N log N)

1 insert — O(log N)

N inserts — O(N log N)

Efficient BuildHeap

• O(N) time

Based on Merge

Given N elements, create N one-node min leftist heaps

and insert them into a Queue, Q

Size of Q, |Q| = N

while( |Q| > 1 )

Remove first two min leftist heaps from queue — H1 and H2

Merge H1 and H2

Insert merged min leftist heap into queue

Efficient BuildHeap

0 0 0 0 0 0 0

7 9 37 41 2 6 13

7, 9, 37, 41, 2, 6, 13

Create 7 one-node min leftist heaps and

insert them in a queue — |Q| = 7

Efficient BuildHeap

H1 H2

00 00 0 0 0 0 0 0

77 99 37 41 2 6 7 13

0 0

9 9

Remove and merge first two min leftist heaps from queue

H1 = 7 |Q| = 6

H2 = 9 |Q| = 5

H1 = Merge(H1, H2)

Insert H1 into queue |Q| = 6

Efficient BuildHeap

H1 H2

00 00 0 0 0 0 0

37

37 41

41 2 6 13 37 7

0 0 0

41 41 9

Remove and merge first two min leftist heaps from queue

H1 = 37 |Q| = 5

H2 = 41 |Q| = 4

H1 = Merge(H1, H2)

Insert H1 into queue |Q| = 5

Efficient BuildHeap

H1 H2

00 00 0 0 0 0

22 66 13 7 2 37

0 0 0 0

6 9 6 41

Remove and merge first two min leftist heaps from queue

H1 = 2 |Q| = 4

H2 = 6 |Q| = 3

H1 = Merge(H1, H2)

Insert H1 into queue |Q| = 4

Efficient BuildHeap

H1 H2

00

1 0 0 1 0

7

13

13 7 37 7 2

0 0 0 0 0 00

9 13 9 41 9 613

Remove and merge first two min leftist heaps from queue

H1 = 13 |Q| = 3

H2 = 7 |Q| = 2

H1 = Merge(H1, H2)

Insert H1 into queue |Q| = 3

Efficient BuildHeap

H1 H2

1

0 0 1 1

2

37 2 2 7

0 0 0 0 00 0

41

6 37 6 6 937 13

0 0

41 41

Remove and merge first two min leftist heaps from queue

H1 = 37 |Q| = 2

H2 = 2 |Q| = 1

H1 = Merge(H1, H2)

Insert H1 into queue |Q| = 2

Efficient BuildHeap

H1 H2

1 1 11

2

7 2 2

01 00 1 00 0 00

97 13

6 7 66 37

0 0 0 0 00

9 13 9 13 41

0 0

37 37

0 0

41 41

Remove and merge first two min leftist heaps from queue

H1 = 7 |Q| = 1

H2 = 2 |Q| = 0

H1 = Merge(H1, H2)

Insert H1 into queue |Q| = 1

Efficient BuildHeap

Root

1

2

1 0

7 6

0 0

9 13

0

37

0

41

Root = 2

Time Complexity of

Efficient BuildHeap

Assume min leftist heap contains N = 2k elements

N/2 1

N/4 2

N/8 3

׃

׃

N/2k = 1 k

Time Complexity of Efficient

BuildHeap

Total Time for BuildHeap

N N N N

= ( * 1) + ( * 2) + ( * 3) + + ( k * k)

2 4 8 2

1 1 1 1

= N( + + + k)

2 4 8 2

k

i

= N∑ i

i=1 2

∞

i

= N∑ i

i=1 2

= 3n for n ≥ 3

= Ο(N)

- Designing Classes and ProgramsUploaded byGobara Dhan
- DB Driven Vertical MenuUploaded byVikram Kohli
- PGF and tikZ manualUploaded bydrewmoore27j
- ee2209 viva questionsUploaded byAnirudhan Ravi
- Decision TreesUploaded bySrivastavaAmol
- Splay and Join OperationUploaded byDanh Nguyen
- Data StructureUploaded bymohit1485
- UNIT - IVUploaded byJit Agg
- Final ProposalUploaded byKayihura Marie Paule
- 5.printerscheduling.docUploaded bySuganya Periasamy
- Parse TreesUploaded byRaj Singh
- Incremental Induction of Decision TreesUploaded byarthured
- A Simple Fast Dominance AlgorithmUploaded byfoofoofoo52
- 15122 Final Exam SheetUploaded bybobtheblob94
- DS Viva QuestionsUploaded byDaniel Mariadass
- binary tree 2Uploaded bySiu Chung Mok
- An LP NLP based branch and bound algorithm for MINLP optimization.pdfUploaded byNuran Dursunoğlu
- heapsortxUploaded byneddafflore
- a3-sagivUploaded byHoc Nguyen Van
- dsa5Uploaded byBobin baby
- 2013certamen2_pautaUploaded byJorge Gutierrez
- Ankith Technical SeminarUploaded byAnkith Hegde
- Strictly Not a PrimeUploaded byAmit Singh
- Object Oriented Programming and Data Structures - Lecture Notes, Study Materials and Important questions answersUploaded byBrainKart Com
- DS CommonQuestions RemindersUploaded byDeepraj Baidya
- Value of Information in DMUploaded byvivekranjan125
- Cpds ObjectiveUploaded bygdeepthi
- feb2011-otn-harvest-328207Uploaded byNikhil Gokhale
- 1Uploaded byFahmi
- Solving the Euclidean Bounded Diameter Minimum Spanning Tree Problem by Clustering-Based (Meta-)HeuristicsUploaded byGaKeGui

- Probability Random Variables Stochastic ProcessUploaded byapi-3801329
- Q6 SolutionUploaded byapi-3801329
- Q5 SolutionUploaded byapi-3801329
- Q4 SolutionUploaded byapi-3801329
- Q3 SolutionUploaded byapi-3801329
- Q1 SolutionUploaded byapi-3801329
- Q2 SolutionUploaded byapi-3801329
- Exercise Solution) 3Uploaded byapi-3801329
- Exercise Solution) 2Uploaded byapi-3801329
- Exercise Solution) 1Uploaded byapi-3801329
- Pentium 4 Pipe LiningUploaded byapi-3801329
- Power Pc (G5)Uploaded byapi-3801329
- Pentium 4 StructureUploaded byapi-3801329
- Memory StructureUploaded byapi-3801329
- Computer Structure and ComponentsUploaded byapi-3801329
- Multiple Interrupts and Buses StructureUploaded byapi-3801329
- History of ComputersUploaded byapi-3801329
- Weight-Biased Leftist Heaps Advanced)Uploaded byapi-3801329
- Skew Heaps Advanced)Uploaded byapi-3801329
- Binomial & Fibonacci Heap Advanced)Uploaded byapi-3801329
- Red-Black Trees Advanced)Uploaded byapi-3801329
- B Trees Advanced)Uploaded byapi-3801329
- Splay Trees Advanced)Uploaded byapi-3801329
- ProbingUploaded byapi-3801329
- 2 3 TreesUploaded byapi-3801329
- Graph Search Methods ExamplesUploaded byapi-3801329
- GraphsUploaded byapi-3801329
- HashingUploaded byapi-3801329
- Linked ListsUploaded byapi-3801329

- Computers Can Store and Process Vast Amounts of DataUploaded byRameswar Aakula
- Data Structure and Algorithms(2&16)1Uploaded bySriram Srinivasan
- DS Lab pgm-M.EUploaded bykeerthi_sm18
- DataStructure GATEUploaded byuanuli
- Lecture 14 Binomial HeapsUploaded byraul
- Answer Homework7 Heapsort (1)Uploaded byVamshi Kolan
- Map Navigation System Based on Optimal Dijkstra AlgorithmUploaded byJuan Manuel Antón Bernal
- 297752504-Data-Structures-2-Marks-and-16-Marks-Question-Bank-With-Answers.txtUploaded byrcpasc
- Heap TreesUploaded byPratik Chheda
- a6aheapsUploaded bymtg.gorczyca
- CS-GATE-2019-shift-3-MEASY.pdfUploaded byshubham
- Advance Data StructuresUploaded bykamsi
- Chapter 8 - HeapsUploaded byNguyễn Thanh Linh
- exam2s13keyUploaded byZahraa Tishreen
- HeapSortUploaded byZaigham Abbas
- AdaUploaded bysagarkondamudi
- ADS R10 LAB MANUAL IN CUploaded byCorey Lewis
- 1109.2378.pdfUploaded byAndika Saputra
- CP7111-Advanced Data Structures Laboratory ManualUploaded byHussain Bibi
- Gate Book- CseUploaded byadityabaid4
- Doubly ended priority queuesUploaded bymanishbhardwaj8131
- Advanced Data StructuresUploaded byToaster97
- GATE Data Structure & Algorithm BookUploaded byMims12
- Leftist and SkewUploaded byRam Kumar
- A Lot of Solved MCQs CS301 for Final 2010 by RisingpakistanUploaded byrisingpakistan
- Heap SortUploaded byaggarwalmegha
- unit-IV -Uploaded bymayank yadav
- Assignment IC Binary TreesUploaded byAditya Pawar
- 05 Priority QueueUploaded byThobius Joseph
- CS301 Final Term MAGA File.. All Paperz Are in 1 File.Uploaded byanumnasik