B.Sc. (Computer Science) Semester 3: Notes and Solved Previous Year Question Papers 2026

What do you get

• All the notes of all the subjects in Semester 3, as per the latest syllabus 2026.
• The practical subjects too, worked out exercise by exercise: 1 practical book of 31 chapters, beside 5 theory books of 493.
• Previous year question papers, with full solutions. Field Project and Computer Science Practical 3 have no solved papers, so they are not included.
• Your own dashboard, where you can track everything you have read, subject by subject.
• Priority access in our MU B.Sc. (Computer Science) student group. The groups are open, so you can send a message any time.
• Valid for one year, 365 days from the day you pay.
• If the University revises the syllabus while your year is running, the notes are rewritten to match and you read the new version at no extra cost. You are never asked to buy the same semester twice.

1. JAVA Programming

   Official Notes munotes.in

   JAVA Programming

   B.SC. (COMPUTER SCIENCE) · SEMESTER 3

   Strictly as per the University of Mumbai NEP syllabus in force for B.Sc. (Computer Science)

   For B.Sc. (Computer Science) students of the University of Mumbai and all its affiliated colleges

   munotes.in Second Year

   JAVA Programming

   Copyright © 2026 munotes.in. All rights reserved.

   Written and first published by munotes.in, 2026.

   This book is for individual students to read at munotes.in. No part of it may be reproduced, distributed, stored, translated or used for institutional or classroom purposes in any form without a prior written licence from munotes.in.

   Licensing and permissions: contact@munotes.in

   The text of statutes and of judgments reproduced in this book is in the public domain under section 52(1)(q) of the Copyright Act 1957. The commentary, arrangement, examples and questions are the original work of munotes.in.

   munotes.in is an independent study resource for MU students. It is not affiliated with, endorsed by, or officially connected to the University of Mumbai. Course names and university references describe the students and syllabus the material relates to.

   Contents

   Module I Java Basics and OOP, Packages, Exceptions, Multithreading, Collections and JSON

   1. What Java Is, Where It Came From, and Why It Is Still Everywhere 1
   2. The Features of Java, Each One Shown Working 6
   3. The JVM: What Actually Runs Your Program 12
   4. The JDK and the JRE: What You Install, and What Went Away 17
   5. Installing the JDK and Running Your First Program 21
   6. The Structure of a Java Program, Word by Word 26
   7. Tokens: Every Kind of Word a Program Is Made Of 31
   8. Data Types: The Eight Primitives, and What a Reference Is 36
   9. Type Conversion and Casting 42
   10. The Wrapper Classes, Autoboxing and Unboxing 49
   11. Operators, and the Order They Are Applied In 54
   12. Deciding: if, else and switch 61
   13. Repeating: while, do-while, for and the for-each Loop 68
   14. Arrays 74
   15. Strings and the String Class 81
   16. Reading Input: the Scanner and the Command Line 87
   17. Methods 92
   18. The Four Principles of Object-Oriented Programming 98
   19. The Class 103
   20. The Object, the Reference, and the Heap 108

   Contents continued

   Module I continued Java Basics and OOP, Packages, Exceptions, Multithreading, Collections and JSON

   1. Constructors 114
   2. The this Keyword 119
   3. static 123
   4. final 128
   5. Inheritance 133
   6. The super Keyword 141
   7. Polymorphism by Overloading 146
   8. Polymorphism by Overriding, and Dynamic Dispatch 151
   9. Abstraction 157
   10. Encapsulation 162
   11. Abstract Classes 167
   12. Interfaces 172
   13. Inner Classes 178
   14. Anonymous Classes and the Lambda 182
   15. The Object Class: toString, equals and hashCode 188
   16. Predefined Packages and import 194
   17. Writing Your Own Package, and Making a Jar 199
   18. Access Specifiers 204
   19. What an Exception Is, and the Hierarchy 209

   Contents continued

   Module I continued Java Basics and OOP, Packages, Exceptions, Multithreading, Collections and JSON

   1. The Predefined Exceptions, One by One 214
   2. try, catch and finally 219
   3. The throw Statement 225
   4. The throws Clause 230
   5. Writing Your Own Exception 235
   6. What a Thread Is 240
   7. Creating a Thread: Thread and Runnable 245
   8. The Thread Life Cycle 250
   9. Controlling a Thread, and the Three Methods That Are Gone 254
   10. Synchronization, and the Race It Prevents 260
   11. wait, notify and notifyAll: the Producer and the Consumer 266
   12. Deadlock 271
   13. java.util and the Collection Framework 276
   14. Generics, Enough to Use a Collection 281
   15. The Collection Interface and the Iterator 286
   16. The List Interface 291
   17. The Set Interface 295
   18. The Map Interface 299
   19. ArrayList 304

   Contents continued

   Module I continued Java Basics and OOP, Packages, Exceptions, Multithreading, Collections and JSON

   1. LinkedList 308
   2. HashSet 313
   3. TreeSet, Comparable and Comparator 318
   4. HashMap 323
   5. Collections and Arrays: the Utility Methods 328
   6. What JSON Is 333
   7. JSON Syntax, Rule by Rule 337
   8. The JSON Data Types Against Java's 341
   9. JSON with Java 346
   10. How This Paper Is Examined: the Journal, the Write-up and the Viva 350
   11. The Module 1 Practical Set 355

   Module II Swing, JDBC, Servlets, JSP and JSON

   1. The Java Foundation Classes: AWT, Swing and What Came After 363
   2. JFrame: the Window 368
   3. JPanel 373
   4. JButton 377
   5. JTextField and the Text Components 381
   6. JLabel 386

   Contents continued

   Module II continued Swing, JDBC, Servlets, JSP and JSON

   1. The Other Common Swing Components 390
   2. Layouts 395
   3. The Delegation Event Model 401
   4. ActionListener 406
   5. Adapter Classes 411
   6. A Complete Swing Application 416
   7. JDBC Architecture 422
   8. The JDBC Driver Types 427
   9. Connecting to a Database 431
   10. Statement 436
   11. PreparedStatement 440
   12. ResultSet 445
   13. Navigating Data 450
   14. ResultSetMetaData 454
   15. Transactions 459
   16. SQLException 465
   17. A Complete JDBC Program: Create, Read, Update, Delete 471
   18. What a Servlet Is, and What a Container Does 476
   19. Installing Tomcat and Deploying Your First Servlet 480

   Contents continued

   Module II continued Swing, JDBC, Servlets, JSP and JSON

   1. The Servlet Life Cycle 485
   2. The Basic Structure of a Servlet 490
   3. An HTML Form and the Servlet That Answers It 495
   4. The Deployment Descriptor 502
   5. ServletConfig 509
   6. ServletContext 515
   7. RequestDispatcher 522
   8. Response Redirection 528
   9. Session Tracking: Why HTTP Forgets You 535
   10. Cookies 542
   11. URL Rewriting 549
   12. HttpSession 555
   13. The Filter API 564
   14. What a JSP Is, and Its Architecture 572
   15. The JSP Life Cycle 579
   16. Scripting Elements 586
   17. Directives 593
   18. The Implicit Objects 601
   19. Expression Language 607

   Contents continued

   Module II continued Swing, JDBC, Servlets, JSP and JSON

   1. JSTL 614
   2. CRUD with JSP 623
   3. A Session-Managed Web Application, End to End 632
   4. JSON on the Web 642
   5. The JSON Data Types on the Wire 650
   6. JSON with Java: org.json, Gson and Jackson 658
   7. The Module 2 Practical Set 665

   Page 1 onwards

   676 pages in this book. The cover and the contents are above. Everything from page one is in the pass.

   Notes

   2026 Edition, as per the latest syllabus. 676 pages.

   Papers

   Previous year question paper solutions. Revised edition 2026. 2023, 2024

   Every chapter in the notes: 120 chapters across 2 modules

   Module I Java Basics and OOP, Packages, Exceptions, Multithreading, Collections and JSON 69 chapters

   1. 1 What Java Is, Where It Came From, and Why It Is Still Everywhere pages 1 to 5
   2. 2 The Features of Java, Each One Shown Working pages 6 to 11
   3. 3 The JVM: What Actually Runs Your Program pages 12 to 16
   4. 4 The JDK and the JRE: What You Install, and What Went Away pages 17 to 20
   5. 5 Installing the JDK and Running Your First Program pages 21 to 25
   6. 6 The Structure of a Java Program, Word by Word pages 26 to 30
   7. 7 Tokens: Every Kind of Word a Program Is Made Of pages 31 to 35
   8. 8 Data Types: The Eight Primitives, and What a Reference Is pages 36 to 41
   9. 9 Type Conversion and Casting pages 42 to 48
   10. 10 The Wrapper Classes, Autoboxing and Unboxing pages 49 to 53
   11. 11 Operators, and the Order They Are Applied In pages 54 to 60
   12. 12 Deciding: if, else and switch pages 61 to 67
   13. 13 Repeating: while, do-while, for and the for-each Loop pages 68 to 73
   14. 14 Arrays pages 74 to 80
   15. 15 Strings and the String Class pages 81 to 86
   16. 16 Reading Input: the Scanner and the Command Line pages 87 to 91
   17. 17 Methods pages 92 to 97
   18. 18 The Four Principles of Object-Oriented Programming pages 98 to 102
   19. 19 The Class pages 103 to 107
   20. 20 The Object, the Reference, and the Heap pages 108 to 113
   21. 21 Constructors pages 114 to 118
   22. 22 The this Keyword pages 119 to 122
   23. 23 static pages 123 to 127
   24. 24 final pages 128 to 132
   25. 25 Inheritance pages 133 to 140
   26. 26 The super Keyword pages 141 to 145
   27. 27 Polymorphism by Overloading pages 146 to 150
   28. 28 Polymorphism by Overriding, and Dynamic Dispatch pages 151 to 156
   29. 29 Abstraction pages 157 to 161
   30. 30 Encapsulation pages 162 to 166
   31. 31 Abstract Classes pages 167 to 171
   32. 32 Interfaces pages 172 to 177
   33. 33 Inner Classes pages 178 to 181
   34. 34 Anonymous Classes and the Lambda pages 182 to 187
   35. 35 The Object Class: toString, equals and hashCode pages 188 to 193
   36. 36 Predefined Packages and import pages 194 to 198
   37. 37 Writing Your Own Package, and Making a Jar pages 199 to 203
   38. 38 Access Specifiers pages 204 to 208
   39. 39 What an Exception Is, and the Hierarchy pages 209 to 213
   40. 40 The Predefined Exceptions, One by One pages 214 to 218
   41. 41 try, catch and finally pages 219 to 224
   42. 42 The throw Statement pages 225 to 229
   43. 43 The throws Clause pages 230 to 234
   44. 44 Writing Your Own Exception pages 235 to 239
   45. 45 What a Thread Is pages 240 to 244
   46. 46 Creating a Thread: Thread and Runnable pages 245 to 249
   47. 47 The Thread Life Cycle pages 250 to 253
   48. 48 Controlling a Thread, and the Three Methods That Are Gone pages 254 to 259
   49. 49 Synchronization, and the Race It Prevents pages 260 to 265
   50. 50 wait, notify and notifyAll: the Producer and the Consumer pages 266 to 270
   51. 51 Deadlock pages 271 to 275
   52. 52 java.util and the Collection Framework pages 276 to 280
   53. 53 Generics, Enough to Use a Collection pages 281 to 285
   54. 54 The Collection Interface and the Iterator pages 286 to 290
   55. 55 The List Interface pages 291 to 294
   56. 56 The Set Interface pages 295 to 298
   57. 57 The Map Interface pages 299 to 303
   58. 58 ArrayList pages 304 to 307
   59. 59 LinkedList pages 308 to 312
   60. 60 HashSet pages 313 to 317
   61. 61 TreeSet, Comparable and Comparator pages 318 to 322
   62. 62 HashMap pages 323 to 327
   63. 63 Collections and Arrays: the Utility Methods pages 328 to 332
   64. 64 What JSON Is pages 333 to 336
   65. 65 JSON Syntax, Rule by Rule pages 337 to 340
   66. 66 The JSON Data Types Against Java's pages 341 to 345
   67. 67 JSON with Java pages 346 to 349
   68. 68 How This Paper Is Examined: the Journal, the Write-up and the Viva pages 350 to 354
   69. 69 The Module 1 Practical Set pages 355 to 362

   Module II Swing, JDBC, Servlets, JSP and JSON 51 chapters

   1. 70 The Java Foundation Classes: AWT, Swing and What Came After pages 363 to 367
   2. 71 JFrame: the Window pages 368 to 372
   3. 72 JPanel pages 373 to 376
   4. 73 JButton pages 377 to 380
   5. 74 JTextField and the Text Components pages 381 to 385
   6. 75 JLabel pages 386 to 389
   7. 76 The Other Common Swing Components pages 390 to 394
   8. 77 Layouts pages 395 to 400
   9. 78 The Delegation Event Model pages 401 to 405
   10. 79 ActionListener pages 406 to 410
   11. 80 Adapter Classes pages 411 to 415
   12. 81 A Complete Swing Application pages 416 to 421
   13. 82 JDBC Architecture pages 422 to 426
   14. 83 The JDBC Driver Types pages 427 to 430
   15. 84 Connecting to a Database pages 431 to 435
   16. 85 Statement pages 436 to 439
   17. 86 PreparedStatement pages 440 to 444
   18. 87 ResultSet pages 445 to 449
   19. 88 Navigating Data pages 450 to 453
   20. 89 ResultSetMetaData pages 454 to 458
   21. 90 Transactions pages 459 to 464
   22. 91 SQLException pages 465 to 470
   23. 92 A Complete JDBC Program: Create, Read, Update, Delete pages 471 to 475
   24. 93 What a Servlet Is, and What a Container Does pages 476 to 479
   25. 94 Installing Tomcat and Deploying Your First Servlet pages 480 to 484
   26. 95 The Servlet Life Cycle pages 485 to 489
   27. 96 The Basic Structure of a Servlet pages 490 to 494
   28. 97 An HTML Form and the Servlet That Answers It pages 495 to 501
   29. 98 The Deployment Descriptor pages 502 to 508
   30. 99 ServletConfig pages 509 to 514
   31. 100 ServletContext pages 515 to 521
   32. 101 RequestDispatcher pages 522 to 527
   33. 102 Response Redirection pages 528 to 534
   34. 103 Session Tracking: Why HTTP Forgets You pages 535 to 541
   35. 104 Cookies pages 542 to 548
   36. 105 URL Rewriting pages 549 to 554
   37. 106 HttpSession pages 555 to 563
   38. 107 The Filter API pages 564 to 571
   39. 108 What a JSP Is, and Its Architecture pages 572 to 578
   40. 109 The JSP Life Cycle pages 579 to 585
   41. 110 Scripting Elements pages 586 to 592
   42. 111 Directives pages 593 to 600
   43. 112 The Implicit Objects pages 601 to 606
   44. 113 Expression Language pages 607 to 613
   45. 114 JSTL pages 614 to 622
   46. 115 CRUD with JSP pages 623 to 631
   47. 116 A Session-Managed Web Application, End to End pages 632 to 641
   48. 117 JSON on the Web pages 642 to 649
   49. 118 The JSON Data Types on the Wire pages 650 to 657
   50. 119 JSON with Java: org.json, Gson and Jackson pages 658 to 664
   51. 120 The Module 2 Practical Set pages 665 to 676
   Every paper that is solved: 3 papers

   • 2023-24
   • Nov 2024
   • 2022-23

2. Data Structures

   Official Notes munotes.in

   Data Structures

   B.SC. (COMPUTER SCIENCE) · SEMESTER 3

   Strictly as per the University of Mumbai NEP syllabus in force for B.Sc. (Computer Science)

   For B.Sc. (Computer Science) students of the University of Mumbai and all its affiliated colleges

   munotes.in Second Year

   Data Structures

   Copyright © 2026 munotes.in. All rights reserved.

   Written and first published by munotes.in, 2026.

   This book is for individual students to read at munotes.in. No part of it may be reproduced, distributed, stored, translated or used for institutional or classroom purposes in any form without a prior written licence from munotes.in.

   Licensing and permissions: contact@munotes.in

   The text of statutes and of judgments reproduced in this book is in the public domain under section 52(1)(q) of the Copyright Act 1957. The commentary, arrangement, examples and questions are the original work of munotes.in.

   munotes.in is an independent study resource for MU students. It is not affiliated with, endorsed by, or officially connected to the University of Mumbai. Course names and university references describe the students and syllabus the material relates to.

   Contents

   Module I Abstract Data Type, Linked Structures, Stacks and Queues

   1. What a Data Structure Is, and Why the One You Pick Decides Whether the Program Works 1
   2. How This Paper Is Examined, and How to Read This Book 5
   3. Data and Its Types: What a Type Actually Settles 8
   4. The Primitive Types, and Where They Stop 11
   5. Linear and Non-Linear, Static and Dynamic: The Map of the Subject 14
   6. Choosing a Structure: The Three Questions to Ask of Any of Them 17
   7. The Abstract Data Type: A Promise, and a Hidden Representation 20
   8. Why Hiding the Representation Is the Whole Point 23
   9. Writing an ADT of Your Own 26
   10. Judging an ADT: Complete, Minimal, and Honest About Cost 29
   11. The Array: What It Really Is in Memory 32
   12. Where the Array Stops: Insertion, Deletion and Growth 35
   13. The Linked List: The Node, the Chain and the Head 38
   14. The Linked List ADT, and Building an Empty One 41
   15. Traversing a Singly Linked List 44
   16. Searching a Singly Linked List 47
   17. Prepending a Node 50
   18. Appending a Node, and Why It Costs More 53

   Contents continued

   Module I continued Abstract Data Type, Linked Structures, Stacks and Queues

   1. Removing a Node 56
   2. Inserting and Deleting at Any Position 59
   3. What a Singly Linked List Is Good and Bad At 62
   4. The Array Against the Linked List, Measured 65
   5. A Polynomial as a Linked List 68
   6. Adding Two Polynomials 71
   7. Multiplying Polynomials, and What the Representation Costs 74
   8. The Doubly Linked List: The Second Link 77
   9. Insertion and Deletion With Two Links 80
   10. Traversing Both Ways, and the Applications That Need It 84
   11. What the Second Link Costs and What It Buys 87
   12. The Stack: One End, and Why That Is Enough 90
   13. The Stack ADT: Push, Pop, and the Errors 93
   14. A Stack on an Array, With Peek 96
   15. A Stack on Links 99
   16. What a Stack Is Good and Bad At 102
   17. Balanced Delimiters, and Why a Counter Is Not Enough 105
   18. Infix, Prefix and Postfix 108
   19. Infix to Postfix With a Stack 111

   Contents continued

   Module I continued Abstract Data Type, Linked Structures, Stacks and Queues

   1. Evaluating a Postfix Expression 114
   2. Prefix: Converting to It, and Evaluating It 118
   3. The Queue: Two Ends 122
   4. The Queue ADT 125
   5. A Queue on an Array, and the Drift That Ruins It 128
   6. A Queue on Links 131
   7. The Circular Queue: Wrap-Around 134
   8. Full or Empty: Telling Them Apart 137
   9. What a Queue Is Good and Bad At 140
   10. The Deque: Open at Both Ends 143
   11. Job Scheduling With a Queue 146
   12. Module 1 in One Sitting 149

   Module II Trees, Priority Queues and Heaps, Graphs and Hashing

   1. From a Line to a Tree: Why Linear Structures Run Out 153
   2. The Tree ADT: The Words, Said Exactly 156
   3. Height, Depth, Level and Size, and the Relations Between Them 159
   4. What a Tree Buys, and What It Costs 162
   5. The Binary Tree 165

   Contents continued

   Module II continued Trees, Priority Queues and Heaps, Graphs and Hashing

   1. Binary Tree Properties, Proved 168
   2. Full, Complete and Perfect, and Why the Difference Matters 171
   3. Implementing a Binary Tree With Links 174
   4. The Array Representation of a Binary Tree 177
   5. Inorder Traversal 180
   6. Preorder and Postorder Traversal 183
   7. Level Order Traversal, and the Queue It Needs 186
   8. Iterative Traversal, and the Stack It Needs 189
   9. Rebuilding a Tree From Two Traversals 192
   10. The Binary Search Tree: The Invariant 196
   11. Searching a Binary Search Tree 199
   12. Inserting Into a Binary Search Tree 202
   13. Deleting From a Binary Search Tree: The Three Cases 205
   14. Why a Binary Search Tree Degenerates 209
   15. What Balance Means 212
   16. Threaded Binary Trees 216
   17. The AVL Tree and the Balance Factor 220
   18. The Four Rotations 223
   19. Insertion Into an AVL Tree 227

   Contents continued

   Module II continued Trees, Priority Queues and Heaps, Graphs and Hashing

   1. Deletion From an AVL Tree 231
   2. Huffman Coding: The Problem 235
   3. Building the Huffman Tree 238
   4. Why the Huffman Code Is Prefix-Free, and What It Saves 241
   5. The Priority Queue: When First In Is the Wrong Rule 246
   6. The Priority Queue ADT 249
   7. Three Ways to Build One, and What Each Costs 252
   8. The Heap: Shape and Order 255
   9. The Array That Holds a Heap 259
   10. Min-Heap and Max-Heap 263
   11. Heapify: Sifting Up and Sifting Down 266
   12. Building a Heap, and Why It Is Linear 270
   13. Where Priority Queues Are Used 275
   14. What a Graph Is 279
   15. The Vocabulary of Graphs 282
   16. The Graph ADT 285
   17. The Adjacency Matrix 288
   18. The Adjacency List 291
   19. Which Representation: The Costs, Measured 294

   Contents continued

   Module II continued Trees, Priority Queues and Heaps, Graphs and Hashing

   1. Inserting and Deleting Vertices and Edges 299
   2. Breadth First Search 305
   3. Depth First Search 310
   4. Connectivity and Connected Components 315
   5. The Shortest Path in an Unweighted Graph 320
   6. Dijkstra's Algorithm 324
   7. The Idea of Hashing: A Key Turned Into an Address 331
   8. The Hash Table ADT 337
   9. Hash Functions 342
   10. What Makes a Hash Function Good 351
   11. Collisions Are Certain, Not Unlucky 358
   12. Chaining 365
   13. Linear Probing 371
   14. Quadratic Probing and Double Hashing 380
   15. Load Factor and Rehashing 388
   16. What Hashing Buys and What It Gives Up 395
   17. Where Hashing Is Used, and Where It Must Not Be 400
   18. Choosing the Right Structure: The Whole Paper on One Page 406
   19. Module 2 in One Sitting 411

   Page 1 onwards

   415 pages in this book. The cover and the contents are above. Everything from page one is in the pass.

   Notes

   2026 Edition, as per the latest syllabus. 415 pages.

   Papers

   Previous year question paper solutions. Revised edition 2026. 2022, 2024, 2025

   Every chapter in the notes: 111 chapters across 2 modules

   Module I Abstract Data Type, Linked Structures, Stacks and Queues 49 chapters

   1. 1 What a Data Structure Is, and Why the One You Pick Decides Whether the Program Works pages 1 to 4
   2. 2 How This Paper Is Examined, and How to Read This Book pages 5 to 7
   3. 3 Data and Its Types: What a Type Actually Settles pages 8 to 10
   4. 4 The Primitive Types, and Where They Stop pages 11 to 13
   5. 5 Linear and Non-Linear, Static and Dynamic: The Map of the Subject pages 14 to 16
   6. 6 Choosing a Structure: The Three Questions to Ask of Any of Them pages 17 to 19
   7. 7 The Abstract Data Type: A Promise, and a Hidden Representation pages 20 to 22
   8. 8 Why Hiding the Representation Is the Whole Point pages 23 to 25
   9. 9 Writing an ADT of Your Own pages 26 to 28
   10. 10 Judging an ADT: Complete, Minimal, and Honest About Cost pages 29 to 31
   11. 11 The Array: What It Really Is in Memory pages 32 to 34
   12. 12 Where the Array Stops: Insertion, Deletion and Growth pages 35 to 37
   13. 13 The Linked List: The Node, the Chain and the Head pages 38 to 40
   14. 14 The Linked List ADT, and Building an Empty One pages 41 to 43
   15. 15 Traversing a Singly Linked List pages 44 to 46
   16. 16 Searching a Singly Linked List pages 47 to 49
   17. 17 Prepending a Node pages 50 to 52
   18. 18 Appending a Node, and Why It Costs More pages 53 to 55
   19. 19 Removing a Node pages 56 to 58
   20. 20 Inserting and Deleting at Any Position pages 59 to 61
   21. 21 What a Singly Linked List Is Good and Bad At pages 62 to 64
   22. 22 The Array Against the Linked List, Measured pages 65 to 67
   23. 23 A Polynomial as a Linked List pages 68 to 70
   24. 24 Adding Two Polynomials pages 71 to 73
   25. 25 Multiplying Polynomials, and What the Representation Costs pages 74 to 76
   26. 26 The Doubly Linked List: The Second Link pages 77 to 79
   27. 27 Insertion and Deletion With Two Links pages 80 to 83
   28. 28 Traversing Both Ways, and the Applications That Need It pages 84 to 86
   29. 29 What the Second Link Costs and What It Buys pages 87 to 89
   30. 30 The Stack: One End, and Why That Is Enough pages 90 to 92
   31. 31 The Stack ADT: Push, Pop, and the Errors pages 93 to 95
   32. 32 A Stack on an Array, With Peek pages 96 to 98
   33. 33 A Stack on Links pages 99 to 101
   34. 34 What a Stack Is Good and Bad At pages 102 to 104
   35. 35 Balanced Delimiters, and Why a Counter Is Not Enough pages 105 to 107
   36. 36 Infix, Prefix and Postfix pages 108 to 110
   37. 37 Infix to Postfix With a Stack pages 111 to 113
   38. 38 Evaluating a Postfix Expression pages 114 to 117
   39. 39 Prefix: Converting to It, and Evaluating It pages 118 to 121
   40. 40 The Queue: Two Ends pages 122 to 124
   41. 41 The Queue ADT pages 125 to 127
   42. 42 A Queue on an Array, and the Drift That Ruins It pages 128 to 130
   43. 43 A Queue on Links pages 131 to 133
   44. 44 The Circular Queue: Wrap-Around pages 134 to 136
   45. 45 Full or Empty: Telling Them Apart pages 137 to 139
   46. 46 What a Queue Is Good and Bad At pages 140 to 142
   47. 47 The Deque: Open at Both Ends pages 143 to 145
   48. 48 Job Scheduling With a Queue pages 146 to 148
   49. 49 Module 1 in One Sitting pages 149 to 152

   Module II Trees, Priority Queues and Heaps, Graphs and Hashing 62 chapters

   1. 50 From a Line to a Tree: Why Linear Structures Run Out pages 153 to 155
   2. 51 The Tree ADT: The Words, Said Exactly pages 156 to 158
   3. 52 Height, Depth, Level and Size, and the Relations Between Them pages 159 to 161
   4. 53 What a Tree Buys, and What It Costs pages 162 to 164
   5. 54 The Binary Tree pages 165 to 167
   6. 55 Binary Tree Properties, Proved pages 168 to 170
   7. 56 Full, Complete and Perfect, and Why the Difference Matters pages 171 to 173
   8. 57 Implementing a Binary Tree With Links pages 174 to 176
   9. 58 The Array Representation of a Binary Tree pages 177 to 179
   10. 59 Inorder Traversal pages 180 to 182
   11. 60 Preorder and Postorder Traversal pages 183 to 185
   12. 61 Level Order Traversal, and the Queue It Needs pages 186 to 188
   13. 62 Iterative Traversal, and the Stack It Needs pages 189 to 191
   14. 63 Rebuilding a Tree From Two Traversals pages 192 to 195
   15. 64 The Binary Search Tree: The Invariant pages 196 to 198
   16. 65 Searching a Binary Search Tree pages 199 to 201
   17. 66 Inserting Into a Binary Search Tree pages 202 to 204
   18. 67 Deleting From a Binary Search Tree: The Three Cases pages 205 to 208
   19. 68 Why a Binary Search Tree Degenerates pages 209 to 211
   20. 69 What Balance Means pages 212 to 215
   21. 70 Threaded Binary Trees pages 216 to 219
   22. 71 The AVL Tree and the Balance Factor pages 220 to 222
   23. 72 The Four Rotations pages 223 to 226
   24. 73 Insertion Into an AVL Tree pages 227 to 230
   25. 74 Deletion From an AVL Tree pages 231 to 234
   26. 75 Huffman Coding: The Problem pages 235 to 237
   27. 76 Building the Huffman Tree pages 238 to 240
   28. 77 Why the Huffman Code Is Prefix-Free, and What It Saves pages 241 to 245
   29. 78 The Priority Queue: When First In Is the Wrong Rule pages 246 to 248
   30. 79 The Priority Queue ADT pages 249 to 251
   31. 80 Three Ways to Build One, and What Each Costs pages 252 to 254
   32. 81 The Heap: Shape and Order pages 255 to 258
   33. 82 The Array That Holds a Heap pages 259 to 262
   34. 83 Min-Heap and Max-Heap pages 263 to 265
   35. 84 Heapify: Sifting Up and Sifting Down pages 266 to 269
   36. 85 Building a Heap, and Why It Is Linear pages 270 to 274
   37. 86 Where Priority Queues Are Used pages 275 to 278
   38. 87 What a Graph Is pages 279 to 281
   39. 88 The Vocabulary of Graphs pages 282 to 284
   40. 89 The Graph ADT pages 285 to 287
   41. 90 The Adjacency Matrix pages 288 to 290
   42. 91 The Adjacency List pages 291 to 293
   43. 92 Which Representation: The Costs, Measured pages 294 to 298
   44. 93 Inserting and Deleting Vertices and Edges pages 299 to 304
   45. 94 Breadth First Search pages 305 to 309
   46. 95 Depth First Search pages 310 to 314
   47. 96 Connectivity and Connected Components pages 315 to 319
   48. 97 The Shortest Path in an Unweighted Graph pages 320 to 323
   49. 98 Dijkstra's Algorithm pages 324 to 330
   50. 99 The Idea of Hashing: A Key Turned Into an Address pages 331 to 336
   51. 100 The Hash Table ADT pages 337 to 341
   52. 101 Hash Functions pages 342 to 350
   53. 102 What Makes a Hash Function Good pages 351 to 357
   54. 103 Collisions Are Certain, Not Unlucky pages 358 to 364
   55. 104 Chaining pages 365 to 370
   56. 105 Linear Probing pages 371 to 379
   57. 106 Quadratic Probing and Double Hashing pages 380 to 387
   58. 107 Load Factor and Rehashing pages 388 to 394
   59. 108 What Hashing Buys and What It Gives Up pages 395 to 399
   60. 109 Where Hashing Is Used, and Where It Must Not Be pages 400 to 405
   61. 110 Choosing the Right Structure: The Whole Paper on One Page pages 406 to 410
   62. 111 Module 2 in One Sitting pages 411 to 415
   Every paper that is solved: 4 papers

   • Oct 2025
   • 2023-24
   • Nov 2024
   • Oct 2022

3. Principles of Operating Systems

   Official Notes munotes.in

   Principles of Operating Systems

   B.SC. (COMPUTER SCIENCE) · SEMESTER 3

   Strictly as per the University of Mumbai NEP syllabus in force for B.Sc. (Computer Science)

   For B.Sc. (Computer Science) students of the University of Mumbai and all its affiliated colleges

   munotes.in Second Year

   Principles of Operating Systems

   Copyright © 2026 munotes.in. All rights reserved.

   Written and first published by munotes.in, 2026.

   This book is for individual students to read at munotes.in. No part of it may be reproduced, distributed, stored, translated or used for institutional or classroom purposes in any form without a prior written licence from munotes.in.

   Licensing and permissions: contact@munotes.in

   The text of statutes and of judgments reproduced in this book is in the public domain under section 52(1)(q) of the Copyright Act 1957. The commentary, arrangement, examples and questions are the original work of munotes.in.

   munotes.in is an independent study resource for MU students. It is not affiliated with, endorsed by, or officially connected to the University of Mumbai. Course names and university references describe the students and syllabus the material relates to.

   Contents

   Module I Fundamentals of Operating Systems, Processes and Threads, Process Synchronization, and CPU Scheduling

   1. What an Operating System Is 1
   2. The Two Jobs: Handing Out the Machine, and Hiding It 5
   3. Interrupts, Traps and the Two Modes 10
   4. The Timer, and Why the Operating System Always Gets the Processor Back 15
   5. The Functions of an Operating System 20
   6. Where Operating Systems Run 24
   7. The Services an Operating System Offers 28
   8. The Command Line and the Desktop 32
   9. What a System Call Is 36
   10. Watching System Calls Happen 40
   11. The Six Families of System Call 44
   12. How an Operating System Is Built 48
   13. Microkernels, Modules and What Linux Actually Is 51
   14. What a Process Is 55
   15. The Five States of a Process 59
   16. The Process Control Block 63
   17. The Queues, the Schedulers and the Context Switch 67
   18. Creating a Process: fork 71
   19. Running a Different Program: exec 75
   20. Waiting, Exiting, the Zombie and the Orphan 79

   Contents continued

   Module I continued Fundamentals of Operating Systems, Processes and Threads, Process Synchronization, and CPU Scheduling

   1. Inter-process Communication: The Two Models 84
   2. Shared Memory, in Code That Runs 88
   3. Pipes 92
   4. Message Queues 96
   5. Blocking and Non-blocking Communication 100
   6. What a Thread Is 104
   7. Making Threads, and Waiting for Them 108
   8. Multicore Programming, and the Limit on It 112
   9. The Three Multithreading Models 116
   10. Thread Pools, and Handing Work Out 120
   11. Measuring It: Sequential Against Threaded 124
   12. The Shape of Every Concurrent Program 129
   13. A Race Condition, Made to Happen 133
   14. The Critical Section Problem, and the Three Conditions 138
   15. Peterson's Solution 142
   16. Hardware Help: Test and Set, and Compare and Swap 146
   17. The Mutex Lock 150
   18. The Semaphore 154
   19. The Bounded Buffer, Solved 158

   Contents continued

   Module I continued Fundamentals of Operating Systems, Processes and Threads, Process Synchronization, and CPU Scheduling

   1. The Readers and the Writers 163
   2. The Dining Philosophers 167
   3. Monitors and Condition Variables 172
   4. Why Scheduling Exists: The Burst Cycle 177
   5. The Dispatcher, Preemption, and What a Switch Costs 181
   6. The Five Criteria, and the Arithmetic of Each 185
   7. Reading and Drawing a Gantt Chart 188
   8. First Come First Served 191
   9. Shortest Job First 194
   10. Shortest Remaining Time First 197
   11. Priority Scheduling, Starvation and Ageing 200
   12. Round Robin, and Choosing the Quantum 203
   13. Multilevel Queue Scheduling 206
   14. Multilevel Feedback Queue Scheduling 209
   15. All Seven Algorithms on One Problem 213
   16. Thread Scheduling, and What Linux Actually Does 217

   Module II Deadlocks, Memory Management, Virtual Memory and Mass Storage, and the File System

   1. What a Deadlock Is, and the System Model 221
   2. The Four Conditions 225

   Contents continued

   Module II continued Deadlocks, Memory Management, Virtual Memory and Mass Storage, and the File System

   1. The Resource Allocation Graph 229
   2. The Four Ways to Handle a Deadlock 233
   3. Deadlock Prevention 236
   4. Safe States, and Avoidance 240
   5. The Banker's Algorithm 244
   6. The Resource Request Algorithm 248
   7. Deadlock Detection 252
   8. Recovery from Deadlock 257
   9. Why Memory Needs Managing 261
   10. Binding an Address: Compile, Load, Run 265
   11. The Memory Management Unit 269
   12. Swapping 273
   13. Contiguous Allocation, and the Holes It Leaves 277
   14. First Fit, Best Fit and Worst Fit 281
   15. Fragmentation, Internal and External 285
   16. Segmentation 289
   17. Paging 293
   18. Splitting an Address, and Translating One 298
   19. The TLB, and the Effective Access Time 302

   Contents continued

   Module II continued Deadlocks, Memory Management, Virtual Memory and Mass Storage, and the File System

   1. Protection and Sharing in a Paged System 307
   2. The Page Table Is Too Big: Hierarchical Paging 312
   3. Hashed and Inverted Page Tables 317
   4. Virtual Memory: Running What Will Not Fit 321
   5. Demand Paging, and the Page Fault 326
   6. The Effective Access Time Under Demand Paging 331
   7. Copy on Write 335
   8. Page Replacement: The Problem 340
   9. FIFO Replacement, and Belady's Anomaly 344
   10. Optimal Replacement 348
   11. LRU Replacement 351
   12. Second Chance, and the Counting Algorithms 355
   13. Comparing the Algorithms, and the Hit Ratio 360
   14. Allocation of Frames 364
   15. Thrashing, and the Working Set 368
   16. What a Disk Is, and What It Costs 373
   17. Disk Structure, and the Logical Block 377
   18. Disk Scheduling: FCFS and SSTF 381
   19. SCAN, C-SCAN, LOOK and C-LOOK 385

   Contents continued

   Module II continued Deadlocks, Memory Management, Virtual Memory and Mass Storage, and the File System

   1. Random Scheduling, and All Six Compared 389
   2. Disk Management 392
   3. What a File Is 397
   4. Opening a File, and What the Kernel Keeps 401
   5. Access Methods 405
   6. Directories, and the Shapes They Take 409
   7. Mounting 415
   8. File Sharing, and Locking 419
   9. The Layers a Read Passes Through 424
   10. On the Disk: Superblock, Inode, Data Blocks 428
   11. Directory Implementation 432
   12. Contiguous and Linked Allocation 436
   13. Indexed Allocation, and What a Real File System Does 441
   14. Free Space Management 446
   15. Designing a Small File System 451

   Page 1 onwards

   455 pages in this book. The cover and the contents are above. Everything from page one is in the pass.

   Notes

   2026 Edition, as per the latest syllabus. 455 pages.

   Papers

   Previous year question paper solutions. Revised edition 2026. 2022, 2024, 2025

   Every chapter in the notes: 110 chapters across 2 modules

   Module I Fundamentals of Operating Systems, Processes and Threads, Process Synchronization, and CPU Scheduling 55 chapters

   1. 1 What an Operating System Is pages 1 to 4
   2. 2 The Two Jobs: Handing Out the Machine, and Hiding It pages 5 to 9
   3. 3 Interrupts, Traps and the Two Modes pages 10 to 14
   4. 4 The Timer, and Why the Operating System Always Gets the Processor Back pages 15 to 19
   5. 5 The Functions of an Operating System pages 20 to 23
   6. 6 Where Operating Systems Run pages 24 to 27
   7. 7 The Services an Operating System Offers pages 28 to 31
   8. 8 The Command Line and the Desktop pages 32 to 35
   9. 9 What a System Call Is pages 36 to 39
   10. 10 Watching System Calls Happen pages 40 to 43
   11. 11 The Six Families of System Call pages 44 to 47
   12. 12 How an Operating System Is Built pages 48 to 50
   13. 13 Microkernels, Modules and What Linux Actually Is pages 51 to 54
   14. 14 What a Process Is pages 55 to 58
   15. 15 The Five States of a Process pages 59 to 62
   16. 16 The Process Control Block pages 63 to 66
   17. 17 The Queues, the Schedulers and the Context Switch pages 67 to 70
   18. 18 Creating a Process: fork pages 71 to 74
   19. 19 Running a Different Program: exec pages 75 to 78
   20. 20 Waiting, Exiting, the Zombie and the Orphan pages 79 to 83
   21. 21 Inter-process Communication: The Two Models pages 84 to 87
   22. 22 Shared Memory, in Code That Runs pages 88 to 91
   23. 23 Pipes pages 92 to 95
   24. 24 Message Queues pages 96 to 99
   25. 25 Blocking and Non-blocking Communication pages 100 to 103
   26. 26 What a Thread Is pages 104 to 107
   27. 27 Making Threads, and Waiting for Them pages 108 to 111
   28. 28 Multicore Programming, and the Limit on It pages 112 to 115
   29. 29 The Three Multithreading Models pages 116 to 119
   30. 30 Thread Pools, and Handing Work Out pages 120 to 123
   31. 31 Measuring It: Sequential Against Threaded pages 124 to 128
   32. 32 The Shape of Every Concurrent Program pages 129 to 132
   33. 33 A Race Condition, Made to Happen pages 133 to 137
   34. 34 The Critical Section Problem, and the Three Conditions pages 138 to 141
   35. 35 Peterson's Solution pages 142 to 145
   36. 36 Hardware Help: Test and Set, and Compare and Swap pages 146 to 149
   37. 37 The Mutex Lock pages 150 to 153
   38. 38 The Semaphore pages 154 to 157
   39. 39 The Bounded Buffer, Solved pages 158 to 162
   40. 40 The Readers and the Writers pages 163 to 166
   41. 41 The Dining Philosophers pages 167 to 171
   42. 42 Monitors and Condition Variables pages 172 to 176
   43. 43 Why Scheduling Exists: The Burst Cycle pages 177 to 180
   44. 44 The Dispatcher, Preemption, and What a Switch Costs pages 181 to 184
   45. 45 The Five Criteria, and the Arithmetic of Each pages 185 to 187
   46. 46 Reading and Drawing a Gantt Chart pages 188 to 190
   47. 47 First Come First Served pages 191 to 193
   48. 48 Shortest Job First pages 194 to 196
   49. 49 Shortest Remaining Time First pages 197 to 199
   50. 50 Priority Scheduling, Starvation and Ageing pages 200 to 202
   51. 51 Round Robin, and Choosing the Quantum pages 203 to 205
   52. 52 Multilevel Queue Scheduling pages 206 to 208
   53. 53 Multilevel Feedback Queue Scheduling pages 209 to 212
   54. 54 All Seven Algorithms on One Problem pages 213 to 216
   55. 55 Thread Scheduling, and What Linux Actually Does pages 217 to 220

   Module II Deadlocks, Memory Management, Virtual Memory and Mass Storage, and the File System 55 chapters

   1. 56 What a Deadlock Is, and the System Model pages 221 to 224
   2. 57 The Four Conditions pages 225 to 228
   3. 58 The Resource Allocation Graph pages 229 to 232
   4. 59 The Four Ways to Handle a Deadlock pages 233 to 235
   5. 60 Deadlock Prevention pages 236 to 239
   6. 61 Safe States, and Avoidance pages 240 to 243
   7. 62 The Banker's Algorithm pages 244 to 247
   8. 63 The Resource Request Algorithm pages 248 to 251
   9. 64 Deadlock Detection pages 252 to 256
   10. 65 Recovery from Deadlock pages 257 to 260
   11. 66 Why Memory Needs Managing pages 261 to 264
   12. 67 Binding an Address: Compile, Load, Run pages 265 to 268
   13. 68 The Memory Management Unit pages 269 to 272
   14. 69 Swapping pages 273 to 276
   15. 70 Contiguous Allocation, and the Holes It Leaves pages 277 to 280
   16. 71 First Fit, Best Fit and Worst Fit pages 281 to 284
   17. 72 Fragmentation, Internal and External pages 285 to 288
   18. 73 Segmentation pages 289 to 292
   19. 74 Paging pages 293 to 297
   20. 75 Splitting an Address, and Translating One pages 298 to 301
   21. 76 The TLB, and the Effective Access Time pages 302 to 306
   22. 77 Protection and Sharing in a Paged System pages 307 to 311
   23. 78 The Page Table Is Too Big: Hierarchical Paging pages 312 to 316
   24. 79 Hashed and Inverted Page Tables pages 317 to 320
   25. 80 Virtual Memory: Running What Will Not Fit pages 321 to 325
   26. 81 Demand Paging, and the Page Fault pages 326 to 330
   27. 82 The Effective Access Time Under Demand Paging pages 331 to 334
   28. 83 Copy on Write pages 335 to 339
   29. 84 Page Replacement: The Problem pages 340 to 343
   30. 85 FIFO Replacement, and Belady's Anomaly pages 344 to 347
   31. 86 Optimal Replacement pages 348 to 350
   32. 87 LRU Replacement pages 351 to 354
   33. 88 Second Chance, and the Counting Algorithms pages 355 to 359
   34. 89 Comparing the Algorithms, and the Hit Ratio pages 360 to 363
   35. 90 Allocation of Frames pages 364 to 367
   36. 91 Thrashing, and the Working Set pages 368 to 372
   37. 92 What a Disk Is, and What It Costs pages 373 to 376
   38. 93 Disk Structure, and the Logical Block pages 377 to 380
   39. 94 Disk Scheduling: FCFS and SSTF pages 381 to 384
   40. 95 SCAN, C-SCAN, LOOK and C-LOOK pages 385 to 388
   41. 96 Random Scheduling, and All Six Compared pages 389 to 391
   42. 97 Disk Management pages 392 to 396
   43. 98 What a File Is pages 397 to 400
   44. 99 Opening a File, and What the Kernel Keeps pages 401 to 404
   45. 100 Access Methods pages 405 to 408
   46. 101 Directories, and the Shapes They Take pages 409 to 414
   47. 102 Mounting pages 415 to 418
   48. 103 File Sharing, and Locking pages 419 to 423
   49. 104 The Layers a Read Passes Through pages 424 to 427
   50. 105 On the Disk: Superblock, Inode, Data Blocks pages 428 to 431
   51. 106 Directory Implementation pages 432 to 435
   52. 107 Contiguous and Linked Allocation pages 436 to 440
   53. 108 Indexed Allocation, and What a Real File System Does pages 441 to 445
   54. 109 Free Space Management pages 446 to 450
   55. 110 Designing a Small File System pages 451 to 455
   Every paper that is solved: 4 papers

   • Oct 2025
   • 2023-24
   • Nov 2024
   • Oct 2022

4. Theory of Computation

   Official Notes munotes.in

   Theory of Computation

   B.SC. (COMPUTER SCIENCE) · SEMESTER 3

   Strictly as per the University of Mumbai NEP syllabus in force for B.Sc. (Computer Science)

   For B.Sc. (Computer Science) students of the University of Mumbai and all its affiliated colleges

   munotes.in Second Year

   Theory of Computation

   Copyright © 2026 munotes.in. All rights reserved.

   Written and first published by munotes.in, 2026.

   This book is for individual students to read at munotes.in. No part of it may be reproduced, distributed, stored, translated or used for institutional or classroom purposes in any form without a prior written licence from munotes.in.

   Licensing and permissions: contact@munotes.in

   The text of statutes and of judgments reproduced in this book is in the public domain under section 52(1)(q) of the Copyright Act 1957. The commentary, arrangement, examples and questions are the original work of munotes.in.

   munotes.in is an independent study resource for MU students. It is not affiliated with, endorsed by, or officially connected to the University of Mumbai. Course names and university references describe the students and syllabus the material relates to.

   Contents

   Module I Introduction to Theory of Computation, Automata Theory, Formal Languages, Regular Languages and Context Free Languages

   1. What This Subject Is About, and the Four Questions It Answers 1
   2. Sets: The Vocabulary Everything Else Is Written In 6
   3. Alphabets, Strings and Languages 11
   4. Relations, and the Equivalence Relation That Runs Through This Subject 16
   5. Functions: What the Transition Function Actually Is 21
   6. Proof Techniques: Five Ways to Be Sure 25
   7. Counting the Uncountable: Diagonalisation, and Why Some Languages Have No Machine 30
   8. What an Automaton Is 35
   9. The Deterministic Finite Automaton, Formally 40
   10. Transitions and Their Properties: the Function, the Table and the Diagram 44
   11. The Extended Transition Function: What a Machine Does to a Whole String 49
   12. Acceptability: When a Machine Accepts a String, and What Language It Accepts 53
   13. Designing a DFA: the Method, and Eight Machines Built With It 58
   14. Nondeterminism, and the Nondeterministic Finite Automaton 64
   15. Empty Moves, and the Epsilon Closure 69
   16. DFA and NDFA Equivalence: the Subset Construction 74
   17. Removing the Empty Moves 80

   Contents continued

   Module I continued Introduction to Theory of Computation, Automata Theory, Formal Languages, Regular Languages and Context Free Languages

   1. Mealy and Moore Machines: a Machine That Writes 84
   2. Converting a Moore Machine to a Mealy Machine, and Back 88
   3. Minimizing Automata: the Partition Method 93
   4. The Myhill Nerode Theorem, and a Second Way to Prove a Language Not Regular 99
   5. What a Grammar Is 105
   6. Derivations: How a Grammar Makes a String 110
   7. The Language Generated by a Grammar, and Proving It Is the One You Claim 115
   8. Writing a Grammar for a Language You Are Given 120
   9. The Chomsky Classification of Grammars and Languages 126
   10. Recursive and Recursively Enumerable Sets 132
   11. Operations on Languages 137
   12. Languages and Automata: Which Machine Goes With Which Grammar 144
   13. Regular Grammar: the Right Linear and Left Linear Forms 149
   14. Regular Expressions 154
   15. The Identities of Regular Expressions 159
   16. Writing a Regular Expression for a Language You Are Given 164
   17. From a Regular Expression to a Finite Automaton 170

   Contents continued

   Module I continued Introduction to Theory of Computation, Automata Theory, Formal Languages, Regular Languages and Context Free Languages

   1. From a Finite Automaton to a Regular Expression: Arden's Theorem and State Elimination 175
   2. The Pumping Lemma for Regular Languages 181
   3. Applications of the Pumping Lemma 187
   4. Closure Properties of the Regular Languages 193
   5. The Decision Problems of the Regular Languages 199
   6. Regular Sets and Regular Grammar: Kleene's Theorem Assembled 204
   7. Context Free Grammars and Context Free Languages 209
   8. The Derivation Tree 214
   9. Leftmost and Rightmost Derivations 219
   10. Ambiguity of a Grammar 223
   11. Simplifying a Grammar, One: Useless Symbols 228
   12. Simplifying a Grammar, Two: Null Productions 233
   13. Simplifying a Grammar, Three: Unit Productions, and the Reduced Grammar 238
   14. Chomsky Normal Form 243
   15. Greibach Normal Form 248
   16. The Pumping Lemma for Context Free Languages 254
   17. Closure Properties and Decision Problems of the Context Free Languages 261

   Contents continued

   Module II Pushdown Automata, Linear Bound Automata, Turing Machines, and Computability and Complexity

   1. The Pushdown Automaton 268
   2. Instantaneous Descriptions and Moves 274
   3. Acceptance by a PDA: by Final State and by Empty Stack 279
   4. Designing a PDA: the Balanced Languages 284
   5. Designing a PDA: Palindromes, and Counting Two Things at Once 289
   6. The Deterministic Pushdown Automaton 295
   7. From a Context Free Grammar to a Pushdown Automaton 300
   8. From a Pushdown Automaton to a Context Free Grammar 305
   9. The Linear Bounded Automaton Model 310
   10. Linear Bounded Automata and the Context Sensitive Languages 315
   11. The Turing Machine 320
   12. Representations of a Turing Machine 325
   13. Acceptability by a Turing Machine: Accept, Reject and Loop 330
   14. Designing and Describing a Turing Machine 335
   15. Turing Machine Construction: Machines That Recognise 340
   16. Turing Machine Construction: Machines That Compute 345
   17. Variants of the Turing Machine: More Tapes, More Tracks, More Heads 350
   18. Variants of the Turing Machine: Nondeterministic, Offline, and the Enumerator 355

   Contents continued

   Module II continued Pushdown Automata, Linear Bound Automata, Turing Machines, and Computability and Complexity

   1. Recursive and Recursively Enumerable Languages 360
   2. Decidable and Undecidable, and What the Complement Tells You 364
   3. The Church Turing Thesis 368
   4. The Universal Turing Machine 373
   5. The Halting Problem 378
   6. Reduction: Proving a Second Problem Unsolvable 383
   7. Rice's Theorem 388
   8. The Post Correspondence Problem, and the Undecidable Problems of Grammars 393
   9. Time Complexity 398
   10. Space Complexity 403
   11. Big O Notation, and the Family Around It 408
   12. Class P 413
   13. Class NP, and the Certificate 418
   14. Polynomial Reductions 423
   15. NP Complete and NP Hard, and Cook's Theorem 429
   16. Proving a Problem NP Complete: Three Reductions Worked 435
   17. Complexity Hierarchies, and the P Against NP Question 441
   18. The Machines and the Grammars, Side by Side 446

   Page 1 onwards

   450 pages in this book. The cover and the contents are above. Everything from page one is in the pass.

   Notes

   2026 Edition, as per the latest syllabus. 450 pages.

   Papers

   Previous year question paper solutions. Revised edition 2026. 2025

   Every chapter in the notes: 87 chapters across 2 modules

   Module I Introduction to Theory of Computation, Automata Theory, Formal Languages, Regular Languages and Context Free Languages 51 chapters

   1. 1 What This Subject Is About, and the Four Questions It Answers pages 1 to 5
   2. 2 Sets: The Vocabulary Everything Else Is Written In pages 6 to 10
   3. 3 Alphabets, Strings and Languages pages 11 to 15
   4. 4 Relations, and the Equivalence Relation That Runs Through This Subject pages 16 to 20
   5. 5 Functions: What the Transition Function Actually Is pages 21 to 24
   6. 6 Proof Techniques: Five Ways to Be Sure pages 25 to 29
   7. 7 Counting the Uncountable: Diagonalisation, and Why Some Languages Have No Machine pages 30 to 34
   8. 8 What an Automaton Is pages 35 to 39
   9. 9 The Deterministic Finite Automaton, Formally pages 40 to 43
   10. 10 Transitions and Their Properties: the Function, the Table and the Diagram pages 44 to 48
   11. 11 The Extended Transition Function: What a Machine Does to a Whole String pages 49 to 52
   12. 12 Acceptability: When a Machine Accepts a String, and What Language It Accepts pages 53 to 57
   13. 13 Designing a DFA: the Method, and Eight Machines Built With It pages 58 to 63
   14. 14 Nondeterminism, and the Nondeterministic Finite Automaton pages 64 to 68
   15. 15 Empty Moves, and the Epsilon Closure pages 69 to 73
   16. 16 DFA and NDFA Equivalence: the Subset Construction pages 74 to 79
   17. 17 Removing the Empty Moves pages 80 to 83
   18. 18 Mealy and Moore Machines: a Machine That Writes pages 84 to 87
   19. 19 Converting a Moore Machine to a Mealy Machine, and Back pages 88 to 92
   20. 20 Minimizing Automata: the Partition Method pages 93 to 98
   21. 21 The Myhill Nerode Theorem, and a Second Way to Prove a Language Not Regular pages 99 to 104
   22. 22 What a Grammar Is pages 105 to 109
   23. 23 Derivations: How a Grammar Makes a String pages 110 to 114
   24. 24 The Language Generated by a Grammar, and Proving It Is the One You Claim pages 115 to 119
   25. 25 Writing a Grammar for a Language You Are Given pages 120 to 125
   26. 26 The Chomsky Classification of Grammars and Languages pages 126 to 131
   27. 27 Recursive and Recursively Enumerable Sets pages 132 to 136
   28. 28 Operations on Languages pages 137 to 143
   29. 29 Languages and Automata: Which Machine Goes With Which Grammar pages 144 to 148
   30. 30 Regular Grammar: the Right Linear and Left Linear Forms pages 149 to 153
   31. 31 Regular Expressions pages 154 to 158
   32. 32 The Identities of Regular Expressions pages 159 to 163
   33. 33 Writing a Regular Expression for a Language You Are Given pages 164 to 169
   34. 34 From a Regular Expression to a Finite Automaton pages 170 to 174
   35. 35 From a Finite Automaton to a Regular Expression: Arden's Theorem and State Elimination pages 175 to 180
   36. 36 The Pumping Lemma for Regular Languages pages 181 to 186
   37. 37 Applications of the Pumping Lemma pages 187 to 192
   38. 38 Closure Properties of the Regular Languages pages 193 to 198
   39. 39 The Decision Problems of the Regular Languages pages 199 to 203
   40. 40 Regular Sets and Regular Grammar: Kleene's Theorem Assembled pages 204 to 208
   41. 41 Context Free Grammars and Context Free Languages pages 209 to 213
   42. 42 The Derivation Tree pages 214 to 218
   43. 43 Leftmost and Rightmost Derivations pages 219 to 222
   44. 44 Ambiguity of a Grammar pages 223 to 227
   45. 45 Simplifying a Grammar, One: Useless Symbols pages 228 to 232
   46. 46 Simplifying a Grammar, Two: Null Productions pages 233 to 237
   47. 47 Simplifying a Grammar, Three: Unit Productions, and the Reduced Grammar pages 238 to 242
   48. 48 Chomsky Normal Form pages 243 to 247
   49. 49 Greibach Normal Form pages 248 to 253
   50. 50 The Pumping Lemma for Context Free Languages pages 254 to 260
   51. 51 Closure Properties and Decision Problems of the Context Free Languages pages 261 to 267

   Module II Pushdown Automata, Linear Bound Automata, Turing Machines, and Computability and Complexity 36 chapters

   1. 52 The Pushdown Automaton pages 268 to 273
   2. 53 Instantaneous Descriptions and Moves pages 274 to 278
   3. 54 Acceptance by a PDA: by Final State and by Empty Stack pages 279 to 283
   4. 55 Designing a PDA: the Balanced Languages pages 284 to 288
   5. 56 Designing a PDA: Palindromes, and Counting Two Things at Once pages 289 to 294
   6. 57 The Deterministic Pushdown Automaton pages 295 to 299
   7. 58 From a Context Free Grammar to a Pushdown Automaton pages 300 to 304
   8. 59 From a Pushdown Automaton to a Context Free Grammar pages 305 to 309
   9. 60 The Linear Bounded Automaton Model pages 310 to 314
   10. 61 Linear Bounded Automata and the Context Sensitive Languages pages 315 to 319
   11. 62 The Turing Machine pages 320 to 324
   12. 63 Representations of a Turing Machine pages 325 to 329
   13. 64 Acceptability by a Turing Machine: Accept, Reject and Loop pages 330 to 334
   14. 65 Designing and Describing a Turing Machine pages 335 to 339
   15. 66 Turing Machine Construction: Machines That Recognise pages 340 to 344
   16. 67 Turing Machine Construction: Machines That Compute pages 345 to 349
   17. 68 Variants of the Turing Machine: More Tapes, More Tracks, More Heads pages 350 to 354
   18. 69 Variants of the Turing Machine: Nondeterministic, Offline, and the Enumerator pages 355 to 359
   19. 70 Recursive and Recursively Enumerable Languages pages 360 to 363
   20. 71 Decidable and Undecidable, and What the Complement Tells You pages 364 to 367
   21. 72 The Church Turing Thesis pages 368 to 372
   22. 73 The Universal Turing Machine pages 373 to 377
   23. 74 The Halting Problem pages 378 to 382
   24. 75 Reduction: Proving a Second Problem Unsolvable pages 383 to 387
   25. 76 Rice's Theorem pages 388 to 392
   26. 77 The Post Correspondence Problem, and the Undecidable Problems of Grammars pages 393 to 397
   27. 78 Time Complexity pages 398 to 402
   28. 79 Space Complexity pages 403 to 407
   29. 80 Big O Notation, and the Family Around It pages 408 to 412
   30. 81 Class P pages 413 to 417
   31. 82 Class NP, and the Certificate pages 418 to 422
   32. 83 Polynomial Reductions pages 423 to 428
   33. 84 NP Complete and NP Hard, and Cook's Theorem pages 429 to 434
   34. 85 Proving a Problem NP Complete: Three Reductions Worked pages 435 to 440
   35. 86 Complexity Hierarchies, and the P Against NP Question pages 441 to 445
   36. 87 The Machines and the Grammars, Side by Side pages 446 to 450
   Every paper that is solved: 1 paper

   • Oct 2025

5. Field Project

   Official Notes munotes.in

   Field Project

   B.SC. (COMPUTER SCIENCE) · SEMESTER 3

   Strictly as per the University of Mumbai NEP syllabus in force for B.Sc. (Computer Science)

   For B.Sc. (Computer Science) students of the University of Mumbai and all its affiliated colleges

   munotes.in Second Year

   Field Project

   Copyright © 2026 munotes.in. All rights reserved.

   Written and first published by munotes.in, 2026.

   This book is for individual students to read at munotes.in. No part of it may be reproduced, distributed, stored, translated or used for institutional or classroom purposes in any form without a prior written licence from munotes.in.

   Licensing and permissions: contact@munotes.in

   The text of statutes and of judgments reproduced in this book is in the public domain under section 52(1)(q) of the Copyright Act 1957. The commentary, arrangement, examples and questions are the original work of munotes.in.

   munotes.in is an independent study resource for MU students. It is not affiliated with, endorsed by, or officially connected to the University of Mumbai. Course names and university references describe the students and syllabus the material relates to.

   Contents

   Module I The Field Project and How It Is Done

   1. The Field Project: What MU Sets in Forty-Five Hours and Two Credits 1
   2. How the Field Project Is Marked: the Guide's Twenty, the Examiner's Thirty and Passing Each 8
   3. The Worked Project in This Book: How Students Back Up Their Data 13
   4. Finding a Real-World Problem and Writing the Problem Statement 21
   5. Survey, Interview or Observation: Choosing How to Find Out 27
   6. Designing a Questionnaire: Questions, Answers, Order and the Pilot 32
   7. Sampling: Who to Ask and How Many 38
   8. Interviews and the Interview Protocol 44
   9. Observation in the Field: Watching, Counting and Recording 50
   10. Engaging Users, Communities and Institutions 55
   11. Permission Letters and Planning a Field Visit 60
   12. Consent, Privacy and Respect in Field Work 66
   13. Collecting the Data: Paper Forms, Online Forms and a Codebook 72
   14. Organising and Cleaning Survey Data 78
   15. Describing Survey Data: Counts, Percentages and the Middle Value 84
   16. Cross-Tabulation and Comparing Groups 89
   17. Charts for a Field Report 94

   Contents continued

   Module I continued The Field Project and How It Is Done

   1. Analysing Interview and Observation Notes: Codes and Themes 99
   2. From Data to Insights: What the Findings Mean and What They Cannot Say 104
   3. Formulating Practical Recommendations 110
   4. From Field Findings to Requirements 117
   5. Wireframes and Workflow Diagrams 124
   6. Building a Working Prototype 129
   7. Testing a Prototype or a Guide with Real Users 134
   8. Planning an Awareness Campaign 139
   9. Running a Training Workshop or Educational Session 144

   Module II The Suggestive Titles

   1. Getting a Title Allotted and Working in a Group of Up to Five 149
   2. Traffic Pattern Study and Data Analysis 155
   3. Sentiment Analysis of Local Business Reviews 161
   4. Data Visualization of Public Health or Environment Data 169
   5. Digital Notice Board Requirement Study & App/Web Development 176
   6. Alumni Portal Needs Assessment & Development 182
   7. Waste Collection Process Study & App Design 188
   8. Phishing Awareness Campaign Development 194

   Contents continued

   Module II continued The Suggestive Titles

   1. Elderly Care Needs Survey & Reminder App Prototype 200
   2. Digital Literacy Workshops for Marginalized Communities 209
   3. Waste Management Data Collection & Analysis 215
   4. Cybersecurity Awareness Survey Among Students 220
   5. Public Access to Digital Government Services Study 226
   6. Mobile App Usage Study in Urban vs. Rural Youth 231
   7. SHG / Artisan Needs Study & Mobile App Development 239
   8. Cybercrime Awareness & Reporting System Study 246
   9. Green Computing Practices Survey 253
   10. Website Requirement Study & Development for NGOs / Artisans 259
   11. Online Payment App Adoption Study Among Street Vendors 265
   12. Database-Driven Blood Donor Directory Study & Design 271
   13. Job Portal Needs Assessment for Low-Education Youth 280
   14. E-Waste Disposal & Upgrade Practices Study 288
   15. Data Privacy Awareness Survey Among Young Adults 295
   16. Digital Access Challenges Study in Rural Schools 302
   17. Mobile/Web App Preferences Study with UX Recommendations 308
   18. Data Backup Practices Study & Simple Guide Development 314

   Contents continued

   Module III The Deliverables, the Diary and the Marks

   1. The Field Visit Report 322
   2. What the Guide Marks First: Field Visit Completion, Attendance and Interaction 329
   3. The Project Planning and Design Document 336
   4. The Final Report: Its Parts, Its Structure and Its Style 343
   5. Writing the Report: the Problem Statement and the Objectives 351
   6. Writing the Report: the Literature Review 359
   7. Writing the Report: the Methodology 369
   8. Writing the Report: Data Collection and Analysis 375
   9. Writing the Report: Conclusions and Recommendations 383
   10. The Guide Interaction Diary 391
   11. The Presentation for Viva 396
   12. Presentation Skills, Communication and the Viva 403
   13. The Whole Field Project on One Page: a Checklist from Title to Viva 414

   Page 1 onwards

   423 pages in this book. The cover and the contents are above. Everything from page one is in the pass.

   Notes

   2026 Edition, as per the latest syllabus. 423 pages.

   Every chapter in the notes: 65 chapters across 3 modules

   Module I The Field Project and How It Is Done 26 chapters

   1. 1 The Field Project: What MU Sets in Forty-Five Hours and Two Credits pages 1 to 7
   2. 2 How the Field Project Is Marked: the Guide's Twenty, the Examiner's Thirty and Passing Each pages 8 to 12
   3. 3 The Worked Project in This Book: How Students Back Up Their Data pages 13 to 20
   4. 4 Finding a Real-World Problem and Writing the Problem Statement pages 21 to 26
   5. 5 Survey, Interview or Observation: Choosing How to Find Out pages 27 to 31
   6. 6 Designing a Questionnaire: Questions, Answers, Order and the Pilot pages 32 to 37
   7. 7 Sampling: Who to Ask and How Many pages 38 to 43
   8. 8 Interviews and the Interview Protocol pages 44 to 49
   9. 9 Observation in the Field: Watching, Counting and Recording pages 50 to 54
   10. 10 Engaging Users, Communities and Institutions pages 55 to 59
   11. 11 Permission Letters and Planning a Field Visit pages 60 to 65
   12. 12 Consent, Privacy and Respect in Field Work pages 66 to 71
   13. 13 Collecting the Data: Paper Forms, Online Forms and a Codebook pages 72 to 77
   14. 14 Organising and Cleaning Survey Data pages 78 to 83
   15. 15 Describing Survey Data: Counts, Percentages and the Middle Value pages 84 to 88
   16. 16 Cross-Tabulation and Comparing Groups pages 89 to 93
   17. 17 Charts for a Field Report pages 94 to 98
   18. 18 Analysing Interview and Observation Notes: Codes and Themes pages 99 to 103
   19. 19 From Data to Insights: What the Findings Mean and What They Cannot Say pages 104 to 109
   20. 20 Formulating Practical Recommendations pages 110 to 116
   21. 21 From Field Findings to Requirements pages 117 to 123
   22. 22 Wireframes and Workflow Diagrams pages 124 to 128
   23. 23 Building a Working Prototype pages 129 to 133
   24. 24 Testing a Prototype or a Guide with Real Users pages 134 to 138
   25. 25 Planning an Awareness Campaign pages 139 to 143
   26. 26 Running a Training Workshop or Educational Session pages 144 to 148

   Module II The Suggestive Titles 26 chapters

   1. 27 Getting a Title Allotted and Working in a Group of Up to Five pages 149 to 154
   2. 28 Traffic Pattern Study and Data Analysis pages 155 to 160
   3. 29 Sentiment Analysis of Local Business Reviews pages 161 to 168
   4. 30 Data Visualization of Public Health or Environment Data pages 169 to 175
   5. 31 Digital Notice Board Requirement Study & App/Web Development pages 176 to 181
   6. 32 Alumni Portal Needs Assessment & Development pages 182 to 187
   7. 33 Waste Collection Process Study & App Design pages 188 to 193
   8. 34 Phishing Awareness Campaign Development pages 194 to 199
   9. 35 Elderly Care Needs Survey & Reminder App Prototype pages 200 to 208
   10. 36 Digital Literacy Workshops for Marginalized Communities pages 209 to 214
   11. 37 Waste Management Data Collection & Analysis pages 215 to 219
   12. 38 Cybersecurity Awareness Survey Among Students pages 220 to 225
   13. 39 Public Access to Digital Government Services Study pages 226 to 230
   14. 40 Mobile App Usage Study in Urban vs. Rural Youth pages 231 to 238
   15. 41 SHG / Artisan Needs Study & Mobile App Development pages 239 to 245
   16. 42 Cybercrime Awareness & Reporting System Study pages 246 to 252
   17. 43 Green Computing Practices Survey pages 253 to 258
   18. 44 Website Requirement Study & Development for NGOs / Artisans pages 259 to 264
   19. 45 Online Payment App Adoption Study Among Street Vendors pages 265 to 270
   20. 46 Database-Driven Blood Donor Directory Study & Design pages 271 to 279
   21. 47 Job Portal Needs Assessment for Low-Education Youth pages 280 to 287
   22. 48 E-Waste Disposal & Upgrade Practices Study pages 288 to 294
   23. 49 Data Privacy Awareness Survey Among Young Adults pages 295 to 301
   24. 50 Digital Access Challenges Study in Rural Schools pages 302 to 307
   25. 51 Mobile/Web App Preferences Study with UX Recommendations pages 308 to 313
   26. 52 Data Backup Practices Study & Simple Guide Development pages 314 to 321

   Module III The Deliverables, the Diary and the Marks 13 chapters

   1. 53 The Field Visit Report pages 322 to 328
   2. 54 What the Guide Marks First: Field Visit Completion, Attendance and Interaction pages 329 to 335
   3. 55 The Project Planning and Design Document pages 336 to 342
   4. 56 The Final Report: Its Parts, Its Structure and Its Style pages 343 to 350
   5. 57 Writing the Report: the Problem Statement and the Objectives pages 351 to 358
   6. 58 Writing the Report: the Literature Review pages 359 to 368
   7. 59 Writing the Report: the Methodology pages 369 to 374
   8. 60 Writing the Report: Data Collection and Analysis pages 375 to 382
   9. 61 Writing the Report: Conclusions and Recommendations pages 383 to 390
   10. 62 The Guide Interaction Diary pages 391 to 395
   11. 63 The Presentation for Viva pages 396 to 402
   12. 64 Presentation Skills, Communication and the Viva pages 403 to 413
   13. 65 The Whole Field Project on One Page: a Checklist from Title to Viva pages 414 to 423

6. Computer Science Practical 3

   Official Notes munotes.in

   Computer Science Practical 3

   B.SC. (COMPUTER SCIENCE) · SEMESTER 3

   Strictly as per the University of Mumbai NEP syllabus in force for B.Sc. (Computer Science)

   For B.Sc. (Computer Science) students of the University of Mumbai and all its affiliated colleges

   munotes.in Second Year

   Computer Science Practical 3

   Copyright © 2026 munotes.in. All rights reserved.

   Written and first published by munotes.in, 2026.

   This book is for individual students to read at munotes.in. No part of it may be reproduced, distributed, stored, translated or used for institutional or classroom purposes in any form without a prior written licence from munotes.in.

   Licensing and permissions: contact@munotes.in

   The text of statutes and of judgments reproduced in this book is in the public domain under section 52(1)(q) of the Copyright Act 1957. The commentary, arrangement, examples and questions are the original work of munotes.in.

   munotes.in is an independent study resource for MU students. It is not affiliated with, endorsed by, or officially connected to the University of Mumbai. Course names and university references describe the students and syllabus the material relates to.

   Contents

   Module I Principles of Operating Systems: ten exercises in C on Linux

   1. How This Practical Is Examined: the Journal, the 80 Per Cent Rule and the Two Questions 1
   2. The Laboratory from Zero: gcc, a Program, and the Manual 6
   3. Processes: fork, wait, exec, and Why Two Programs Need to Talk 14
   4. Practical 1: Process Communication using Shared Memory 22
   5. Practical 1 continued: the Race Condition, Semaphores, and Producer and Consumer 31
   6. Practical 2: Process Communication with Pipes 40
   7. Practical 2 continued: Message Queues, Blocking and Non-blocking 48
   8. Practical 3: Threading and Single Thread Control Flow 57
   9. Practical 4: Multi-threading and Fibonacci Generation 67
   10. Practical 5: Process Synchronisation and the Bounded Buffer 77
   11. Practical 6: the Readers-Writers Problem 86
   12. Practical 7: CPU Scheduling, FCFS and Non-preemptive Scheduling 95
   13. Practical 8: CPU Scheduling, Round Robin 106
   14. Practical 9: Memory Management, FIFO and LRU Page Replacement 117
   15. Practical 10: Disk Scheduling 128
   16. Practical 10 continued: a Simple File System 137

   Contents continued

   Module II Data Structures: ten exercises in Python

   1. Python for Data Structures: the Tools This Module Uses 146
   2. Practical 11: Abstract Data Types and Custom Structures 154
   3. Practical 12: Singly Linked Lists 162
   4. Practical 13: Polynomial Operations Using Linked Lists 172
   5. Practical 14: Doubly Linked Lists 181
   6. Practical 15: the Stack ADT 190
   7. Practical 15 continued: Prefix to Postfix, and Evaluating It 198
   8. Practical 16: Queues and Circular Queues 207
   9. Practical 17: Binary Search Trees and Tree Traversals 217
   10. Practical 18: AVL Trees and Rebalancing 230
   11. Practical 18 continued: Heaps and Priority Queues 243
   12. Practical 19: Graph Representations and Traversals 258
   13. Practical 20: Hashing and Collision Handling 272

   Module J The journal and the practical examination

   1. Keeping the Journal, and What Goes on the Page 286
   2. A Worked Practical Paper: Q.1 and Q.2 293

   Page 1 onwards

   300 pages in this book. The cover and the contents are above. Everything from page one is in the pass.

   Notes

   2026 Edition, as per the latest syllabus. 300 pages.

   Every chapter in the notes: 31 chapters across 3 modules

   Module I Principles of Operating Systems: ten exercises in C on Linux 16 chapters

   1. 1 How This Practical Is Examined: the Journal, the 80 Per Cent Rule and the Two Questions pages 1 to 5
   2. 2 The Laboratory from Zero: gcc, a Program, and the Manual pages 6 to 13
   3. 3 Processes: fork, wait, exec, and Why Two Programs Need to Talk pages 14 to 21
   4. 4 Practical 1: Process Communication using Shared Memory pages 22 to 30
   5. 5 Practical 1 continued: the Race Condition, Semaphores, and Producer and Consumer pages 31 to 39
   6. 6 Practical 2: Process Communication with Pipes pages 40 to 47
   7. 7 Practical 2 continued: Message Queues, Blocking and Non-blocking pages 48 to 56
   8. 8 Practical 3: Threading and Single Thread Control Flow pages 57 to 66
   9. 9 Practical 4: Multi-threading and Fibonacci Generation pages 67 to 76
   10. 10 Practical 5: Process Synchronisation and the Bounded Buffer pages 77 to 85
   11. 11 Practical 6: the Readers-Writers Problem pages 86 to 94
   12. 12 Practical 7: CPU Scheduling, FCFS and Non-preemptive Scheduling pages 95 to 105
   13. 13 Practical 8: CPU Scheduling, Round Robin pages 106 to 116
   14. 14 Practical 9: Memory Management, FIFO and LRU Page Replacement pages 117 to 127
   15. 15 Practical 10: Disk Scheduling pages 128 to 136
   16. 16 Practical 10 continued: a Simple File System pages 137 to 145

   Module II Data Structures: ten exercises in Python 13 chapters

   1. 17 Python for Data Structures: the Tools This Module Uses pages 146 to 153
   2. 18 Practical 11: Abstract Data Types and Custom Structures pages 154 to 161
   3. 19 Practical 12: Singly Linked Lists pages 162 to 171
   4. 20 Practical 13: Polynomial Operations Using Linked Lists pages 172 to 180
   5. 21 Practical 14: Doubly Linked Lists pages 181 to 189
   6. 22 Practical 15: the Stack ADT pages 190 to 197
   7. 23 Practical 15 continued: Prefix to Postfix, and Evaluating It pages 198 to 206
   8. 24 Practical 16: Queues and Circular Queues pages 207 to 216
   9. 25 Practical 17: Binary Search Trees and Tree Traversals pages 217 to 229
   10. 26 Practical 18: AVL Trees and Rebalancing pages 230 to 242
   11. 27 Practical 18 continued: Heaps and Priority Queues pages 243 to 257
   12. 28 Practical 19: Graph Representations and Traversals pages 258 to 271
   13. 29 Practical 20: Hashing and Collision Handling pages 272 to 285

   Module J The journal and the practical examination 2 chapters

   1. 30 Keeping the Journal, and What Goes on the Page pages 286 to 292
   2. 31 A Worked Practical Paper: Q.1 and Q.2 pages 293 to 300

Questions