DATA STRUCTURES & ALGORITHMS COMPLETED EXAM 2024, Exams of Computer Science

Download DATA STRUCTURES & ALGORITHMS COMPLETED EXAM 2024 and more Exams Computer Science in PDF only on Docsity!

DATA STRUCTURES

& Algorithms

COMPLETED EXAM

1. What is the difference between a stack and a queue? How are they implemented using arrays or linked lists? A stack is a linear data structure that follows the LIFO (Last In First Out) principle, meaning that the last element inserted is the first one to be removed. A queue is also a linear data structure that follows the FIFO (First In First Out) principle, meaning that the first element inserted is the first one to be removed. Both stacks and queues can be implemented using arrays or linked lists. For arrays, a stack can use either the beginning or the end of the array as the top, and a queue can use either the beginning or the end of the array as the front. For linked lists, a stack can use either the head or the tail as the top, and a queue can use the head as the front and the tail as the rear.
2. What is a binary search tree? What are its properties and applications? A binary search tree (BST) is a binary tree data structure that satisfies the following properties: for any node in the tree, all the nodes in its left subtree have values less than or equal to its value, and all the nodes in its right subtree have values greater than or equal to its value. A BST supports efficient search, insertion, deletion, and traversal operations. Some applications of BSTs are: sorting, searching, indexing, priority queues, symbol tables, etc.
3. What is a hash table? How does it work and what are its advantages and disadvantages? A hash table is a data structure that maps keys to values using a hash function. A hash function takes a key as input and returns an integer value called a hash code, which is used to index an array of buckets or slots where the values are stored. A hash table works by applying the hash function to the key and accessing the corresponding bucket or slot in the array. If there is more than one value stored in the same bucket or slot, then a collision occurs and a resolution technique is needed to handle it. Some common collision resolution techniques are: chaining, linear probing, quadratic probing, double hashing, etc. The advantages of hash tables are: fast access, insertion, and deletion operations; dynamic resizing; flexible keys; etc. The disadvantages of hash tables are: possible collisions; wasted space; unpredictable order; etc.
4. What is an algorithm? What are some criteria to measure its efficiency and quality? An algorithm is a finite sequence of well-defined steps or instructions that solves a problem or performs a task. Some criteria to measure its efficiency and quality are: correctness, completeness, optimality, time complexity, space complexity, simplicity, readability, modularity, robustness, etc.
5. What are some common sorting algorithms? How do they work and what are their time and space complexities? Some common sorting algorithms are: selection sort, insertion sort, bubble sort, merge sort, quick sort, heap sort, radix sort, etc. They work by comparing and rearranging elements in an array or list until they are in a desired order (ascending or descending). Their time and space complexities vary depending on the algorithm design and implementation. For example:

• Selection sort works by finding the smallest (or largest) element in each iteration and placing it at its

7. What are some common data structures? How are they implemented and what are their advantages and disadvantages? Some common data structures are: arrays, linked lists, stacks, queues, trees, graphs, hash tables, heaps, etc. They are implemented using primitive data types (such as integers, floats, characters, booleans, etc.) and/or references (such as pointers, references, etc.) to store and manipulate data. Their advantages and disadvantages vary depending on the data structure design and implementation. For example:

• Arrays are data structures that store a fixed number of elements of the same type in contiguous memory locations. They have fast random access, but slow insertion and deletion operations; fixed size, but no dynamic resizing; easy implementation, but low abstraction; etc.
• Linked lists are data structures that store a variable number of elements of any type in non-contiguous memory locations linked by references. They have fast insertion and deletion operations, but slow random access; dynamic resizing, but extra space for references; high abstraction, but complex implementation; etc.
• Stacks are data structures that store elements in LIFO order. They have fast push and pop operations, but limited access to other elements; dynamic resizing, but possible overflow or underflow; simple implementation, but low versatility; etc.
• Queues are data structures that store elements in FIFO order. They have fast enqueue and dequeue operations, but limited access to other elements; dynamic resizing, but possible overflow or underflow; simple implementation, but low versatility; etc.
• Trees are data structures that store elements in a hierarchical order with one root node and zero or more child nodes. They have fast search, insertion, deletion, and traversal operations (depending on the type of tree), but complex implementation; high abstraction, but possible imbalance or degeneration; etc.
• Graphs are data structures that store elements as nodes connected by edges with weights or directions. They have versatile applications (such as network analysis, path finding, etc.), but complex implementation; high abstraction, but possible cycles or disconnected components; etc.
• Hash tables are data structures that store key-value pairs using a hash function to map keys to values. They have fast access, insertion, and deletion operations (depending on the hash function and collision resolution technique), but possible collisions; dynamic resizing, but wasted space; flexible keys, but unpredictable order; etc.
• Heaps are data structures that store elements in a complete binary tree where each node is greater than or equal to its children (max heap) or less than or equal to its children (min heap). They have fast access to the root element (the maximum or minimum), but slow access to other Topic: Big O Notation and Complexity Analysis Question: Define Big O notation and explain its significance in analyzing the time and space complexity of algorithms. Provide examples of algorithms and their corresponding Big O complexities, and discuss the implications of complexity analysis for algorithm selection and optimization. Answer: Big O notation quantifies the worst-case time or space complexity of algorithms. For example, linear search has O(n) time complexity, while binary search has O(log n) time complexity. Understanding and comparing these complexities inform algorithm design, selection, and optimization to achieve efficient solutions for different problem sizes.

Topic: Arrays and Linked Lists Question: Compare and contrast arrays and linked lists as fundamental data structures. Discuss their advantages, disadvantages, and applications in real-world scenarios, and analyze the time and space complexities of common operations for both data structures. Answer: Arrays provide constant-time access but have fixed size, while linked lists allow dynamic memory allocation but have linear-time access. Understanding these trade-offs is crucial for selecting the appropriate data structure based on the specific requirements of applications and optimizing algorithms for efficient data manipulation. Topic: Trees and Graphs Question: Explain the properties and applications of binary trees and graphs. Discuss the traversal algorithms for binary trees and graph representation techniques, and analyze the time and space complexities of traversal and search operations on these data structures. Answer: Binary trees support efficient searching and sorting operations, while graphs model complex relationships among data entities. Traversal algorithms like in-order, pre-order, and post-order traversal for binary trees, and depth-first and breadth-first search for graphs, enable effective data exploration and manipulation, guiding algorithm design for various applications. Topic: Sorting and Searching Algorithms Question: Compare and contrast the performance of different sorting algorithms, such as bubble sort, merge sort, and quicksort, in terms of time complexity, stability, and space usage. Discuss the trade-offs between comparison-based and non-comparison-based sorting algorithms and their suitability for different input data characteristics. Answer: Sorting algorithms exhibit varying time complexities and stability, influencing their applicability to different input data patterns. Comparison-based algorithms like merge sort offer consistent performance, while non-comparison-based algorithms like counting sort excel for specific data distributions. Understanding these trade-offs guides algorithm selection for optimal sorting performance. Topic: Hashing and Hash Tables Question: Describe the principles of hashing and the use of hash tables for efficient data storage and retrieval. Discuss collision resolution techniques, such as chaining and open addressing, and analyze the time and space complexities of common operations on hash tables. Answer: Hashing enables rapid data retrieval through hash tables, though collisions may occur. Collision resolution methods like chaining and open addressing mitigate collisions, impacting the efficiency of hash table operations. Understanding these techniques is critical for designing robust hash functions and selecting appropriate collision resolution strategies for efficient data management.

Topic: Advanced Data Structures Question: Discuss the applications and advantages of advanced data structures, such as trie, segment tree, and Fenwick tree, in solving specific computational problems. Analyze the time and space complexities of common operations on these data structures and justify their suitability for different types of data processing tasks. Answer: Advanced data structures like trie, segment tree, and Fenwick tree offer specialized capabilities for efficient data organization and manipulation. Understanding the time and space complexities of operations on these data structures informs their selection and optimization for diverse computational problems, guiding the development of high-performance algorithms.