Data Structures and Algorithms

In B*Trees, leaf nodes are connected via a doubly linked list to allow efficient range queries and sequential traversal in both directions. Singly linked lists only support unidirectional traversal, and generic pointers or structures do not define the specific list traversal pattern.

When you create an ArrayList using the no-argument constructor new ArrayList(), Java initializes it with a default capacity of 10. This is an implementation detail of the ArrayList class designed to balance memory usage and performance for common use cases. The capacity is not 0, 8, or unlimited.

SEQNUM is the correct SORT option to generate sequence numbers. The syntax is typically SEQNUM=n where n specifies the starting position and length. NUMGEN and GENNUM are not valid SORT utility options for this purpose.

The function passes point3d structs by value, meaning the entire struct (12 bytes for 3 ints) is copied for each parameter, every time the function is called. With 2 million objects and 1 million function calls, this results in copying 24 million bytes (2 parameters x 12 bytes x 1 million calls) - a significant performance overhead. Passing by reference (const point3d&) would avoid this copying.

Partition by Key only groups records by key value across partitions without requiring any specific order. Dedup Sort, Sort within Groups, and Merge all depend on pre-sorted data to function correctly.

HybridDictionary is the most efficient choice for storing name/value pairs when the quantity is unknown. It automatically uses a ListDictionary for small collections (which is efficient for few items) and switches to a Hashtable when the collection grows (which is efficient for larger collections). Hashtable is always a hash table (overhead for small collections), ListDictionary is always a linked list (slow for large collections), and ArrayList stores only values not key-value pairs.

Dijkstra's algorithm needs: (1) a graph representation via Adjacency List for efficient neighbor access, (2) a Heap (typically min-heap) to efficiently extract the vertex with minimum distance in O(log V), and (3) a structure to manage visited/unvisited vertices or frontier, typically implemented via Queue or priority queue. Option B has all essential components.

The recursive function shown has a pattern that suggests nested loops leading to O(n²) complexity. For each of n iterations, there are up to n recursive calls or operations within, giving quadratic time complexity. O(n²) is a common complexity for nested iteration patterns.

When the maximum value k in the list is known, we can use counting sort which runs in O(n+k) time - O(n) to count occurrences and O(k) to output sorted values. This is better than comparison-based sorts like merge/quick sort which require O(n log n) in the best case.

Reversing a linked list requires traversing the list once and redirecting each node's next pointer to its predecessor. This is done in a single pass with constant work per node, giving O(n) time complexity.

This minimum path sum problem can be solved by recursion (exponential O(2^n) by exploring all paths) or optimally by dynamic programming (O(n^2) using memoization). Brute force would be O(n^3) or worse, and divide & conquer doesn't apply to this DP structure.

This is the same minimum path sum problem - recursion explores all possible paths giving O(2^n) complexity, while dynamic programming with memoization achieves O(n^2) by avoiding recomputation. Divide & conquer is not applicable to this DP-optimized structure.

When a COBOL program performs sorting operations (via SORT verb), it typically invokes external sort utilities provided by the operating system or runtime environment rather than implementing the sort algorithm internally. This external sorting leverages optimized system utilities for efficient data processing, making the statement True.

In Ruby, both length and size are valid methods to get the number of elements in an array. They are aliases and return the same result. Options C and D are incorrect because size(name) and length(name) are not valid Ruby syntax - these methods must be called on the array object itself, not with the array as an argument.