CS UNIT 10

• Data types are classifications of data that determine the possible values and operations.
• Integers are whole numbers, while real numbers are numbers with decimal points.
• Understanding and using data types appropriately is essential for problem-solving in programming.

Basic Data Types

• Boolean: Logical values (True/False). Represented as BOOLEAN in pseudocode, bool in Python, boolean in Java and VB.NET.
• Char: Single alphanumeric character. Represented as CHAR in pseudocode, char in Java, and Char in VB.NET. Not used in Python
• Date: Represents a date. Represented as DATE in pseudocode, class datetime in Python, class Date in Java, and Date in VB.NET.
• Integer: Whole number. Represented as INTEGER in pseudocode, int in Python, byte/short/int in Java, and Integer in VB.NET.
• Real: Number with a decimal point. Represented as REAL in pseudocode, float in Python/Java, and single/double in VB.NET.
• String: Sequence of alphanumeric characters. Represented as STRING in pseudocode, str class in Python, and String class in Java/VB.NET.
• Declaration statements in pseudocode take the form: DECLARE <identifier> : <data type>.
• Identifiers are unique names given to data items for identification purposes.

Records

• Records are composite data types that group several related items, potentially of different data types, under a single identifier.
• This composite type streamlines the handling of data, making code more structured and maintainable.
• A record's items can be accessed via <identifier>.<item identifier>, for example, Book.author.
• You must declare the structure of a record using the TYPE keyword before declaring variables of that record's type.
• Pseudocode record type definition:

  TYPE <Typename>
  DECLARE <identifier> : <data type>
  ...
  ENDTYPE
  

Arrays

• Arrays are data structures that store multiple elements of the same data type.
• Elements are accessed using an index number that represents the position of the element in the array.
• The first element's index is the lower bound, and the last element's index is the upper bound.
• Arrays can be one-dimensional (1D) or multi-dimensional (2D, 3D etc.).
• A one-dimensional (1D) array can be viewed as a list.
• A two-dimensional (2D) array can be viewed as a table with rows and columns.
• Pseudocode to declare a 1D array: DECLARE <identifier> : ARRAY[<lower bound>:<upper bound>] OF <data type>.
• Pseudocode to declare a 2D array: DECLARE <identifier> : ARRAY[<lower bound row>:<upper bound row>, <lower bound column>:<upper bound column>] OF <data type>.

Linear Search

• Linear Search sequentially checks each element in an array to find a target value.
• It starts from the lower bound and continues until the item is found or the upper bound is reached.
• Pseudocode includes setting a found flag, an index variable, and a REPEAT UNTIL loop.
• Time complexity is O(n) in the worst case

Bubble Sort

• Bubble Sort is a sorting algorithm that repeatedly steps through the list, compares adjacent elements, and swaps them if they are in the wrong order.
• Each pass places the next largest element into its correct position.
• Process repeats until no swaps are needed, indicating the list is sorted.
• Pseudocode includes nested loops: an outer loop to reduce the number of elements to compare, and an inner loop to step through the array.
• Time complexity is O(n^2)

Files

• Files store data for later use.
• Text files store sequences of characters with optional end-of-line markers.
• Pseudocode Statements for file handling:
  • OPEN <file identifier> FOR <file mode>: Opens a file. Modes include READ, WRITE, and APPEND.
  • READFILE <file identifier>, <variable>: Reads a line from the file into a string variable.
  • WRITEFILE <file identifier>, <variable>: Writes a line to the file from a string variable.
  • EOF(<file identifier>): Function to check for the end-of-file condition.
  • CLOSEFILE <file identifier>: Closes the file.

Abstract Data Types (ADTs)

• Abstract Data Types (ADTs) are collections of data with defined operations.
• Common ADTs include stacks, queues, and linked lists.
• Stack: Operates on the Last In, First Out (LIFO) principle
• Queue: Operates on the First In, First Out (FIFO) principle
• Linked List: A chain of items in which each item points to the next item. In a linked list a new item is always added to the start of the list.

Stacks

• Stacks operate under the Last In, First Out (LIFO) principle.
• push: adds an item to the top of the stack.
• pop: removes the top item from the stack.
• Base pointer points to the first/bottom item.
• Top pointer points to the last/top item.

Queues

• Queues operate under the First In, First Out (FIFO) principle.
• enqueue: Adds an item to the rear of the queue.
• dequeue: Removes an item from the front of the queue.
• Front pointer points to the first item.
• Rear pointer points to the last item.
• It is often managed as a circular queue to avoid moving items.

Linked Lists

• Linked lists contain a sequence of nodes, each with data and a pointer to the next node in the list.
• Implemented using arrays (one for data and another for pointers).
• A start pointer indicates the beginning of the list.
• A heap manages available (empty) positions for new nodes.
• New items are commonly added to the start of the list.