Fundamental Data Structures and Algorithms.pptx

DATA STRUCTURES AND
ALGORITHMS
by
Jenny Lyn D. Masgong

DATA STRUCTURE
• a way to organize and store data so that it can be accessed and
worked with efficiently
Types of Data
Structure
Primitive
Integer Float Character Boolean
Non-
primitive
Array Linked List Queue Trees

ARRAY
Definition
A collection of elements
identified by index or
key.
 Fixed in size and stores
elements of the same
type.
Features
Random access via
indices.
Fixed size (determined at
the time of creation).
 Can store primitive
data types or objects.
Operation
Access: O(1) time
complexity.
Insert/Remove: O(n) for
worst-case scenarios
(inserting/removing in
the middle or
beginning).
 Search: O(n) for
unsorted arrays; O(log
n) for sorted arrays
using binary search

EXAMPLE OF ARRAY DECLARATION
JAVA
int[] arr = {1, 2, 3, 4};

MORE ON ARRAY
PROS
• Fast access time using indices.
• Simple and efficient when the
number of elements is fixed.
CONS
• Fixed size (cannot resize
dynamically).
• Insertion and deletion can be slow if
not at the end.

LINKED LISTS
Definition
 a linear data structure
where elements (nodes) are
stored in objects, and each
node points to the next
node in the list
 types:
 Singly Linked List: Each
node points to the next.
 Doubly Linked List: Each
node points to both the
next and previous nodes.
 Circular Linked List: The
last node points to the
first node.
Features
Dynamic size (can grow or
shrink).
 Efficient insertions and
deletions.
Operation
Insert at beginning: O(1)
Insert at end: O(n) for singly
linked lists (O(1) for doubly
linked lists with tail pointer).
Delete: O(1) if node reference
is known, otherwise O(n) to
find the node.
 Search: O(n)

EXAMPLE OF SINGLY LINKED LIST IN
JAVA
class Node {
int data;
Node next;
Node(int data) {
this.data = data;
next = null;
}
}
class LinkedList {
Node head;
// Add element at the front
public void push(int new_data) {
Node new_node = new Node(new_data);
new_node.next = head;
head = new_node;
}
// Print the linked list
public void printList() {
Node temp = head;
while (temp != null) {
System.out.print(temp.data + "
");
temp = temp.next;
}
}
}
public class Main {
public static void main(String[] args)
{
LinkedList llist = new
LinkedList();
llist.push(10);
llist.push(20);
llist.push(30);
llist.printList(); // Output: 30 20
10
}

MORE ON LINKED LIST
PROS
• Dynamic size (can grow or shrink as
needed).
• Efficient insertions and deletions
from the beginning (or end if doubly
linked).
CONS
• Access time is slower (sequential
search).
• Extra space required for pointers.

STACKS
Definition
 linear data
structure that
follows the Last In,
First Out (LIFO)
principle.
 the last element
inserted is the first
one to be removed
Feature
Only the top
element is
accessible.
 Used for problems
like recursion,
undo operations,
and parsing
expressions.
Operation
Push: Add an element
to the top of the stack
(O(1)).
Pop: Remove the top
element (O(1)).
Peek: View the top
element without
removing it (O(1)).
 isEmpty: Check if the
stack is empty (O(1)).

EXAMPLE OF STACK IN JAVA
import java.util.Stack;
public class StackExample {
public static void main(String[] args) {
Stack<Integer> stack = new Stack<>();
stack.push(10);
stack.push(20);
stack.push(30);
System.out.println(stack.peek()); // Output: 30
System.out.println(stack.pop()); // Output: 30
System.out.println(stack.peek()); // Output: 20
}
}

MORE ON STACKS
PROS
• Efficient for problems requiring
reverse order (e.g., undo
operations).
• Fast access to the top element.
CONS
• Limited in functionality to LIFO
operations.
• Only allows access to the top
element (no direct access to other
elements).

QUEUE
Definition
 a collection that
follows the First In,
First Out (FIFO)
principle
 the first element
inserted is the first
one to be removed
Types
Simple Queue: Basic
FIFO behavior.
Circular Queue: The end
of the queue connects
back to the beginning.
 Priority Queue:
Elements are
dequeued based on
priority rather than the
order they were added.
Operation
Enqueue: Add an
element to the queue
(O(1)).
Dequeue: Remove the
front element (O(1)).
Peek: View the front
element without
removing it (O(1)).
 isEmpty: Check if the
queue is empty (O(1)).

EXAMPLE OF SIMPLE QUEUE IN JAVA
import java.util.LinkedList;
import java.util.Queue;
public class QueueExample {
Queue<Integer> queue = new LinkedList<>();
queue.offer(10);
queue.offer(20);
queue.offer(30);
System.out.println(queue.poll()); // Output: 10
System.out.println(queue.peek()); // Output:
20
}
}

MORE ON QUEUES
PROS
• Ideal for scheduling problems and
handling requests in order.
• Efficient enqueue and dequeue
operations.
CONS
• Limited to FIFO operations.
• Not efficient for random access or
deletions from arbitrary positions.

HASH MAP
Definition
• collection of key-value
pairs
• implemented using a
hash table.
Feature
• allows fast retrieval of
elements using a key
Operation
Put: Add or update a key-
value pair (O(1) on
average).
Get: Retrieve the value for
a given key (O(1) on
average).
Remove: Remove the key-
value pair (O(1) on
average).
• ContainsKey: Check if a
key exists (O(1) on
average).

EXAMPLE OF HASH MAP IN JAVA
import java.util.HashMap;
public class HashMapExample {
HashMap<String, Integer> map = new HashMap<>();
map.put("apple", 1);
map.put("banana", 2);
map.put("cherry", 3);
System.out.println(map.get("apple")); // Output: 1
System.out.println(map.containsKey("banana")); //
Output: true
}
}

MORE ON HASH MAPS
PROS
• Efficient for key-value mapping.
• Provides constant time access for
lookups, insertions, and deletions.
CONS
• Hash collisions can degrade
performance (though this is rare with
good hashing).
• Not ordered (if you need ordered
traversal, consider TreeMap).

TREES
Definition
• A hierarchical structure
made up of nodes
connected by edges.
Types
Binary Tree (Each node
has at most two children)
Binary Search Tree (BST)
(Left child < parent < right
child)
AVL Tree (Self-balancing
BST)
• Heap (Complete binary
tree, used for priority
queues)
Operation
Insert: Add a node (O(log
n) in a balanced tree).
Search: Find a node (O(log
n) in a balanced tree).
• Delete: Remove a node
(O(log n) in a balanced
tree).

MORE ON TREES
PROS
• Fast searching and insertion (O(log
n) for balanced trees).
• Hierarchical structure that can
represent hierarchical data.
CONS
• Can become unbalanced (leading to
O(n) complexity for skewed trees).
Use self-balancing trees (like AVL or
Red-Black Trees) to mitigate this.

ASSIGNMENT
To fully understand graphs as a data structure, you need to cover
the following topics systematically:
• Definition of a Graph
• Types of Graphs
• Pros and Cons of Graphs
• Write a Java implementation for basic graph operations such as
graph creation, graph traversal (DFS, BFS), and graph representation.

GRAPHS
Definition
• a non-linear data
structure that consists of
a collection of nodes
(vertices) and a
collection of edges
connecting pairs of
nodes
• used to represent
various real-world
problems like social
networks,
transportation
networks, and web
pages
Types
Directed Graph (Digraph):
edges have a direction,
i.e., they go from one
vertex to another.
• Undirected Graph:
edges have no direction;
they simply connect two
vertices.
Operation
Add Vertex
Add Edge
Remove Vertex
Remove Edge
BFS (Breadth-First Search
DFS (Depth-First Search
Shortest Path
Cycle Detection
• Graph Traversal

Fundamental Data Structures and Algorithms.pptx

More Related Content

Similar to Fundamental Data Structures and Algorithms.pptx (20)

Recently uploaded (20)

Fundamental Data Structures and Algorithms.pptx

Editor's Notes