char arr[10];
Each char occupies 1 byte in memory. An array of 10 chars will occupy 10 × 1 = 10 bytes.
In C, pointers are declared using the asterisk (*) symbol before the variable name. The syntax is 'datatype *pointer_name;'
int x = 5;
printf("%d", x++);
The post-increment operator (x++) returns the current value of x before incrementing. So printf prints 5, and then x becomes 6.
A Heap (either Min-Heap or Max-Heap) is the optimal data structure for implementing priority queues with O(log n) insertion and deletion time complexity.
In a Max-Heap, the element with the highest priority is always at the root, enabling efficient extraction of the maximum element.
Arrays and Linked Lists would require O(n) time for priority-based operations, while Graphs are unsuitable for this purpose.
Heaps are fundamental in algorithms like Dijkstra's and Prim's for finding shortest paths.
A B-tree of order m has a maximum of m children per node, which means it can have a maximum of (m-1) keys.
Each node can have between ⌈m/2⌉ and m children (for non-leaf nodes), ensuring balance. B-trees are commonly used in database indexing and file systems because they minimize disk I/O operations through their multi-level structure and balanced properties.
Hash Tables achieve O(1) average-case time complexity for both insertion and search operations when using a well-designed hash function that minimizes collisions and maintains a good load factor.
Deletion also operates in O(1) average time.
However, in worst-case scenarios with poor hash functions or high collision rates, these operations can degrade to O(n).
The key to performance is maintaining low collision rates through techniques like chaining or open addressing.
A Stack follows LIFO principle where the last element inserted is the first one to be removed.
It is fundamental in managing function calls through the call stack, undo/redo operations, and expression evaluation.
Queues use FIFO, Heaps are used for priority ordering, and Linked Lists maintain sequential but flexible storage.
The volatile keyword tells the compiler that a variable's value may change at any time (due to external factors like hardware registers, signal handlers, or multi-threading) and should be read from memory every time it's accessed, rather than being optimized by the compiler or cached in a register.
struct demo {
unsigned int a : 5;
unsigned int b : 3;
unsigned int c : 4;
unsigned int d : 7;
};
Bit fields in C are packed into the smallest integral type that can accommodate them.
Here, a(5) + b(3) + c(4) + d(7) = 19 bits total.
Since 19 bits exceed 16 bits but fit within 32 bits, the compiler allocates 4 bytes (32 bits) for this structure, following standard packing rules.
int main() {
char arr[] = "GATE";
char *p = arr;
printf("%d\n", sizeof(arr));
printf("%d", sizeof(p));
return 0;
}
The output is 5 and 8 because sizeof(arr) returns 5 bytes (4 characters plus 1 null terminator in the string "GATE"), while sizeof(p) returns 8 bytes on a 64-bit system since p is a pointer variable and pointers occupy 8 bytes in 64-bit architecture. The key concept is that sizeof() behaves differently for arrays versus pointers: when applied to an array, it returns the total memory allocated for the entire array, but when applied to a pointer, it only returns the size of the pointer itself, not what it points to. Other options would be incorrect because they either miscalculate the array size by forgetting the null terminator, use incorrect pointer sizes (like 4 bytes for 32-bit systems), or confuse the size of the array with the size of the pointer variable.