Data Structure

In linked lists, a null pointer (NULL in C/C++) marks the end of the list. When traversing, encountering a null next pointer signals there are no more nodes to follow. This is different from an empty list (where the head pointer itself is null) or an empty structure field.

To access a structure member through a pointer, you must dereference the pointer first before applying the dot operator. (*p).mem correctly dereferences p to get the structure, then accesses mem. The shorthand p->mem is equivalent and more commonly used. *p.mem would try to dereference a non-existent p.mem, and *(p.mem) is invalid.

To convert a*(b+c)/e-f to prefix: First convert a*(b+c) to *a+bc. Then (*a+bc)/e becomes /*a+bce. Finally, subtract f: -/*a+bcef. Prefix notation places operators before their operands, requiring systematic conversion from innermost parentheses outward.

 Stack is an abstract data type that serves as a collection of elements, with two principal operations: push, which adds an element to the collection, and pop, which removes the last element that was added.So It can be used to process procedure call in program.

Every linked list node must contain a 'next' address field (pointer) that points to the subsequent node or null if it's the last node. Without this field, nodes couldn't be linked together to form a list. Nodes typically also have a data field, but the next pointer is the essential requirement.

Bubble sort's worst-case time complexity is O(n²) because it makes n-1 passes, each comparing up to n-1 pairs of adjacent elements. The total comparisons approach (n-1) + (n-2) + ... + 1 = n(n-1)/2, which is O(n²). Option B correctly represents this quadratic complexity.

A vertex's degree counts both: (1) the number of edges incident to that vertex (edges having it as an endpoint), and (2) the number of neighboring vertices directly connected to it. In simple graphs, these are equivalent since each edge connects to exactly one neighbor. Both definitions describe the same fundamental measure of vertex connectivity.

A tree is defined as a finite set of nodes with one designated root, where remaining nodes form disjoint subtrees. Options A is correct - trees consist of nodes. 'Directed access' in option B is not a standard term in tree definitions. The node count is finite and hierarchical.

Data structure evaluation considers both space utilization (memory efficiency) and time efficiency (operation speed). The best data structure balances these competing factors - using minimal memory while enabling fast operations. This tradeoff is fundamental to algorithm design and optimization.

Traversing (visiting each element), searching (finding specific elements), and merging (combining structures) are all valid, fundamental data structure operations. Since all options A-C are valid operations, the correct answer is D - 'None of these' represents that there is no invalid operation in the list.

Lists, stacks, and trees can all grow or shrink during runtime, making them dynamic data structures. Arrays are the primary example of static (non-dynamic) data structures with fixed sizes. Since lists, stacks, and trees are all dynamic, the correct answer is D - none of these are non-dynamic.

Stacks are used for postfix expression evaluation because operators are applied to the most recent operands, matching the LIFO (Last In First Out) principle. When encountering an operator, pop required operands from the stack, apply the operation, and push the result back.

Dynamic memory allocation occurs during runtime when programs request memory using functions like malloc() or new. Static allocation is fixed at compile time and cannot change during execution.

By convention, the root node of a tree is at level 0. Its direct children are at level 1, grandchildren at level 2, and so on. This zero-based indexing is standard in tree data structures.

The stack insertion operation (push) adds a new node to the top of the stack. The description matches this exactly: create a node, store the element, and insert at the top (the only insertion point in a stack).

Pre-order traversal visits the root node first, then recursively traverses the left subtree, then the right subtree. The 'pre' prefix means the root comes before (pre) its children.

Static memory allocation is fixed at compile time. The compiler determines memory requirements before the program runs, allocating space on the stack for global and local variables.

AVL trees are self-balancing binary search trees where each node's balance factor (height of left subtree minus height of right subtree) must be -1, 0, or 1. This constraint ensures the tree remains balanced.

Linked lists are linear data structures where elements are arranged sequentially. Each node points to the next, forming a linear chain. Trees and graphs are non-linear as elements branch in multiple directions.

Folding is a hash function method that divides the key into equal-sized parts and combines them (usually by addition or XOR) to create a hash value. Quadratic probing, chaining, and open addressing are collision resolution techniques, not hash functions.

A pendent vertex (or pendant vertex) is a vertex with degree one, meaning it's connected to exactly one other vertex. In graph theory, these are also called leaf vertices or end vertices, but 'pendent vertex' is the precise term.

In queue implementation using arrays, FRONT=REAR indicates an empty queue. This is the initial state after initialization. When FRONT=REAR+1 (in circular queues), the queue is full.