Course Content

Other Courses

Tribhuvan university > CSIT - 2074 Syllabus > Data Structures and Algorithms

Data Structures and Algorithms - Syllabus

Syllabus Notes Old Questions Unit Wise Questions Question Bank

Embark on a profound academic exploration as you delve into the Data Structures and Algorithms course (DSA) within the distinguished Tribhuvan university's CSIT department. Aligned with the 2074 Syllabus, this course (CSC206) seamlessly merges theoretical frameworks with practical sessions, ensuring a comprehensive understanding of the subject. Rigorous assessment based on a 60 + 20 + 20 marks system, coupled with a challenging passing threshold of , propels students to strive for excellence, fostering a deeper grasp of the course content.

This 3 credit-hour journey unfolds as a holistic learning experience, bridging theory and application. Beyond theoretical comprehension, students actively engage in practical sessions, acquiring valuable skills for real-world scenarios. Immerse yourself in this well-structured course, where each element, from the course description to interactive sessions, is meticulously crafted to shape a well-rounded and insightful academic experience.


Course Description:

This course includes the basic foundations in of data structures and algorithms. This course

covers concepts of various data structures like stack, queue, list, tree and graph. Additionally,

the course includes idea of sorting and searching.

Course Objectives:

  •  To introduce data abstraction and data representation in memory
  •  To describe, design and use of elementary data structures such as stack, queue, linked list, tree and graph
  •  To discuss decomposition of complex programming problems into manageable sub problems
  •  To introduce algorithms and their complexity

Units

Introduction to Data Structures & Algorithms

1.1 Data types, Data structure and Abstract date type

1.2 Dynamic memory allocation in C

1.3 Introduction to Algorithms

1.4 Asymptotic notations and common functions



Stack

2.1 Basic Concept of Stack, Stack as an ADT, Stack Operations, Stack Applications

2.2 Conversion from infix to postfix/prefix expression, Evaluation of postfix/ prefix

expressions



Queue

3.1 Basic Concept of Queue, Queue as an ADT, Primitive Operations in Queue

3.2 Linear Queue, Circular Queue, Priority Queue, Queue Applications



Recursion

4.1 Principle of Recursion, Comparison between Recursion and Iteration, Tail Recursion

4.2 Factorial, Fibonacci Sequence, GCD, Tower of Hanoi(TOH)

4.3 Applications and Efficiency of Recursion



Lists

5.1 Basic Concept, List and ADT, Array Implementation of Lists, Linked List

5.2 Types of Linked List: Singly Linked List, Doubly Linked List, Circular Linked List.

5.3 Basic operations in Linked List: Node Creation, Node Insertion and Deletion from

Beginning, End and Specified Position

5.4 Stack and Queue as Linked List



Sorting

6.1 Introduction and Types of sorting: Internal and External sort

6.2 Comparison Sorting Algorithms: Bubble, Selection and Insertion Sort, Shell Sort

6.3 Divide and Conquer Sorting: Merge, Quick and Heap Sort

6.4 Efficiency of Sorting Algorithms



Searching and Hashing

7.1 Introduction to Searching, Search Algorithms: Sequential Search, Binary Search

7.2 Efficiency of Search Algorithms

7.3 Hashing : Hash Function and Hash Tables, Collision Resolution Techniques



Trees and Graphs

8.1 Concept and Definitions, Basic Operations in Binary Tree, Tree Height, Level and Depth

8.2 Binary Search Tree, Insertion, Deletion, Traversals, Search in BST

8.3 AVL tree and Balancing algorithm, Applications of Trees

8.4 Definition and Representation of Graphs, Graph Traversal, Minimum Spanning Trees:

Kruskal and Prims Algorithm

8.5 Shortest Path Algorithms: Dijksrtra Algorithm



Lab works

Laboratory Works:

After completing this course, students should have practical knowledge of data structures,

algorithms, and ADTs. The laboratory work includes.

  •  Writing programs with dynamic memory allocation and de-allocation.
  •  Writing programs to implement stack operations.
  •  Writing programs using stack to convert infix expression to postfix/prefix expression and to   evaluate postfix/prefix expression.
  •  Writing programs to implement queue operations for linear, circular, and priority queue.
  •  Writing recursive programs to implement factorial, Fibonacci sequence, GCD, and Towerof   Hanoi algorithms.
  •  Writing programs to implement list using array and linked list.
  •  Writing programs for linked list implementation of stack and queue.
  •  Writing programs to implement sorting, searching and hashing algorithms.
  •  Writing programs to implement Binary Search Trees and AVL Tress.
  •  Writing programs to implement searching, spanning tree and shortest path.