A way of organizing and storing data is correct. Data structures organize and store data efficiently. The choice depends on operations needed: access, insertion, deletion, search.

None of the above is correct. Data structures organize and store data efficiently. The choice depends on operations needed: access, insertion, deletion, search.

Linear Data Structure:
A linear data structure is one in which elements are arranged in a sequential order, and each element is connected to its previous and next element.

Examples:

• Array
• Linked List
• Stack
• Queue

Non-Linear Data Structure:
A non-linear data structure is one in which elements are not arranged in a sequential order. Data is stored in a hierarchical or network structure.

Examples:

• Tree
• Graph

Answer:
A linear data structure is any of the following: Array, Linked List, Stack, Queue.

Linear Data Structure:
A linear data structure is one in which elements are arranged in a sequential order, and each element is connected to its previous and next element.

Examples:

• Array
• Linked List
• Stack
• Queue

Non-Linear Data Structure:
A non-linear data structure is one in which elements are not arranged in a sequential order. Data is stored in a hierarchical or network structure.

Examples:

• Tree
• Graph

Answer:
A linear data structure is any of the following: Array, Linked List, Stack, Queue.

A Tree is a data structure in which elements have a hierarchical relationship.

How it works:

• Data is organized in a parent-child relationship.
• The top node is called the root.
• Each node can have zero or more child nodes.
• Nodes are connected using edges.

What is the term for accessing elements of a data structure in a specific order?

The most commonly used data structure to implement a priority queue is a Heap (especially Binary Heap).
How it works:

• A priority queue stores elements based on their priority, not just insertion order.
• A Binary Heap maintains the highest (max-heap) or lowest (min-heap) priority at the root.
• Insertion and deletion operations keep the heap property intact.
• The element with highest priority is always accessed first.

Types:

• Min-Heap → smallest element has highest priority
• Max-Heap → largest element has highest priority

A Stack is used to check for balanced parentheses in an expression.

How it works:

• When an opening bracket (, {, [ is found, it is pushed onto the stack.
• When a closing bracket ), }, ] is found, the top element is popped from the stack.
• The popped opening bracket must match the closing bracket.
• After processing the entire expression, the stack should be empty.

Example:

• Expression: {(a+b)}
• Push {, Push (
• Pop ( when ) is found
• Pop { when } is found
• Stack becomes empty → Parentheses are balanced

A Stack is used to evaluate expressions in postfix form.

How it works:

• Scan the expression from left to right.
• If operand is found, push it onto the stack.
• If operator is found, pop required operands from stack.
• Perform the operation and push the result back to stack.
• Final value remains at the top of the stack.

Example:

• Postfix: 5 3 +
• Push 5, push 3
• Apply + → 5 + 3 = 8
• Result = 8

A Parse Tree (Syntax Tree) is used in the syntax analysis phase of a compiler.

What is a Parse Tree?

• It is a tree structure that represents the grammatical structure of source code.
• It is constructed based on the rules of a formal grammar.
• The root node represents the start symbol of the grammar.
• Internal nodes represent non-terminal symbols.
• Leaf nodes represent terminal symbols (actual tokens from the input program).

How it works:

• The parser checks the input program against grammar rules.
• If the syntax is correct, it builds a tree showing how the program is derived from the grammar.
• This tree helps the compiler understand the structure of the program.

A Stack uses LIFO (Last In First Out) order.

How it works:

• The last element inserted is the first one to be removed.
• Insertion is done using push().
• Removal is done using pop().
• Only the top element can be accessed directly.

Applications of Stack:

• Checking balanced parentheses in expressions.
• Evaluating postfix and prefix expressions.
• Implementing undo operations in text editors.
• Function call management (Call Stack).
• Solving the Tower of Hanoi problem.
• Depth-First Search (DFS) traversal in graphs.

A Queue uses FIFO (First In First Out) order.

How it works:

• The first element inserted is the first one to be removed.
• Insertion is done at the rear using enqueue().
• Removal is done from the front using dequeue().
• Elements are processed in the same order they arrive.

Example:

• Enqueue A → Queue: A
• Enqueue B → Queue: A, B
• Dequeue → A is removed first

The most appropriate data structure for applying the balancing of symbols algorithm is a Stack.

How it works:

• Whenever an opening symbol (, {, [ is encountered, it is pushed onto the stack.
• Whenever a closing symbol ), }, ] is encountered, the top element is popped.
• The popped symbol must match the corresponding opening symbol.
• If the stack is empty at the end, the symbols are balanced.

Why Stack is used:

• It follows LIFO (Last In First Out) order, which matches nested symbol checking.

ADT stands for Abstract Data Type.

Meaning:

• It is a theoretical model of a data structure.
• It defines what operations can be performed, not how they are implemented.
• It focuses on behavior rather than implementation details.