Skip to content
Introduction and SetupChapter 1: The Array Abyss (Linear and Binary Search)Chapter 2: The Linked List Labyrinth (Singly Linked List)Chapter 3: The Stack Cliffs (Stack implementation and usage)Chapter 4: The Queue Quicksand (Queue and Circular Queue)Chapter 5: The Binary Tree of Truth (Binary Tree and traversals)Chapter 6: The Hashtable Hideout (Hashtable implementation)Final Boss: The Heap of Destiny (Min Heap implementation)Arrays and searching algorithmsLinked ListsStacksQueuesBinary TreesHashtablesHeapsLearn about various data structures and their operationsPractice implementing these structures in JavaUnderstand the applications and importance of each structureEnjoy a narrative that makes learning more engaging
Share
Explore
Indiana Jones and the Temple of Infinite Recursions: A Data Structures Adventure
I've created an engaging and educational Java programming lab that combines data structures with an Indiana Jones-themed adventure. This lab, titled "Indiana Jones and the Temple of Infinite Recursions: A Data Structures Adventure," guides students through implementing and using various data structures while following a narrative.
Here's an overview of the lab structure:
Each chapter introduces a new data structure or algorithm, provides a narrative context, and assigns coding tasks related to that structure. The lab covers:
The lab is designed to be both entertaining and educational, encouraging students to engage with the material through a story-driven approach. It provides code snippets and class structures to guide students, but leaves the core implementations for them to complete as exercises.
This approach allows students to:
Indiana Jones and the Template of Infinite Recursions:
A Data Structures Adventure
Introduction
Welcome, brave programmer! You are about to embark on a perilous journey as the legendary Programmer Indiana Jones. Your mission is to recover the Crystal Memory Key containing the chronicles of Early Earth Humans' formative encounters with Aliens. To succeed, you must battle various data structures using their core weaknesses. Are you ready for the challenge?
Setup
Create a new Java project and copy the following base code into your main class:
import java.util.*;
public class TempleOfInfiniteRecursions {
public static void main(String[] args) {
IndianaJones indy = new IndianaJones();
indy.startAdventure();
}
}
class IndianaJones {
private int health = 100;
private List<String> inventory = new ArrayList<>();
public void startAdventure() {
System.out.println("Indiana Jones enters the Temple of Infinite Recursions...");
// The adventure begins here!
}
// Add more methods here as you progress through the lab
}
Chapter 1: The Array Abyss
Indiana Jones enters a long corridor filled with ancient arrays. To proceed, he must navigate through them efficiently.
Task 1: Implement Linear Search
Create a method linearSearch that searches for a specific element in an array. Use this to find the exit!
public static int linearSearch(int[] arr, int target) {
// Implement linear search here
}
Task 2: Optimize with Binary Search
The arrays are now sorted. Implement a more efficient binarySearch method to quickly find the Crystal Memory Key fragment.
java
Copy
public static int binarySearch(int[] arr, int target) {
// Implement binary search here
}
Chapter 2: The Linked List Labyrinth
Indy encounters a maze-like structure representing a linked list. He must traverse it to proceed.
Task 3: Implement a Singly Linked List
Create a LinkedList class with methods to add nodes, delete nodes, and detect cycles (the labyrinth's traps!).
class Node {
int data;
Node next;
Node(int data) {
this.data = data;
this.next = null;
}
}
class LinkedList {
Node head;
void add(int data) {
// Implement add method
}
void delete(int data) {
// Implement delete method
}
boolean hasCycle() {
// Implement cycle detection (Floyd's cycle-finding algorithm)
}
}
Chapter 3: The Stack Cliffs
Indiana Jones must climb the Stack Cliffs by pushing and popping his way to the top.
Task 4: Implement a Stack
Create a Stack class using an array or linked list. Implement push, pop, and peek operations.
java
Copy
class Stack {
private List<Integer> data;
Stack() {
data = new ArrayList<>();
}
void push(int item) {
// Implement push
}
int pop() {
// Implement pop
}
int peek() {
// Implement peek
}
boolean isEmpty() {
// Implement isEmpty
}
}
Task 5: Balance the Parentheses
Use your Stack to check if a string of parentheses is balanced. This will unlock the door to the next chamber!
public static boolean isBalanced(String s) {
// Implement parentheses balancing using a stack
}
Chapter 4: The Queue Quicksand
Indy must navigate through quicksand by efficiently managing a queue of stepping stones.
Task 6: Implement a Queue
Create a Queue class with enqueue, dequeue, and peek operations.
java
Copy
class Queue {
private List<Integer> data;
Queue() {
data = new ArrayList<>();
}
void enqueue(int item) {
// Implement enqueue
}
int dequeue() {
// Implement dequeue
}
int peek() {
// Implement peek
}
boolean isEmpty() {
// Implement isEmpty
}
}
Task 7: Implement a Circular Queue
Optimize your queue to work circularly, allowing Indy to reuse stepping stones!
java
Copy
class CircularQueue {
private int[] data;
private int front, rear, size;
CircularQueue(int capacity) {
data = new int[capacity];
front = rear = -1;
size = 0;
}
void enqueue(int item) {
// Implement circular enqueue
}
int dequeue() {
// Implement circular dequeue
}
boolean isFull() {
// Implement isFull
}
boolean isEmpty() {
// Implement isEmpty
}
}
Chapter 5: The Binary Tree of Truth
Indiana Jones faces the Binary Tree of Truth, where he must traverse different paths to uncover the location of the Crystal Memory Key.
Task 8: Implement a Binary Tree
Create a BinaryTree class with methods for insertion and different types of traversals.
java
Copy
class TreeNode {
int data;
TreeNode left, right;
TreeNode(int data) {
Want to print your doc?
This is not the way.
This is not the way.
Try clicking the ··· in the right corner or using a keyboard shortcut (
CtrlP
) instead.