BCA 106T Data Structures and Algorithms Notes are 89-page English study notes for GGSIPU BCA Semester 2, written for the batch admitted in 2024-25 onwards. They cover all 4 official units with 24 C programs with output, 46 labelled figures and 76 solved exam questions: 48 two-mark and 28 ten-mark.
Scheme: CCFUP scheme 2024-25 | Applies to: batch admitted in 2024-25 onwards | Verified against: syllBCA1styr240124.pdf and syll4yrBCA240124.pdf (approved 20 Dec 2023)
- BCA 106T at a glance: credits, units and exam pattern
- BCA 106T notes unit-wise
- Excerpt from page 51: Polish and reverse Polish notation
- Do the notes cover the full syllabus?
- How to write BCA 106T answers
- BCA 106T exam corner
- Who writes and checks these notes
- BCA 106P lab and other Sem 2 papers
- BCA 106T FAQs
- Get the full notes on WhatsApp
BCA 106T Data Structures and Algorithms at a glance: GGSIPU BCA Sem 2 credits, units and exam pattern
BCA 106T is a Core Course Theory (CCT) paper. Its official pre-requisites are C programming skills and discrete mathematics, so these GGSIPU BCA Sem 2 Data Structures and Algorithms notes write every program in C.
| Code and title | BCA 106T · Data Structures and Algorithms |
|---|---|
| Course and semester | BCA, Semester 2 |
| Category and credits | CCT · 4 credits · L-T 4-0 (4 lecture hours a week) |
| Marks | 100: 40 internal + 60 end-term |
| Applies to | Batch admitted in 2024-25 onwards |
| End-term pattern | Q1 compulsory: 10 × 2 marks, at least 2 per unit. Then one of two questions per unit, 10 marks each. (20 + 40 = 60 marks) |
| Units | 4 (teaching hours: Unit I 14, Units II to IV 10 each) |
| Paired lab | BCA 106P · CCP · 1 credit · 40 + 60 = 100 marks |
Unit I gets the most hours: arrays, two searches, four sorts and hashing. It is one of four core theory papers among the GGSIPU BCA Semester 2 papers.
BCA 106T Data Structures and Algorithms Notes unit-wise: 24 C programs with output and 76 solved questions across 4 units
After a cover and a master index, each unit runs 20 to 23 pages and ends with a Quick Revision Sheet, a Common Mistakes table and an Exam Corner. Notes for every other paper sit under GGSIPU BCA notes.
BCA 106T Unit 1: Linear Data Structures (Static)
Pages 3 to 25. Algorithm attributes and asymptotic notation, array address formulas for 1-D and 2-D arrays, then searching, sorting and hashing.
Sections 1.1 Algorithms to 1.6 Hashing · 8 C programs with output (sparse matrix to triplet, two searches, four sorts, a linear-probing hash table) · 12 figures · 12 two-mark and 7 ten-mark questions.
| Sort | Best | Worst | Space, stable? |
|---|---|---|---|
| Selection | O(n²) | O(n²) | O(1), no |
| Bubble | O(n) | O(n²) | O(1), yes |
| Insertion | O(n) | O(n²) | O(1), yes |
| Merge | O(n log n) | O(n log n) | O(n), yes |
Quick look: four sorting methods compared (from page 20)
- Sort
- Selection
- Best
- O(n²)
- Worst
- O(n²)
- Space, stable?
- O(1), no
- Sort
- Bubble
- Best
- O(n)
- Worst
- O(n²)
- Space, stable?
- O(1), yes
- Sort
- Insertion
- Best
- O(n)
- Worst
- O(n²)
- Space, stable?
- O(1), yes
- Sort
- Merge
- Best
- O(n log n)
- Worst
- O(n log n)
- Space, stable?
- O(n), yes
BCA 106T Unit 2: Linear Data Structures (Dynamic)
Pages 26 to 45. Run-time memory with malloc(), calloc(), realloc() and free(), then singly, circular and doubly linked lists through all eight operations the syllabus names.
Sections 2.1 Dynamic Memory Allocation to 2.5 Doubly Linked List · 4 C programs with output, one of which runs creation, insertion, search, modify, sort, reverse, delete and merge together · 10 figures · 12 two-mark and 7 ten-mark questions.
| Basis | malloc() | calloc() |
|---|---|---|
| Arguments | One: total bytes | Two: blocks, size of each |
| Starting value | Garbage | Zero |
| Speed | Slightly faster | Slightly slower |
| Example | malloc(5 * sizeof(int)) | calloc(5, sizeof(int)) |
Quick look: malloc() vs calloc() (from page 28)
- Basis
- Arguments
malloc()- One: total bytes
calloc()- Two: blocks, size of each
- Basis
- Starting value
malloc()- Garbage
calloc()- Zero
- Basis
- Speed
malloc()- Slightly faster
calloc()- Slightly slower
- Basis
- Example
malloc()malloc(5 * sizeof(int))calloc()calloc(5, sizeof(int))
BCA 106T Unit 3: Abstract Data Types
Pages 46 to 66. Stacks and queues as abstract data types, each built with an array and with a linked list, plus expression conversion with trace tables and linear, circular and double-ended queues.
Sections 3.1 Abstract Data Types and Stacks to 3.5 Types of Queues · 9 C programs with output, the most of any unit · 2 solved trace examples · 8 figures · 12 two-mark and 7 ten-mark questions.
Quick look: circular queue wrap-around rules (from page 60)
rear = (rear + 1) % MAX; /* insert */
front = (front + 1) % MAX; /* delete */
/* full : (rear + 1) % MAX == front */
/* empty: front == -1 */The modulo lets rear jump from MAX - 1 back to 0, so cells freed at the front are used again.
BCA 106T Unit 4: Non Linear Data Structures
Pages 67 to 89. Graph terms and three ways to store a graph, binary tree types and storage, recursive traversals and the BST, then step-by-step creation of AVL, heap, M-way and B-trees without code, as the syllabus asks.
Sections 4.1 Introduction to Graphs to 4.6 AVL, Heap, M-way and B Trees · 3 C programs with output · 16 figures, the most of any unit · 12 two-mark and 7 ten-mark questions.
| Case | New node went into | Fix |
|---|---|---|
| LL | Left subtree of left child | Single right rotation |
| RR | Right subtree of right child | Single left rotation |
| LR | Right subtree of left child | Left on child, then right |
| RL | Left subtree of right child | Right on child, then left |
Quick look: the four AVL rotation cases (from pages 81 to 82)
- Case
- LL
- New node went into
- Left subtree of left child
- Fix
- Single right rotation
- Case
- RR
- New node went into
- Right subtree of right child
- Fix
- Single left rotation
- Case
- LR
- New node went into
- Right subtree of left child
- Fix
- Left on child, then right
- Case
- RL
- New node went into
- Left subtree of right child
- Fix
- Right on child, then left
Polish and reverse Polish notation in stack applications: excerpt from page 51 of the BCA 106T notes
Excerpt from page 51
A stack is not only a storage idea. Its most examined use in this paper is handling arithmetic expressions: a stack converts an expression from the way humans write it into a form the computer can evaluate in one scan. The same structure also manages function calls and recursion, checks whether brackets are balanced, reverses a string, and powers undo, the browser back button and depth-first search.
Three ways to write one expression
Every arithmetic expression can be written in three forms, depending on where the operator sits. In infix the operator goes between its operands (A + B); this is how we write maths by hand. In prefix, also called Polish notation after Jan Łukasiewicz, the operator comes before its operands (+ A B). In postfix, called reverse Polish notation, it comes after them (A B +).
Infix needs brackets and precedence rules to remove doubt: A + B × C means A + (B × C), not (A + B) × C. In prefix and postfix the position of each operator already fixes the order of work, so no brackets are needed. That is why a computer can evaluate them with a stack in a single pass.
Precedence and associativity
| Operator | Precedence | Associativity |
|---|---|---|
| ^ (exponent) | Highest (3) | Right to left |
| * / % | Middle (2) | Left to right |
| + − | Lowest (1) | Left to right |
Operator precedence used for conversion
- Operator
- ^ (exponent)
- Precedence
- Highest (3)
- Associativity
- Right to left
- Operator
- * / %
- Precedence
- Middle (2)
- Associativity
- Left to right
- Operator
- + −
- Precedence
- Lowest (1)
- Associativity
- Left to right
The bracket method for a quick check
Fully bracket the expression by precedence. For postfix, move each operator to the position of its closing bracket; for prefix, move it to its opening bracket. Then drop all the brackets.
| Infix | Fully bracketed | Postfix | Prefix |
|---|---|---|---|
| A + B * C | (A + (B * C)) | A B C * + | + A * B C |
| (A + B) * C | ((A + B) * C) | A B + C * | * + A B C |
| A ^ B ^ C | (A ^ (B ^ C)) | A B C ^ ^ | ^ A ^ B C |
Bracket method on three expressions
- Infix
- A + B * C
- Fully bracketed
- (A + (B * C))
- Postfix
- A B C * +
- Prefix
- + A * B C
- Infix
- (A + B) * C
- Fully bracketed
- ((A + B) * C)
- Postfix
- A B + C *
- Prefix
- * + A B C
- Infix
- A ^ B ^ C
- Fully bracketed
- (A ^ (B ^ C))
- Postfix
- A B C ^ ^
- Prefix
- ^ A ^ B C
The last row shows why associativity matters: exponent groups from the right, so A ^ B ^ C means A ^ (B ^ C). The bracket method is good for checking an answer, but a long answer still needs the stack method with a full trace table.
Do the BCA 106T notes cover the full GGSIPU syllabus?
Yes. Every topic in the four official BCA 106T units is in the notes, including linked list sorting (page 35) and creation-only AVL, heap, M-way and B-trees (pages 81 to 86).
| Official unit | Official topics | Where in the notes | Status |
|---|---|---|---|
| I: Linear Data Structures, Static | Algorithms, design techniques, time space trade off; arrays, address calculation, sparse matrices; searching, four sorts; hashing | 1.1 to 1.6, p4 to 22 | Covered |
| II: Linear Data Structures, Dynamic | Dynamic vs static memory allocation; singly, circular, doubly linked list; creation, insertion, deletion, modification, searching, sorting, reversing, merging | 2.1 to 2.5, p27 to 42 | Covered |
| III: Abstract Data Types | Stacks: static, dynamic, Polish and reverse Polish notations; queues: linear, circular, doubly ended | 3.1 to 3.5, p47 to 63 | Covered |
| IV: Non Linear Data Structures | Graph representations; binary tree types, recursive traversals, BST; creation of AVL, heap, M-way, B tree | 4.1 to 4.6, p68 to 86 | Covered |
BCA 106T official units mapped to the notes
- Official unit
- I: Linear Data Structures, Static
- Official topics
- Algorithms, design techniques, time space trade off; arrays, address calculation, sparse matrices; searching, four sorts; hashing
- Where in the notes
- 1.1 to 1.6, p4 to 22
- Status
- Covered
- Official unit
- II: Linear Data Structures, Dynamic
- Official topics
- Dynamic vs static memory allocation; singly, circular, doubly linked list; creation, insertion, deletion, modification, searching, sorting, reversing, merging
- Where in the notes
- 2.1 to 2.5, p27 to 42
- Status
- Covered
- Official unit
- III: Abstract Data Types
- Official topics
- Stacks: static, dynamic, Polish and reverse Polish notations; queues: linear, circular, doubly ended
- Where in the notes
- 3.1 to 3.5, p47 to 63
- Status
- Covered
- Official unit
- IV: Non Linear Data Structures
- Official topics
- Graph representations; binary tree types, recursive traversals, BST; creation of AVL, heap, M-way, B tree
- Where in the notes
- 4.1 to 4.6, p68 to 86
- Status
- Covered
Official sources: BCA first-year syllabus, batch 2024-25 onwards and BCA scheme of examination, w.e.f. 2024-25.
Page 62 also adds a short note on priority queues, not named in the official Unit III list. Every course in GGSIPU notes is checked against its official PDF the same way.
How to write BCA 106T answers: trace tables, before-and-after linked list diagrams and ten-mark algorithm answers
The BCA 106T paper rewards working, not essays. The notes use one six-part frame for every ten-mark answer: definition, diagram, algorithm or C program, worked example, complexity, comparison table.
Each unit has its own habit. Unit II: draw the list before and after, number the link changes, then write the function. Unit III: put every conversion in a Symbol, Stack, Output trace table. Unit IV: draw every step when you build a BST, AVL tree, heap or B-tree.
Worked example: one array, two orders (from page 25)
A[1 … 10][1 … 15] has base 100 and w = 2, so M = 10 rows and N = 15 columns. Find A[4][6].
Row-major : 100 + 2 × [15 × (4 − 1) + (6 − 1)] = 200
Column-major: 100 + 2 × [10 × (6 − 1) + (4 − 1)] = 206Row-major multiplies by columns, column-major by rows. Mixing them is the top Unit I mistake in the notes.
Two more slips from those tables: in postfix evaluation the first value popped is the second operand, so 8 4 / gives 2; and the BST inorder successor is the leftmost node of the right subtree, not just the right child. Practise this format on GGSIPU BCA important questions.
BCA 106T exam corner: 48 two-mark and 28 ten-mark solved questions by unit
Two-mark questions have model answers; ten-mark questions have an answer plan naming the figures and programs to use.
| Unit | 2 Marks | 10 Marks | Programs with output |
|---|---|---|---|
| I | 12 | 7 | 8 |
| II | 12 | 7 | 4 |
| III | 12 | 7 | 9 |
| IV | 12 | 7 | 3 |
BCA 106T solved questions and programs per unit
- Unit
- I
- 2 Marks
- 12
- 10 Marks
- 7
- Programs with output
- 8
- Unit
- II
- 2 Marks
- 12
- 10 Marks
- 7
- Programs with output
- 4
- Unit
- III
- 2 Marks
- 12
- 10 Marks
- 7
- Programs with output
- 9
- Unit
- IV
- 2 Marks
- 12
- 10 Marks
- 7
- Programs with output
- 3
- Unit I: A[−5 … 20] has base 1000 and w = 2. Find LOC(A[10]). Pointer: 1000 + 2 × 15 = 1030; 26 elements.
- Unit II: Why is binary search not suitable for a linked list? Pointer: reaching the middle needs a walk from START, so O(log n) is lost.
- Unit III: Evaluate 5 3 + 8 2 − *. Pointer: 8, then 6, then 48.
- Unit IV: What is a strict binary tree? Pointer: every node has 0 or 2 children; n leaves give 2n − 1 nodes.
The BCA 106T notes solve 48 two-mark and 28 ten-mark questions across 4 units, plus 24 programs with output.
More practice sits in the BCA 106T important questions.
Who writes and checks the BCA 106T DSA notes?
- Prateek Talwar, author · Founder, Unnati Educations · ACS, ICSI, since 2019 · B.Com, University of Delhi (SOL) · profile
- Ritik Rawat, subject reviewer · Senior Full Stack Developer, Unnati Educations · B.Tech · reviews the BCA and B.Tech notes · profile
These BCA 106T Data Structures and Algorithms IPU notes print an output block under each of the 24 programs. The same team prepares GGSIPU important questions for every course.
BCA 106T and the BCA 106P DSA lab (20 practicals), plus other GGSIPU BCA Sem 2 papers
BCA 106P DSA lab notes: 20 practicals (10 core + 10 application-based) · CCP · 2 practical hours a week · 1 credit.
Officially, BCA 106P shares the outcomes of BCA 106T and the teacher notifies its practical list. Unit I feeds search, sort and hashing practicals; Unit II linked lists; Unit III stacks and queues; Unit IV graphs, traversals and the BST.
Other Semester 2 papers: BCA 102T Database Management System (DBMS), BCA 104T Object Oriented Programming using Java, BCA 108T Software Engineering, their labs 102P, 104P and 108P, BCA 142T Soft Skills and BCA 192T Environment Studies. The C skills come from BCA 101T in Semester 1; every Unit II node is a C struct.
BCA 106T DSA notes FAQs
What is the passing mark for BCA 106T?
BCA 106T is marked out of 100: 40 internal and 60 end-term, as per the BCA scheme of examination for the 2024-25 batch. The scheme PDF does not print a separate pass percentage for this paper. End-term minimums, grading and re-appear rules are set by GGSIPU Ordinance 11, which the BCA scheme cites. Check the latest copy on ipu.ac.in before your exam.
Which BCA 106T unit has the most C programs?
Unit III, with 9 complete C programs with output: a stack using an array, a stack using a linked list, infix to postfix, postfix and prefix evaluation, postfix to prefix conversion, a linear queue, a linked queue, a circular queue and a deque. Unit I follows with 8, Unit II has 4 and Unit IV has 3, because Unit IV is mostly drawn trees.
Do the BCA 106T notes match the 2024-25 batch syllabus?
Yes. The notes follow the BCA first-year syllabus for the batch admitted in 2024-25 onwards, approved by the Academic Council on 20 Dec 2023. All four official units are mapped topic by topic in the syllabus table on this page. If your college follows an older BCA scheme, compare your unit list with that table before you buy.
Do the BCA 106T notes have C code for AVL trees and B-trees?
No, and that matches the paper. The BCA 106T syllabus asks for introduction and creation of AVL, heap, M-way and B-trees, excluding implementation. So section 4.6 builds each tree step by step from a list of keys, with figures for every rotation and split. The BST in section 4.5 does have full C code for insertion, search and deletion.
How are the BCA 106T notes different from the BCA 106P lab notes?
BCA 106T notes explain the theory for the written end-term paper: definitions, algorithms, diagrams, complexity and solved two-mark and ten-mark questions. BCA 106P lab notes are for practice in the lab: each practical has its aim, logic, C code, output and viva questions. The lab notes are a separate book with their own page and sample.
Get the full BCA 106T Data Structures and Algorithms Notes on WhatsApp
Order these notes in book form through WhatsApp. They are not available in PDF.
These Data Structures and Algorithms notes in English come as one 89-page printed book with a master index, so you can turn straight to any unit while you revise.
| Unit | Pages | Programs | Solved questions |
|---|---|---|---|
| I: Static linear | 23 (p3 to 25) | 8 | 19 |
| II: Dynamic linear | 20 (p26 to 45) | 4 | 19 |
| III: Abstract data types | 21 (p46 to 66) | 9 | 19 |
| IV: Non linear | 23 (p67 to 89) | 3 | 19 |
What the BCA 106T notes book contains, unit by unit
- Unit
- I: Static linear
- Pages
- 23 (p3 to 25)
- Programs
- 8
- Solved questions
- 19
- Unit
- II: Dynamic linear
- Pages
- 20 (p26 to 45)
- Programs
- 4
- Solved questions
- 19
- Unit
- III: Abstract data types
- Pages
- 21 (p46 to 66)
- Programs
- 9
- Solved questions
- 19
- Unit
- IV: Non linear
- Pages
- 23 (p67 to 89)
- Programs
- 3
- Solved questions
- 19
Message us on WhatsApp to place your book order; our desk confirms the order and delivery details in the same chat.
Unnati Educations is an independent education provider based in Vikaspuri, Delhi. We are not affiliated with, authorised by, or endorsed by Guru Gobind Singh Indraprastha University (GGSIPU). 'GGSIPU' and 'IPU' are used only to describe the syllabus our notes follow. For official information, visit ipu.ac.in.
Ready for the full notes?
Discuss coverage and delivery with our team.