Scribd
Upload
3 views8 pages

Data Structure

The document provides a comprehensive overview of various data structures and algorithms in Java, including graph representations using adjacency matrix and list, depth-first and breadth-first traversals, minimum spanning tree algorithms (Kruskal's and Prim's), Dijkstra's algorithm for shortest paths, and hash table collision handling techniques. It also includes practical examples using Java's Collection Framework, such as ArrayList, HashMap, and PriorityQueue, along with coding examples for employee management, finding largest elements, and removing duplicates. The document serves as a resource for understanding and implementing these concepts in Java programming.

Uploaded by

1012412073
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
3 views8 pages

Data Structure

The document provides a comprehensive overview of various data structures and algorithms in Java, including graph representations using adjacency matrix and list, depth-first and breadth-first traversals, minimum spanning tree algorithms (Kruskal's and Prim's), Dijkstra's algorithm for shortest paths, and hash table collision handling techniques. It also includes practical examples using Java's Collection Framework, such as ArrayList, HashMap, and PriorityQueue, along with coding examples for employee management, finding largest elements, and removing duplicates. The document serves as a resource for understanding and implementing these concepts in Java programming.

Uploaded by

1012412073
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 8

✅ Graph Representations and Traversals

1. Graph using Adjacency Matrix

public class GraphMatrix {


int[][] adjMatrix;
int vertices;

GraphMatrix(int v) {
vertices = v;
adjMatrix = new int[v][v];
}

void addEdge(int src, int dest) {


adjMatrix[src][dest] = 1;
adjMatrix[dest][src] = 1; // undirected graph
}

void display() {
for (int i = 0; i < vertices; i++) {
for (int j = 0; j < vertices; j++)
System.out.print(adjMatrix[i][j] + " ");
System.out.println();
}
}

public static void main(String[] args) {


GraphMatrix g = new GraphMatrix(4);
g.addEdge(0, 1);
g.addEdge(0, 2);
g.addEdge(1, 2);
g.addEdge(2, 3);
g.display();
}
}

2. Graph using Adjacency List

import java.util.*;

class GraphList {
List<List<Integer>> adjList;

GraphList(int v) {
adjList = new ArrayList<>();
for (int i = 0; i < v; i++)
adjList.add(new ArrayList<>());
}

void addEdge(int src, int dest) {


adjList.get(src).add(dest);
adjList.get(dest).add(src); // undirected
}

void display() {
for (int i = 0; i < adjList.size(); i++)
System.out.println(i + ": " + adjList.get(i));
}

public static void main(String[] args) {


GraphList g = new GraphList(4);
g.addEdge(0, 1);
g.addEdge(0, 2);
g.addEdge(1, 2);
g.addEdge(2, 3);
g.display();
}
}

3. DFS and BFS Traversal

class GraphTraversal {
int V;
List<List<Integer>> adj;

GraphTraversal(int v) {
V = v;
adj = new ArrayList<>();
for (int i = 0; i < v; i++)
adj.add(new ArrayList<>());
}

void addEdge(int u, int v) {


adj.get(u).add(v);
adj.get(v).add(u);
}

void DFS(int v, boolean[] visited) {


visited[v] = true;
System.out.print(v + " ");
for (int u : adj.get(v))
if (!visited[u])
DFS(u, visited);
}

void BFS(int start) {


boolean[] visited = new boolean[V];
Queue<Integer> q = new LinkedList<>();
visited[start] = true;
q.add(start);

while (!q.isEmpty()) {
int v = q.poll();
System.out.print(v + " ");
for (int u : adj.get(v)) {
if (!visited[u]) {
visited[u] = true;
q.add(u);
}
}
}
}
public static void main(String[] args) {
GraphTraversal g = new GraphTraversal(5);
g.addEdge(0, 1);
g.addEdge(0, 2);
g.addEdge(1, 3);
g.addEdge(2, 4);
System.out.print("DFS: ");
g.DFS(0, new boolean[5]);
System.out.print("\nBFS: ");
g.BFS(0);
}
}

✅ Minimum Spanning Tree and Shortest Path (Numericals)

1. Kruskal’s Algorithm (numerical-style logic)

// Pseudocode-like Kruskal logic for numerical example:


// Edges: (0-1, 1), (1-2, 2), (0-2, 3)
// Sort edges by weight → pick smallest that don’t form cycle.

Total MST cost = 1 (0-1) + 2 (1-2) = 3

2. Prim’s Algorithm (small numerical)

// Starting from node 0


// Edges: (0-1, 2), (0-2, 3), (1-2, 1)
// MST = 0→1 (2), 1→2 (1) → Total cost = 3

3. Dijkstra’s Algorithm (Numerical)

// Graph:
// 0->1:4, 0->2:1, 2->1:2, 1->3:1
// From 0: shortest to 3 = 0→2→1→3 = 1+2+1 = 4

✅ Hash Table and Collision Handling

1. Linear Probing (Code + Numerical)

class LinearProbing {
int size = 10;
int[] table = new int[size];

LinearProbing() {
Arrays.fill(table, -1);
}
void insert(int key) {
int idx = key % size;
while (table[idx] != -1) idx = (idx + 1) % size;
table[idx] = key;
}
void display() {
System.out.println(Arrays.toString(table));
}
public static void main(String[] args) {
LinearProbing ht = new LinearProbing();
int[] keys = {23, 43, 13, 27}; // all %10
for (int key : keys) ht.insert(key);
ht.display();
}
}

2. Numerical:

Table size = 10, insert 27, 37, 47 using:

Linear probing: All go to index 7 → 8 → 9

Quadratic probing: 7, 8, 11 → next i² offset

Double hashing: h2(key) = 7 - key%7 → use that as step size

✅ Java Collection Framework Examples

1. ArrayList

import java.util.*;

public class ArrayListExample {


public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
for (String s : list)
System.out.println(s);
}
}

2. HashMap

import java.util.*;

public class HashMapExample {


public static void main(String[] args) {
HashMap<Integer, String> map = new HashMap<>();
map.put(1, "Java");
map.put(2, "Python");
System.out.println(map.get(2));
}
}

3. PriorityQueue

import java.util.*;

public class PriorityQueueExample {


public static void main(String[] args) {
PriorityQueue<Integer> pq = new PriorityQueue<>();
pq.add(30);
pq.add(10);
pq.add(20);
while (!pq.isEmpty())
System.out.print(pq.poll() + " ");
}
}

CodingPart:
1. HashMap: Employees and Departments

import java.util.*;

public class EmployeeDepartmentMap {


HashMap<String, String> empDept = new HashMap<>();
// Add a new employee
public void addEmployee(String name, String department) {
empDept.put(name, department);
}
// List employees by department
public void listEmployeesByDepartment(String department) {
System.out.println("Employees in " + department + ":");
for (Map.Entry<String, String> entry : empDept.entrySet()) {
if (entry.getValue().equals(department)) {
System.out.println(entry.getKey());
}
}
}
public static void main(String[] args) {
EmployeeDepartmentMap ed = new EmployeeDepartmentMap();
ed.addEmployee("Alice", "HR");
ed.addEmployee("Bob", "IT");
ed.addEmployee("Charlie", "IT");

ed.listEmployeesByDepartment("IT");
}
}

2. PriorityQueue: Find K Largest Elements

import java.util.*;

public class KLargestElements {


public static List<Integer> findKLargest(int[] arr, int k) {
PriorityQueue<Integer> pq = new PriorityQueue<>(); // Min heap

for (int num : arr) {


pq.offer(num);
if (pq.size() > k) {
pq.poll();
}
}

return new ArrayList<>(pq);


}
public static void main(String[] args) {
int[] nums = {10, 50, 30, 20, 70, 80};
int k = 3;
System.out.println("Top " + k + " largest elements: " + findKLargest(nums, k));
}
}

3. HashMap + PriorityQueue: K Most Frequent Elements

import java.util.*;
public class KMostFrequent {
public static List<Integer> topKFrequent(int[] nums, int k) {
Map<Integer, Integer> freqMap = new HashMap<>();

for (int num : nums) {


freqMap.put(num, freqMap.getOrDefault(num, 0) + 1);
}

PriorityQueue<Map.Entry<Integer, Integer>> pq =
new PriorityQueue<>((a, b) -> a.getValue() - b.getValue());

for (Map.Entry<Integer, Integer> entry : freqMap.entrySet()) {


pq.offer(entry);
if (pq.size() > k) {
pq.poll();
}
}
List<Integer> result = new ArrayList<>();
for (Map.Entry<Integer, Integer> entry : pq) {
result.add(entry.getKey());
}
return result;
}
public static void main(String[] args) {
int[] nums = {1, 1, 1, 2, 2, 3};
int k = 2;
System.out.println("Top " + k + " frequent elements: " + topKFrequent(nums,
k));
}
}

4. ArrayList: Student Marks

import java.util.*;

public class StudentMarks {


ArrayList<Integer> marks = new ArrayList<>();

// Add a mark
public void addMark(int mark) {
marks.add(mark);
}

// Delete a mark at index


public void deleteMark(int index) {
if (index >= 0 && index < marks.size()) {
marks.remove(index);
}
}
// Calculate average
public double averageMark() {
if (marks.isEmpty()) return 0;
int sum = 0;
for (int mark : marks) {
sum += mark;
}
return (double) sum / marks.size();
}

public static void main(String[] args) {


StudentMarks sm = new StudentMarks();
sm.addMark(80);
sm.addMark(90);
sm.addMark(70);
sm.deleteMark(1); // remove 90
System.out.println("Average = " + sm.averageMark());
}
}

5. Remove Duplicates from ArrayList

import java.util.*;

public class RemoveDuplicates {


public static List<Integer> removeDuplicates(List<Integer> list) {
Set<Integer> set = new LinkedHashSet<>(list);
return new ArrayList<>(set);
}

public static void main(String[] args) {


ArrayList<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 2, 3, 4, 4, 5));
System.out.println("Original: " + list);
System.out.println("Without duplicates: " + removeDuplicates(list));
}
}

You might also like

pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy