Activity 9: Data Structure in Typescript

Explain Each Data Structure in TypeScript: For each data structure, provide the following details:

Definition: A brief explanation of the data structure.

- A binary tree is a hierarchical data structure where each node has at most two children, called the left child and the right child.

- A binary search tree (BST) is a special kind of binary tree where the values in the left subtree of a node are always smaller than the node's value, and the values in the right subtree are always larger.
Key Features: The important characteristics and behaviors of the data structure.

- Data structures are fundamental tools in computer science for organizing, storing, and managing data efficiently. They provide a systematic way to arrange data, define relationships between elements, and enable efficient operations like retrieval, insertion, and deletion.
Use Cases: Where and why this data structure is typically used.

- Binary trees and binary search trees are hierarchical data structures used for organizing data efficiently, enabling fast searching, sorting, and data retrieval in various applications like databases, expression evaluation, and decision-making.
Time Complexity: Analyze the performance of each data structure (Big-O notation) for common operations like insert, delete, and search.

- Time complexity, expressed using Big-O notation, measures how the time taken for operations like insertion, deletion, and search grows with the size of the data structure, indicating the efficiency of different data structures for various tasks.
Example Code in TypeScript: Provide a TypeScript code snippet demonstrating how to use each data structure.

-class Node { value: number; left: Node | null; right: Node | null; constructor(value: number) { this.value = value; this.left = null; this.right = null; } } // Usage const rootNode = new Node(5); rootNode.left = new Node(3); rootNode.right = new Node(8);

Arrays:

Adding Elements: Use the push() method to add elements at the end of the array.

let numbers: number[] = [1, 2, 3];
numbers.push(4);

Removing Elements: Use methods like pop() to remove the last element or splice() to remove specific elements.

let fruits: string[] = ['apple', 'banana', 'orange']; fruits.pop(); // Removes 'orange'

Accessing Elements: Access elements by their index, starting from 0, to retrieve or modify values.

let colors: string[] = ['red', 'green', 'blue']; let firstColor = colors[0]; // Accesses 'red'

Tuple:

In TypeScript, tuples are fixed-size arrays where each element may have a different data type, providing a way to represent a specific sequence of elements. Tuples differ from arrays in that they enforce a specific order and data type for each element, offering more precise data representation.

let employee: [string, number, boolean]; employee = ['Alice', 30, true]; let name: string = employee[0]; // Accesses 'Alice' let age: number = employee[1]; // Accesses 30 let isActive: boolean = employee[2]; // Accesses true

ArrayList (Dynamic Arrays):

- In TypeScript, dynamic arrays can be created and managed using the built-in Array class, which allows for flexible resizing and manipulation of arrays without specifying a fixed size. By adding or removing elements dynamically, dynamic arrays in TypeScript can adjust their size as needed to accommodate changing data requirements.

Stack:

Arrays in TypeScript are used to store collections of elements of the same type. They are declared using square brackets [] after the variable name and the type of the elements.

let numbers: number[] = [1, 2, 3, 4, 5];

Adding elements: Use the push() method to add elements to the end of an array.
Removing elements: Use the pop() method to remove the last element or the splice() method to remove elements at specific indices.
Accessing elements: Use square brackets [] with an index to access individual elements.

Queue:

To implement a queue in TypeScript, you can use an array and follow the First In First Out (FIFO) principle. In a queue, the first element added is the first one to be removed. Enqueue operation adds an element to the back of the queue, while dequeue operation removes the element from the front of the queue. This ensures that elements are processed in the order they were added, maintaining the FIFO order.

LinkedList:

To create a singly or doubly linked list in TypeScript using classes, you first define a Node class that includes the data and a reference to the next (for singly linked list) or previous (for doubly linked list) node. Then, you create a LinkedList class that manages the nodes.

Define a Node class with properties for data and a reference to the next (and previous for doubly linked list) node.
Define a LinkedList class with methods to add, remove, and traverse nodes.

HashMap (or Object/Map):

In TypeScript, you can create a key-value pair data structure using either a Map or an object.

Using Map:

let keyValueMap = new Map();
To create a Map, you can initialize it as follows:
Inserting a value with a key:

keyValueMap.set('key1', 'value1');
Deleting a value by key:

keyValueMap.delete('key1');
Searching for a value by key:

keyValueMap.get('key1');
To create an object with key-value pairs:

let keyValueObject = { key1: 'value1', key2: 'value2' };
Inserting a value with a key:

keyValueObject['key3'] = 'value3';
Deleting a value by key:

delete keyValueObject['key1'];
Searching for a value by key:

keyValueObject['key2'];

Set:

A set is a data structure in Python that stores unique elements. This means that no element can appear more than once in a set.

Here's how to create a set:

my_set = {1, 2, 3, 4} print(my_set)

To add an element to a set, use the add() method:

my_set.add(5) print(my_set)

To remove an element from a set, use the remove() method:

my_set.remove(3) print(my_set)

To check if an element exists in a set, use the in operator:

if 2 in my_set: print("2 is in the set") else: print("2 is not in the set")

Tree:

In TypeScript, binary trees or binary search trees (BST) can be implemented using classes to define the structure of nodes and the tree itself. Each node in the binary tree has a value, a reference to the left child node, and a reference to the right child node.

- class Node { value: number; left: Node | null; right: Node | null; constructor(value: number) { this.value = value; this.left = null; this.right = null; } } class BinarySearchTree { root: Node | null; constructor() { this.root = null; } insert(value: number) { const newNode = new Node(value); if (!this.root) { this.root = newNode; } else { this.insertNode(this.root, newNode); } } private insertNode(node: Node, newNode: Node) { if (newNode.value < node.value) { if (!node.left) { node.left = newNode; } else { this.insertNode(node.left, newNode); } } else { if (!node.right) { node.right = newNode; } else { this.insertNode(node.right, newNode); } } } // In-order traversal inOrderTraversal(node: Node | null) { if (node) { this.inOrderTraversal(node.left); console.log(node.value); this.inOrderTraversal(node.right); } } search(value: number): boolean { return this.searchNode(this.root, value); } private searchNode(node: Node | null, value: number): boolean { if (!node) { return false; } if (value < node.value) { return this.searchNode(node.left, value); } else if (value > node.value) { return this.searchNode(node.right, value); } else { return true; } } } // Example usage const bst = new BinarySearchTree(); bst.insert(10); bst.insert(5); bst.insert(15); bst.insert(2); bst.insert(7); console.log("In-order traversal:"); bst.inOrderTraversal(bst.root); console.log("Searching for 5:", bst.search(5)); console.log("Searching for 20:", bst.search(20));

Deliverables:

Data structures are fundamental components in programming that organize and store data efficiently. Here are some common data structures with TypeScript examples:
1. Arrays: Arrays store a collection of elements in a sequential order. They can hold data of the same type and are accessed using indices.
  
  let numbers: number[] = [1, 2, 3, 4, 5]; let fruits: string[] = ['apple', 'banana', 'orange'];
2. Linked Lists: Linked lists consist of nodes where each node holds data and a reference to the next node in the sequence.
  
  class Node { data: number; next: Node | null; constructor(data: number) { this.data = data; this.next = null; } } let node1 = new Node(1); let node2 = new Node(2); node1.next = node2;

Stacks: Stacks follow the Last In, First Out (LIFO) principle, where elements are added and removed from the top of the stack.

let stack: number[] = []; stack.push(1); stack.push(2); let topElement = stack.pop();

Queues: Queues adhere to the First In, First Out (FIFO) principle, where elements are added to the rear and removed from the front of the queue.

let queue: number[] = []; queue.push(1); queue.push(2); let frontElement = queue.shift();
Trees: Trees are hierarchical data structures with a root node and child nodes. Each node can have multiple child nodes.

class TreeNode { value: number; children: TreeNode[]; constructor(value: number) { this.value = value; this.children = []; } } let root = new TreeNode(1); let child1 = new TreeNode(2); root.children.push(child1);

~~Arigato

Activity 9: Data Structure in Typescript

ArrayList (Dynamic Arrays):

Stack:

Queue:

LinkedList:

HashMap (or Object/Map):

Set:

Tree:

Deliverables: