Algorithms & C Programming

Explain the role of a compiler and the process of turning C source code into an executable program.

Declare, initialize, and use variables of basic data types (int, float, double, char).

Use arithmetic operators to perform calculations.

Read formatted user input from the console using scanf and store it in variables.

Use comparison and logical operators to construct boolean expressions.

Implement conditional logic using if-else if-else statements.

Use switch statements to handle multiple discrete cases.

Write a while loop to repeat actions based on a condition.

Write a for loop for definite iteration over a sequence.

Control loop behavior with break and continue statements.

Trace the execution of nested loops on paper to predict output.

Explain the purpose of functions for code organization, reuse, and abstraction.

Define a function with parameters and a return value.

Call functions and use their return values in expressions.

Use function prototypes to declare functions before their definition.

Distinguish between local and global variable scope.

Refactor a monolithic program into smaller, single-purpose functions (e.g., a unit converter).

Declare, initialize, and access elements in one-dimensional arrays.

Represent strings as null-terminated character arrays and use standard library string functions (strlen, strcpy, strcmp).

Explain the concept of a memory address and how variables are stored in memory.

Declare pointer variables; use the address-of (&) and dereference (*) operators.

Describe the relationship between arrays and pointers in C, using pointer arithmetic to traverse an array.

Pass pointers to functions to allow modification of arguments (pass-by-reference).

Manipulate strings using character pointers (char *).

Define and use structs to group related data into a custom type.

Access struct members using dot (.) and arrow (->) notation for struct variables and pointers to structs.

Explain the difference between stack and heap memory allocation.

Allocate and deallocate memory on the heap using malloc() and free().

Create dynamically-sized arrays at runtime.

Dynamically allocate memory for instances of structs.

Identify and prevent common memory errors like memory leaks and dangling pointers.

Explain how command-line arguments are passed to the main function (argc, argv).

Write a program that processes command-line arguments.

Open, read from, write to, and close text files using fopen, fscanf, fprintf, and fclose.

Perform error checking when opening and operating on files.

Write a program that reads structured data from a file into an array of structs.

Write a program that saves an array of structs to a text file.

Define 'algorithm' and explain the importance of efficiency.

Describe Big-O notation as a tool for classifying algorithm time complexity.

Identify and compare common complexity classes: O(1), O(log n), O(n), O(n log n), O(n²).

Determine the Big-O time complexity of simple iterative code, including nested loops.

Distinguish between best-case, worst-case, and average-case analysis.

Count the number of primitive operations in a simple code fragment for a given input size.

Implement linear search on an array and state its O(n) time complexity.

Implement binary search on a sorted array and state its O(log n) time complexity.

Implement the selection sort algorithm and analyze its O(n²) time complexity.

Implement the insertion sort algorithm.

Analyze the time complexity of insertion sort, identifying its best-case O(n) and worst-case O(n²) scenarios.

Explain the divide-and-conquer strategy using merge sort as a motivating example.

Implement the 'merge' helper function to combine two sorted arrays into one.

Define recursion in terms of a base case and a recursive step.

Implement the merge sort algorithm by making recursive calls.

Trace the call stack of a simple recursive function (e.g., factorial) to understand its execution flow.

Analyze the O(n log n) time complexity and O(n) space complexity of merge sort.

Compare the performance characteristics of all sorting algorithms covered (bubble, selection, insertion, merge).

Describe the Stack Abstract Data Type (ADT), its LIFO behavior, and its primary operations (push, pop, peek).

Solve a problem using a stack, such as validating balanced parentheses in a string.

Describe the Queue ADT, its FIFO behavior, and its primary operations (enqueue, dequeue).

Implement a queue using a circular array to manage memory efficiently.

Define a node struct for a singly linked list.

Implement a function to insert a new node at the head of a linked list.

Implement a function to traverse a linked list and print its elements.

Implement a function to search for a value within a linked list.

Implement a function to delete a node with a specific value from a linked list.

Implement a stack using a linked list to demonstrate its versatility.

Explain the structure and terminology of binary trees (root, node, leaf, height, depth).

Describe the properties of a Binary Search Tree (BST).

Implement the insert and search operations for a BST.

Implement in-order, pre-order, and post-order traversals for a binary tree.

Explain the concept of hashing, hash functions, and collisions.

Implement a basic hash table using chaining (an array of linked lists) to handle collisions.

Compare the average-case time complexity of search operations in arrays, BSTs, and hash tables.

For a given problem scenario, select a suitable data structure and justify the choice based on operational complexity.