Scribd
Upload
6 views

Advanced Data Structurer

Advanced Data Structurer

Uploaded by

Prokash Barman
Copyright
© © All Rights Reserved
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
6 views

Advanced Data Structurer

Advanced Data Structurer

Uploaded by

Prokash Barman
Copyright
© © All Rights Reserved
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
You are on page 1/ 35

Advanced Data

Structures

 Bellman-Ford Algorithm, Segment Tree,


Red-Black Tree, Expression Tree, Binary
Indexed Tree, B-Tree
-Prokash Barman
Bellman-Ford Algorithm

Segment Tree

Red-Black Tree

Expression Tree

Binary Indexed Tree (Fenwick Tree)

B-Tree
Table of Conclusion
Contents Q&A

References
Bellman-Ford
Algorithm

o Purpose: Find shortest


paths in graphs with
negative edge weights
o Key features: Handles
negative weights,
detects negative cycles
Bellman-Ford
Algorithm -
Key Steps
o Initialization:
 Set distance to source
vertex to 0
 Set distances to all other
vertices to infinity
 Set predecessors to null
Bellman-Ford Algorithm - Relaxation

Repeat for |V| - 1 iterations:


For each edge (u, v) with weight w:
If d[u] + w < d[v], update d[v] to d[u] + w and
set π[v] to u
Bellman-Ford
Algorithm - Negative
Cycle Detection

o Negative Cycle
Detection:
 Perform one more pass:
 For each edge (u, v) with
weight w:
 If d[u] + w < d[v], a
negative cycle exists
Bellman-Ford Algorithm - Pseudocode

function BellmanFord(G, s):


# G is the graph and s is the source vertex

# Step 1: Initialization
for each vertex v in G:
if v is s:
d[v] = 0
else:
d[v] = ∞
π[v] = null
Bellman-Ford Algorithm - Pseudocode
# Step 2: Relaxation
for i from 1 to |V| - 1:
for each edge (u, v) in G:
if d[u] + w(u, v) < d[v]:
d[v] = d[u] + w(u, v)
π[v] = u

# Step 3: Negative Cycle Detection


for each edge (u, v) in G:
if d[u] + w(u, v) < d[v]:
return "Negative cycle detected"
return d, π
Time
Complexity: O(VE)

Bellman-Ford Space
Algorithm - Complexity: O(V)
Complexity
Segment Tree

o Purpose: Efficient range


queries and updates
over an array
o Key features: Each node
represents an interval
Segment Tree -
Key Concepts

 Root represents the entire


array
 Leaves represent single
elements
 Intermediate nodes
represent the union of
their children's intervals
Segment Tree -
Operations
o Build: Construct the segment tree
from the input array
o Query: Retrieve information from a
range of indices
o Update: Modify a single element or a
range of elements
function buildSegmentTree(arr):

# Construct the segment tree from the


array

function querySegmentTree(node, left,


right, queryLeft, queryRight):

# Perform a range query


Segment
Tree - function updateSegmentTree(node, index,
value):
Pseudocode
# Update the value at a specific index
Build: O(n)

Query: O(log n)
Segment
Tree -
Complexity
Update: O(log n)
Red-Black
Tree
o Purpose: Self-balancing
binary search tree
o Key features: Maintains
balance through coloring
nodes
Every node is either red or black

The root is always black

Red-Black If a node is red, its children must be


Tree - black

Properties Every path from a node to its


descendants' leaves contains the same
number of black nodes
Insert: Add a new node
while maintaining red-black
properties

Delete: Remove a node


while maintaining red-black
Red-Black properties
Tree -
Operations Search: Find a node with a
specific key
Red-Black Tree - Pseudocode

function insertRedBlackTree(node, key):

# Insert a new node

function deleteRedBlackTree(node, key):

# Delete a node

function searchRedBlackTree(node, key):

# Search for a node


Insert: O(log n)

Delete: O(log n)
Red-Black
Tree -
Search: O(log n)
Complexity
Expression
Tree
o Purpose: Represent and
evaluate arithmetic
expressions
o Key features: Leaves
represent operands, internal
nodes represent operators
Expression
Tree - Key
Concepts

LEAVES: INTERNAL NODES:


OPERANDS OPERATORS
Expression
Tree -
Operations

BUILD: CONSTRUCT THE EVALUATE: COMPUTE THE


EXPRESSION TREE FROM AN VALUE OF THE EXPRESSION
EXPRESSION
Expression Tree - Pseudocode

• function buildExpressionTree(expression):
• # Construct the expression tree
•
• function evaluateExpressionTree(node):
• # Evaluate the expression
Build: O(n)

Expression Evaluate: O(n)


Tree -
Complexity
Red-Black Tree:
Efficient search, insert,
and delete operations
Expressio
n Tree vs. Expression Tree:
Red-Black Represent and evaluate
Tree arithmetic expressions
Binary Indexed
Tree (Fenwick Tree)

o Purpose: Efficient
cumulative frequency
counting and updating
o Key features: Each
element stores
cumulative frequency of
a range
Binary Indexed
Tree - Key
Concepts

o Structure:
 Represented as an
array
 Each element stores
cumulative frequency
Build: Construct the binary
indexed tree from an array

Query: Retrieve the


Binary cumulative frequency up to
Indexed a given index
Tree -
Operations Update: Modify the
frequency of an element
Binary Indexed Tree - Pseudocod
Binary Indexed Tree - Pseudocode
• function buildBinaryIndexedTree(arr):

• # Construct the binary indexed tree

• function queryBinaryIndexedTree(index):

• # Retrieve the cumulative frequency

• function updateBinaryIndexedTree(index, value):

• # Update the frequency of an element


Build: O(n)

Binary Query: O(log n)


Indexed
Tree -
Complexity
Update: O(log n)
B-Tree
01 02
Purpose: Self- Key features:
balancing tree Efficient
for sorted search, insert,
data and delete
operations
o Structure:

B-Tree -  Each node can have multiple


children
Key  Each node (except root) must have
at least m/2 children
Concepts  The root must have at least 2
children
Search: Find a key
B-Tree - in the B-tree
Operations
Insert: Add a new
key to the B-tree

Delete: Remove a
key from the B-tree
: B-Tree - Pseudocode

• function searchBtree(node, key):

• # Search for a key

• function insertBtree(node, key):

• # Insert a new key

• function deleteBtree(node, key):

• # Delete a key
B-Tree -
Complexity SEARCH: O(LOG INSERT: O(LOG
N) N)

DELETE: O(LOG
N)

You might also like