CSE358:COMBINATORIAL STUDIES

L:2 T:0 P:4 Credits:4

Course Outcomes: Through this course students should be able to

CO1 :: understand fundamental programming concepts and apply them to construct functional
and efficient code.

CO2 :: apply essential data structures and algorithms to develop optimized solutions for
computational problems.

CO3 :: analyze and evaluate the efficiency of algorithms using time and space complexity
considerations.
CO4 :: apply object-oriented programming principles to design modular, reusable, and scalable
software solutions.

CO5 :: create and execute SQL queries to manage, manipulate, and retrieve structured data
efficiently.
CO6 :: develop problem-solving techniques, algorithmic paradigms, and database concepts to
tackle real-world coding challenges and technical interviews.

Unit I
Programming Fundamentals : Basic Syntax & Operators, Introduction to the chosen programming
language, basic syntax, variables, data types, Operators (arithmetic, relational, logical), Control
structures (if-else, switch-case, loops), Functions and recursion, Data Structures – Arrays & Strings,
Introduction to arrays and basic operations (insertion, deletion, searching), String manipulation
(concatenation, substring, string reversal), Multi-dimensional arrays and array-based algorithms,
Solving problems with arrays and strings (e.g., reverse array, find duplicates), Object-Oriented
Programming (OOP), Classes and objects, Inheritance and polymorphism, Encapsulation and
abstraction, Practice with OOP-based problems (e.g., designing simple class hierarchies), Time
Complexity & Big-O Notation, Introduction to time complexity and Big-O notation, Analyze the time
complexity of problems solved so far
Unit II
Advanced Data Structures & Algorithms : Linked Lists, Singly linked list (insertion, deletion,
traversal), Doubly linked list and circular linked list, Reverse linked list, detect loops, and other basic
algorithms, Practice problems on linked lists, Stacks and Queues, Stack operations and use cases
(infix, prefix, postfix), Implementing queues (basic queue, circular queue, priority queue),
Applications of stacks and queues (e.g., balanced parentheses, expression evaluation), Practice
problems, Trees and Binary Search Trees (BST), Basic binary tree operations (in-order, pre-order,
post-order traversal), Binary Search Tree (BST) properties and operations, AVL Trees, Red-Black
Trees, Practice problems on trees and BST, Heaps, Min heap and max heap (insert, delete, heapify),
Priority Queue implementation and applications
Unit III
Graphs and Advanced Topics : Graphs, Graph representations (adjacency matrix, adjacency list),
BFS (Breadth-First Search) and DFS (Depth-First Search), Shortest path algorithms (Dijkstra,
Bellman-Ford), Practice graph-related problems (connected components, cycle detection), Sorting and
Searching Algorithms, Sorting algorithms (bubble sort, selection sort, insertion sort), Efficient sorting
algorithms (merge sort, quick sort, heap sort), Searching algorithms (binary search, linear search,
interpolation search)
Unit IV
Introduction to Databases : Introduction to Databases, Understanding relational databases and
schema design
SQL : Data types in SQL, creating tables, and inserting data, Basic SQL queries (SELECT, WHERE,
ORDER BY, GROUP BY), SQL Joins, Subqueries & Aggregation, Inner join, left join, right join, and full
join, Subqueries (in SELECT, WHERE, and FROM clauses), Aggregate functions (COUNT, SUM, AVG,
MIN, MAX), Practice SQL problems with joins, aggregation, and subqueries
Unit V
Advanced SQL : Advanced SQL, Set operations (UNION, INTERSECT, EXCEPT), Transactions, ACID
properties, and indexing, Stored procedures, triggers, and views, Practice with complex SQL queries
(nested queries, recursive queries)
Data Structures Optimization : Optimizing Data Structures, Improving space and time complexity
of algorithms, Implementing efficient algorithms (e.g., divide and conquer, greedy), Code review and
optimization techniques

Session 2024-25 Page:1/2

Unit VI
Real-world Problem Practice : Practice designing systems (e.g., URL shortening service, e-
commerce system), Problem-solving with data structures and databases in real-time scenarios, Focus
on edge cases and problem-solving techniques, Final Mock Interview and Review, Full mock interview
(coding + SQL), Review and polish weak areas, Mock Coding Tests, Solve algorithmic problems under
time pressure, Focus on data structures with harder complexity, Solve questions related to SQL
optimization and database design, Take mock coding challenges from online platforms (e.g.,
LeetCode, HackerRank), Review and analyze the solutions, Interview-Specific Practice, Review
common interview questions on algorithms and data structures, Solve problems involving real-world
use cases (e.g., designing a system or solving a business problem), Focus on SQL interview questions
(database design, SQL queries, optimization), Mock technical interviews (with peers or mentors),
System Design & Problem-Solving, Introduction to system design and scalable systems
Final Practice : Final practice and review interview preparation

List of Practicals / Experiments:

Practical Problem Solving

• 1. Insert, delete, update, and search elements in 1D and 2D array

• 2. Lowest Common Ancestor in a Binary Search Tree

• 3. Insert, delete, update and search in BST

• 4. Implement Dijkstra and Bellman-Ford Algorithm for finding the shortest path in the graph

• 5. Design and implement a relational database schema for an Online Library Management System
using SQL.
• 6. Implement advanced SQL operations, including indexing, transactions, stored procedures, triggers,
and optimization techniques to enhance query performance and database efficiency.

References:
1. INTRODUCTION TO ALGORITHMS by THOMAS H. CORMEN, CHARLES E. LEISERSON,
RONALD L. RIVEST AND CLIFFORD STEIN, MIT Press
2. CRACKING THE CODING INTERVIEW by GAYLE LAAKMANN MCDOWELL, CAREERCUP

Session 2024-25 Page:2/2