Left, Root, Right

In pre-order traversal, the order of visiting nodes is: Root, Left, Right.

Right, Root, Left

Left, Right, Root

class TreeNode { int value; }

class TreeNode { int value; TreeNode left; TreeNode right; TreeNode(int value) { this.value = value; } } class BinaryTree { TreeNode root; void insert(int value) { // insertion logic } void traverseInOrder(TreeNode node) { // in-order traversal logic } }

void traversePreOrder(TreeNode node) { }

class BinaryTree { void addNode(int value) { } }

Both trees are identical in structure and function.

A binary tree can only have two children, while a binary search tree can have more.

A binary search tree allows duplicate values, while a binary tree does not.

A binary tree has no specific ordering of nodes, while a binary search tree has an ordering property that facilitates efficient searching.

Insert the node at the root of the tree regardless of its value.

Delete the smallest node in the tree before inserting the new node.

Insert the node by traversing the tree based on comparisons until an empty position is found.

Always place the new node as the left child of the current node.

A balanced binary tree has no nodes.

A balanced binary tree must be a complete binary tree.

A balanced binary tree can have any height difference between subtrees.

A balanced binary tree has the property that the height of the left and right subtrees of any node differ by at most one.

A binary tree is balanced if the height difference between left and right subtrees is no more than 1 for all nodes.

A binary tree is balanced if it has a maximum depth of 3.

A binary tree is balanced if it is a complete binary tree.

A binary tree is balanced if all nodes have the same number of children.

n

n/2

log(n)

n^2

Use a recursive function to find the maximum height of left and right subtrees, returning max(leftHeight, rightHeight) + 1.

Use an iterative approach with a queue to find the height.

Calculate the height by summing the values of all nodes.

Count the number of nodes in the tree.

The process involves locating the node, handling three cases: leaf, one child, or two children.

Only removing nodes with two children

Deleting nodes without checking their children

Removing the root node only

The node is simply removed without any replacement.

The entire tree is deleted when a node is removed.

The node is replaced with a random node from the tree.

Replace the node with its in-order predecessor or successor.

Traverse the tree using a stack to visit nodes in reverse order.

Process all nodes in a single pass without using any data structure.

Visit each node recursively before its children to achieve level-order.

Use a queue to traverse the tree level by level, processing each node from left to right.

The root node can be any node in the tree.

The root node is the starting point of a binary tree and defines its structure.

The root node is only used for traversal purposes.

The root node is the last node in a binary tree.

The minimum value is found at the leftmost node of the binary search tree.

The minimum value is found at the rightmost node of the binary search tree.

The minimum value is the root node of the binary search tree.

You can find the minimum value by averaging all the node values.

A complete binary tree is a binary tree where all levels are filled equally.

A complete binary tree is a binary tree where all levels are fully filled except possibly the last, which is filled from left to right.

A complete binary tree is a tree with only one level.

A complete binary tree has all nodes with two children.

A full binary tree is a binary tree with at least one child for every node.

A full binary tree is a binary tree where every node has 1 or 3 children.

A full binary tree is a binary tree where every node has 0 or 2 children.

A full binary tree is a tree with only leaf nodes.

Use breadth-first traversal to collect values and sort them before rebuilding the tree.

Convert the binary tree to a linked list and then back to a binary search tree.

Perform pre-order traversal to collect values, then rebuild the tree using random values.

Perform in-order traversal to collect values, then rebuild the tree using sorted values.

Iterative traversal does not use any data structures.

Iterative traversal uses loops and explicit stacks; recursive traversal uses function calls and the call stack.

Recursive traversal uses loops and explicit stacks.

Iterative traversal is faster than recursive traversal.

Ignore duplicates and keep the first occurrence only.

Store duplicates in a linked list at each node.

Delete all duplicate values from the tree.

Replace duplicates with a special marker.

Pointers store data values in a binary tree.

Pointers are used only for memory allocation in trees.

Pointers connect nodes in a binary tree, enabling traversal and manipulation.

Pointers are not necessary for binary tree operations.

To enhance the performance of recursive functions.

The purpose of a base case in recursion is to provide a stopping condition that prevents infinite recursion.

To provide additional parameters for recursive calls.

To define the maximum depth of recursion allowed.

You can create a recursive function by defining multiple base cases without a recursive case.

A recursive function in Java should only call itself once without any updated arguments.

A recursive function in Java is designed by defining a base case and a recursive case that calls the function with updated arguments.

A recursive function in Java is designed by using only loops without any base case.

Graph traversal, node expansion, heuristic evaluation, pruning

Decision space, choice making, constraint checking, backtracking mechanism

Sorting, searching, data structure manipulation, algorithm efficiency

Dynamic programming, greedy choice, optimal substructure, solution space

The subset sum problem is about finding the maximum element in a set.

The subset sum problem is a method for calculating the average of a set of numbers.

The subset sum problem is a decision problem that asks if a subset of a given set of integers can sum to a specific target value.

The subset sum problem involves sorting a list of integers.

Recursion can only be used for sorting numbers.

Recursion simplifies the problem by eliminating numbers from consideration.

Recursion is not applicable to the subset sum problem.

Recursion can be used to explore all combinations of numbers to find a subset that sums to the target.

O(n * n!)

O(n^3)

O(n!)

O(n^2)

Sudoku puzzle solving.

Finding the shortest path in a graph with Dijkstra's algorithm.

Generating all possible combinations of a set of numbers.

Solving a simple arithmetic equation.

Implement a sorting algorithm for permutations

Create a static method without recursion

public class Permutations { public static void permute(char[] arr, int index) { if (index == arr.length) { System.out.println(new String(arr)); return; } for (int i = index; i < arr.length; i++) { swap(arr, index, i); permute(arr, index + 1); swap(arr, index, i); } } private static void swap(char[] arr, int i, int j) { char temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } public static void main(String[] args) { char[] arr = {'a', 'b', 'c'}; permute(arr, 0); } }

Use a loop to generate permutations

Recursion uses self-calls; iteration uses loops.

Recursion is faster than iteration.

Iteration uses self-calls; recursion uses loops.

Recursion is a type of iteration.

Traveling Salesman Problem

Graph Coloring Problem

Sudoku Solver

N-Queens problem

TreeSet

ArrayList or LinkedList

Queue

HashMap

stack.add(element);

stack.insert(element);

stack.pushTo(element);

stack.push(element);

delete()

shift()

remove()

pop()

A stack uses FIFO, while a queue uses LIFO.

A stack uses LIFO, while a queue uses FIFO.

Both stack and queue use LIFO.

A stack allows random access, while a queue does not.

O(n)

O(log n)

O(1)

O(n^2)

Task scheduling in operating systems

Undo functionality in text editors

Web browser history management.

File storage management

Implement the queue using an array instead of stacks.

Use three stacks to manage the queue operations.

Use two stacks: one for enqueueing and one for dequeueing. Transfer elements from the first stack to the second when needed.

Use a single stack for both enqueueing and dequeueing.

add

push

enqueue

insert

O(1) for simple array

O(1) for linked list or circular array, O(n) for simple array

O(log n) for linked list

O(n) for circular array

Task scheduling in operating systems

Network packet routing

Data storage in databases

Image processing in graphics

A circular queue is a type of stack that allows elements to be added only at one end.

A circular queue can only hold a fixed number of elements and cannot grow dynamically.

A circular queue allows efficient use of space by wrapping around, while a regular queue can waste space and requires shifting elements.

A regular queue is more efficient than a circular queue in terms of memory usage.

Use stack.clear() to determine if a stack is empty.

Check if stack.peek() returns null.

Use stack.isEmpty() to check if a stack is empty.

Use stack.size() to check if a stack is empty.

The LIFO principle allows items to be removed in the order they were added.

The LIFO principle ensures that the most recently added item is the first to be removed, facilitating efficient data management.

The LIFO principle is used to prioritize older items over newer ones.

The LIFO principle ensures that all items are removed simultaneously.

A circular queue helps in resource management by efficiently utilizing a fixed-size buffer for resource allocation and deallocation.

A circular queue limits resource allocation to a single user at a time.

A circular queue is primarily used for sorting data in ascending order.

A circular queue requires dynamic memory allocation for each resource request.

Stacks allow for faster access to the most recently added item.

Queues are less efficient for managing memory compared to stacks.

Queues provide ordered processing, fair access to resources, and are ideal for task scheduling.

Stacks are better for task scheduling than queues.

5

0

1

-1

myArray int[];

array int myArray;

int[] myArray;

int myArray[];

-1

null

undefined

0

Call str.getLength() to find the string length.

Use str.size() to determine the length of a string.

Use str.lengthOf() to retrieve the length of a string.

Use str.length() to get the length of a string.

myString.convertToLower()

myString.lowercase()

myString.toLowerCase()

myString.toLower()

arrayName[2][0]

arrayName[0][2]

arrayName[0][1]

arrayName[1][2]

H

e

l

o

List.sort()

ArrayList.sort()

Arrays.sort()

Collections.sortArray()

You can concatenate two strings in Java using the '+' operator or the String.concat() method.

Using the StringBuilder.append() method

Using the '-' operator

Using the String.append() method

The purpose of the StringBuilder class in Java is to provide a mutable sequence of characters for efficient string manipulation.

To store a fixed number of characters.

To create immutable strings in Java.

To convert strings to integers efficiently.

Use StringBuilder.append('The number is: ', number) to format a string.

Use String.format("The number is: %d", number) to format a string with a number.

Use String.concat(number) to append a number to a string.

Use number.toString() + ' is the number' to format a string.

The main difference is that arrays have a fixed size, whereas ArrayLists can change size dynamically.

Arrays can store only primitive data types, while ArrayLists can store objects.

ArrayLists are faster than arrays in all operations.

Arrays can only be used in static contexts, while ArrayLists can be used in dynamic contexts.

dataType[][] arrayName = new dataType[rows][columns]; or dataType[][] arrayName = {{value1, value2}, {value3, value4}};

dataType arrayName = new dataType[rows][columns];

dataType[][] arrayName = new dataType[rows];

dataType arrayName = new dataType[rows];

Use the 'find()' method (Python)

Check the length of the string

Use the 'in' operator (Python) or 'includes()' method (JavaScript).

Use the 'substring()' method (JavaScript)

sortArray(yourArray);

Arrays.order(yourArray);

Arrays.sort(yourArray);

yourArray.sort();

A singly linked list is a dynamic data structure with nodes linked sequentially, differing from an array which has a fixed size and allows direct index-based access.

A singly linked list is a static data structure with a fixed size.

A singly linked list stores elements in a contiguous block of memory.

An array allows for dynamic resizing while a linked list does not.

A doubly linked list is more memory efficient than a singly linked list.

A doubly linked list can only be traversed in one direction.

A doubly linked list has nodes with a single pointer to the next node only.

A doubly linked list has nodes with pointers to both the next and previous nodes, allowing bidirectional traversal, which provides advantages in node deletion and traversal efficiency over a singly linked list.

A circular linked list is a linked list where the last node points to the first node, useful for circular iteration scenarios.

A circular linked list is a data structure that only allows one-way traversal.

A circular linked list is a linked list where nodes are arranged in a grid format.

A circular linked list is a type of array that allows for dynamic resizing.

Sorting: Arranging nodes in a specific order.

Merging: Combining two linked lists into one.

1) Insertion: Adding a new node to the list. 2) Deletion: Removing a node from the list. 3) Traversal: Accessing each node in the list.

Searching: Finding a specific node based on a value.

Delete the current head before adding the new node.

Create a new node, set its next to the current head, and update the head to the new node.

Add the new node at the end of the list.

Replace the current head with the new node without linking.

Memory overhead from pointers, fragmentation, and garbage collection.

No need for garbage collection

Constant time access to elements

Memory efficiency from arrays

Garbage collection in Java requires manual intervention to free linked list nodes.

Linked list nodes are never collected by garbage collection in Java.

Garbage collection in Java identifies unreachable linked list nodes and reclaims their memory automatically.

Garbage collection in Java only works for arrays, not linked lists.

Implementing binary search trees

Storing data in a fixed-size array

Managing user sessions in web applications

Examples of where linked lists are useful include implementing stacks and queues, dynamic memory allocation, maintaining a playlist in media players, representing adjacency lists in graphs, and providing undo functionality in applications.

Traverse the list by jumping two nodes at a time.

Visit each node randomly until you decide to stop.

Start at the head, loop through each node until you reach the head again.

Start at the tail and move backwards through each node.

O(n^2)

O(log n)

O(1)

O(n)