FIT2082 (2019)

Heaps - linked node

A heap can be made from a linked node, but thanks to completeness it can be implemented as an array For a node at k+1: ● Parent's parent: k//2 ● Parent = k ● Child left = 2*k ● Child right = 2*k+1

Recursive sorts merge sort

Merge sort is O(n log(n)) Merge sort halves the list, and once it's reached two elements, it sorts them and continues sorting as it combines the list.

Tranversing Binary Trees - methods

Methods ○ Preorder: root, then left, then right ○ Inorder: left, root, right ○ Postorder: left, right, root

Classess - Methods define

Methods define operations that can be performed by any object created as an instance of a class

Iterative sorting algorithms selection sort - complexity and why

O(n 2 ) Not stable

Iterative sorting algorithms bubble sort - complexity and why

O(n2) - ## incremental max number of swaps needed is n-1

Classes - Objects define

Objects are blocks of memory containing data and methods. In Python, every value is an object, they have both data and methods. We access the data and methods of an object in Python with dot notation. object.method()

Open addressing define

Open addressing ○ Each array position contains a single item ○ Upon collision, use an empty space to store the item ○ Requires array at least double the size as the number of element

Seperate chaining

Separate Chaining ■ Instead of looking for the next empty space, use a linked list to store collisions at the same hash location

MIPS instructions -Comparison Instructions Set less than

Set less than ■ slt $t0, $t1, $t2 ● if $t1 < $t2 then $t0 = 1 ● else $t0 = 0

MIPS instructions -Comparison Instructions Set less than immediate

Set less than immediate ■ slti $t0, $t1, x ● if $t1 < x then $t0 = 1 ● else $t0 = 0

3 parts of a loop MIPS

So a loop is composed of three parts: A condition that skips to the end of the loop when not true, and changes a variable if it's a for loop A set of instructions to be executed inside the loop A jump back to the loop condition

Recursion

Solving a large problem by reducing it to one or more subproblems that are the same kind as the original problem but simpler. Each subproblem is broken down until it's so simple it can be solved with a base case.

Queues immplemented with linked lists append

def append(self, item): new_node = Node(item, None) if self.is_empty(): self.front = new_node else: self.rear.link = new_node self.rear = new_node

Queues immplemented with linked lists is empty

def is_empty(self): return self.front is None

Linked list implementation is empty

def is_empty(self): return self.top is None

Stacks implemented with Linked list is empty

def is_empty(self): return self.top is None

Circular queue is empty

def is_empty(self): return self.count == 0

Queues implemented with arrays is empty

def is_empty(self): return self.rear == self.front

stack implemented with Arrays is empty

def is_empty(self): return self.top == 0

Stacks implemented with Linked list is full

def is_full(self): return False

Linked list implementation is full

def is_full(self): return False

Queues immplemented with linked lists is full

def is_full(self): return False

Queues implemented with arrays is full

def is_full(self): return rear == len(self.the_array)

Circular queue is full

def is_full(self): return self.count == len(the_array)

stack implemented with Arrays is full

def is_full(self): return top >= len(self.the_array)

Queues implemented with arrays peek

def peek(self): if self.is_empty(): raise Exception("Queue is empty") return self.the_array[self.front]

stack implemented with Arrays peek

def peek(self): if self.is_empty(): raise Exception("Stack is empty") return self.the_array[top - 1]

Stacks implemented with Linked list peek

def peek(self): if self.is_empty(): raise Exception("Stack is empty") return self.top.item

Queues immplemented with linked lists peek

def peek(self): if self.is_empty(): raise Exception("Stack is empty") return self.front.item

Stacks implemented with Linked list pop

def pop(self): if self.is_empty(): raise Exception("Stack is empty") item = self.top.item self.top = self.top.link return item

stack implemented with Arrays pop

def pop(self): if self.is_empty(): raise Exception("Stack is empty") self.top -= 1 item = self.the_array[top] return item

Stacks implemented with Linked list push

def push(self, item): self.top = Node(item, self.top)

stack implemented with Arrays push

def push(self, item): if self.is_full(): raise Exception("Stack is full") self.the_array = item self.top += 1

Linked list implementation reset

def reset(self): self.top = None

Queues implemented with arrays reset

def reset(self): self.front = 0 self.rear = 0

Queues immplemented with linked lists reset

def reset(self): self.front = None Self.rear = None self.count = 0

stack implemented with Arrays reset

def reset(self): self.top = 0

Stacks implemented with Linked list reset

def reset(self): self.top = None self.count = 0

Queues immplemented with linked lists serve

def serve(self): if self.is_empty(): raise Exception("Queue is empty") item = self.front.item self.front = self.front.link if self.front is None: self.rear = None return item

Circular queue serve

def serve(self): if self.is_empty(): raise Exception("The queue is empty") self.the_array[self.front] = item self.front = (self.front + 1) % len(self.the_array) self.count += 1 return item

Queues implemented with arrays serve

def serve(self): if self.is_empty(): raise Exception("Queue is empty") item = self.the_array[self.front] self.front += 1 return item

Circular queue size

def size(self): return self.count

Queues implemented with arrays size

def size(self): return self.rear - self.front

Recursive sorts general strategy

def sort(list): if base case: solve else [half1, half2] = split(list) sort(part1) sort(part2) combine(part1, part2)

Text segment

executable code goes here

Data segment

first - stores static data - its size is known before exectution and includes - class data, static variables, literal strings in the source coude, global variables second - dynamic ( heaps) objects and instance variables,. Grows 'downwards'

Linked List Implementation big picture

from node import Node

Stack segment

grows upwards/ towards heap § Contains the system stack § It is used for the temporary storage of: - Method information: • Local variables • Value of parameter • Return address - Saved register values (not studied in this unit)

Heaps

A heap is a binary tree with two special properties: ● Complete ○ Every level is full except the last ○ The last level is filled from the left ● Heap Ordered ○ Each child is smaller than or equal to its parents

Classes - Methods how does it differ to a function

A method is like a function except: ● It appears inside a class ● Its first arguments must be a reference to the instance whose method was called ○ The argument is named self ○ You must explicitly add self ○ Automatically added in call

Tree - inner Node

A node wih parents and children

Tree - Parent Node

A node with children

Tree - leaf node

A node with no children

Tree - Child Node

A node with parents

Tree - Subtree

A part of a tree

System Stack in MIPS - end of a funnction

Deallocate variables by popping allocated space from the stack

Tree - Width

the number od nodes in the level with the most nodes

start of MIPS function

# function entry addi $sp,$sp,-8 sw $ra,4($sp) sw $fp,0($sp) addi $fp,$sp,0 # copy $sp to $fp # 5*4 bytes=20. # 5 local variables ( n, a, i, item, item to right ) addi $sp, $sp,-20

item=the_list[item]

# item=the_list[i+1] # retrieving element i lw $t4, 8($fp) #storing address of memory allocated to $v0 lw $t0, -12($fp) #load i addi $t0,$t0,1 # i+1 addi $t1,$0,4 mult $t0,$t1 #4*(i+1) mflo $t2 add $v0,$t4,$t2 # the_list address +4*(i+1) lw $t3,4($v0) #load item i into to $t3 sw $t3, -20($fp) #item_to_right defined

exit MIPS function

# reinstating original frame pointer and return address lw $fp,0($sp) lw $ra,4($sp) addi $sp,$sp,8 # deallocating the stack bytes used for the storage ra and fp' jr $ra #returning to caller as well.

Trees define

######

Special Purpose Registers List

.HI and LO IR - instruction register PC - program counter

MIPS function entry from assignment

Saving sp to ra copying sp to fp then creating space for local variables

Iterative sorting algorithms Insertion sort

1. Main part: a. Split the list into two ■ A sorted part, starting with one element ■ An unsorted part, with the rest of the elements b. Extend the sorted part by taking any element in the unsorted section and inserting it into the sorted part, maintaining order 2. For every element in the unsorted list a. Store the first unsorted value, x, in a temporary place b. Shift all sorted elements larger than x one position to the right c. Copy x into the newly freed space

Super Linear Big O explain

Superlinear: O(n log n) Problem is broken up into sub-problems

Iterative sorting algorithms selection sort

1. Start at the leftmost unsorted element 2. Find the smallest element to the right 3. Swap it with the leftmost unsorted element

MIPS main components

32 General purpose registes - fast, expensive meory, physically inn CPU and each 32 bits size ALU - Arithmetic logic Unit - does the computatioons on register values Special registers - PC (Program Counter) - HI, LO (multiplication/division results) - IR (Instruction Register) - MAR/MRR/MWR (Memory Address/Read/Write Register),

Queues implemented with arrays overview

:)

Binary Search tree

A binary tree such that ● Every node has a key ● All keys in the left subtree of a node are less than the key of the node ● All keys in the right subtree of a node are larger than the key of the node ● All keys are unique

Circular queue define

A circular queue allows it to loop around when the rear reaches the end of the array, however this means that we can't tell when the queue is full or empty so we can use a counter or a reserved spot before the front to resolve this

Graph define

A graph is composed of ● A set of vertices, or nodes ● A set of edges A connected graph is one which every node is connected, there are no unreachable nodes. An acyclic graph has no cycles A tree is a connected acyclic graph

Python names and namespaces scope

A scope is the block of text where a namespace is directly accessible. That is, where there's no need to qualify a name. The scope is determined statically but is used dynamically ● Statically: so that you can always determine the scope of any name by looking at the program ● Dynamically: at runtime Python searches for names

Binary Tree define

A tree where each node has at most two children. A binary tree is height balanced if, for every node, the difference between the height of the left subtree and the right subtree is at most one. A perfect binary tree is one which all parents have two children and all leaves are at the same level.

Python - Variable representation

A variable is a name that identifies something. The name usually refers to a memory location. Like in MIPS, memory is divided into portions, and each portion has an address. In Python, the variable is a reference to a memory location containing ● The data ● The type of date ● Metadata

Python - creating variables

A variable is created when you first assign it a value x = value The actual value of x is the address to the data, Python doesn't require a specified type When a value is changed it only alters the reference

MIPS Memory Diagrams

A way of representing memory allocated to variables, including their ● Addresses ● Contents ● Variable Names This isn't crucial for global variables in the data segment. Every variable has a label to identify it, this label is used to access global variables. Local variables don't have a label because it should only be accessible to the function or method running it as a variable may have the same name within different scopes A memory diagram following the stack format: 0x6FFFFFF4 var 10 0x6FFFFFF8 old $fp 0x70000020 0x6FFFFFFC $ra 0x00401000 0x70000000 arg 14 0x... ? ?

List ADT Adding and deleting elements example

Adding elements: add an item at the position at length, then increment length Removing elements: decrement length.

MIPS Instructions - Arithmetic Addition

Addition ■ add $t0, $t1, $t2 ■ $t0 = $t1 + $t2

MIPS Instructions - Arithmetic Addition immediate

Addition immediate ■ addi $t0, $t1, x ■ $t1 = $t1 + x

Advantages of recursion

Advantages ● More natural ● Easier to prove correct ● Easier to analyse

Advantages of ADT

Advantages of ADT ● Simplicity ● Maintenance ● Flexibility and Reusability ● Portability

list comprehension

Allows you to easily get lists and iterators based on functions and conditions Python rules for creating lists intelligently s = [x for x in range(1:51) if x%2 == 0] [2, 4, 6, 8, 10, 12, 14, 16, etc]

Abstract Data Types traits

An abstract data type: ● Provides information regarding ○ The possible values of the type and their meaning ○ The operations that can be done on them ● Users interact with the data only through provided operations

Linked Data structures Advantage

Advantages: ● Fast deletion and adding of intermediate elements ● Resizable ● Less memory than a relatively empty array

Overload operators

All classes are derived from the built-in object, Object. This defined methods like __str__ and __int__. Your class inherits the definition, but you can also redefine it.

Recursion vs Iteration requirements for recusive implementation

Any iterative function can be implemented by recursion. ● Iterators are replaced by function calls ● The base case is the related condition of the loop ● Needs an auxiliary function to prepare conversion

Recursion vs Iteration requirements for iteratiev implementation

Any recursive function can also be implemented using iteration ● Need to store past results

Binary search tree - about search insert and delete

Binary trees are good for searching, inserting, and deleting ● Searching is binary ● Modifying links are constant ○ Deleting ■ Find the node and if ● A leaf: set to none ● A node with one child: parent reference is set to child ● A node with two children: Parents reference is set to the node's successor ○ The leftmost node with no left nodes ● Can be traversed in particular orders

MIPS instructions -Conditional Branch Instructions Branch if equal

Branch if equal ■ beq $t0, $t1, address

System Stack in MIPS - Beginning of a function

At the beginning of a function ● Allocated variables by pushing space onto the stack ● Initialize space by storing values in newly allocated space

Recursive sorts quick sort

Best: O(n log(n)) Worst O(n 2 ) ● The split: partition the list into two ○ One with elements smaller than the pivot ○ Another with elements greater than p ● The combination: append with the pivot in the middle

Better heap construction

Better Heap Construction If we know many elements in advance we can do it more quickly. Each balanced subtree in a heap is a heap, so we can build it up from the bottom by making little trees, heapifying them, then joining them, then heapifying, etc.

MIPS instructions -Conditional Branch Instructions Branch if not equal

Branch if not equal ■ bne $t1, $t2, address

Iterative sorting algorithms bubble sort

Bubble Sort 1. Start with the leftmost element 2. Compare the left element, x, to its neighbour on the right, y 3. If x>y, swap 4. Consider the next position to the right

0x10000000 - 0x7FFFFFFF

Data segment heap stack segment ( temp storage)

Classess define and define attributes

Classes A class is a blueprint for objects. That is, a class defines its attributes: ● The data stored by the object ● The methods that can be used by the object ● How its initialised Classes use the following syntax class ClassName: def methodName(arguments): code Every object is created by instantiating a class

classes python

Classes are objects within python that can be instantiated with their own data and methods. Every method within a class has a reference to itself

Cluster define

Cluster ■ A sequence of full hash table slots which grow larger as items are added

Conflict resolution define

Conflict occurs when a hash function produces the same output for two separate inputs. There are two main approaches to resolving these conflicts: - seperate chaininng and open addressing

Constant big O explain

Constant: O(1) Running time doesn't depend on n

when to use arrays

Contiguous Storage if: ● Known number of elements ● Few insertions or deletions needed ● Lots of searches on a sorted list ● Access to elements based on their position

MIPS Assembly directories

Directories always start with a dot. These don't assemble to machine language, they're used to allocated space and data. ● .data ○ Tells assembler it's working in the parts of the program to create things in the data segment ● .text ○ Tells the assembler to work in the text segment ● .space N ○ Creates N bytes of empty space ● .word W1[, W2, W3, ...] ○ Allocate 4 byte words and store the WN values in them ● .asciiz "string" ○ Allocates a sequence of 4 byte values and a zero byte to represent a string

Disadvantages of recusion

Disadvantages ● Runtime overhead ● Memory overhead

Linked Data Structure disadvantage

Disadvantages: ● More memory when relatively full ● Operations are time-consuming (no random access

MIPS Instructions - Arithmetic Division

Division ■ div $t1, $t2 ■ LO = $t1//$t2, HI = remainder

Double hashing define

Double Hashing ■ Whenever a collision occurs a secondary hash function is used to determine the step size. Eliminates the effect of clusters

System Stack in MIPS - during a function

During a function ● Push and pop variables using lw and sw

Priority Queue

Each element has a priority, we process the higher priorities first. There are two main operations ● add(element) ● get_next() For implementation, we use the usual built-in methods and the two new ones. It can be implemented with Array lists, linked lists, or a binary search tree

Exponential Big O explain

Exponential: O(2n) Combinatorial explosion

Factorial Big O explain

Factorial: O(n!) Finding all permutations of n items

Functions python

Functions are a portion of code which can be called to from anywhere in the same namespace

MIPS Function

Functions are used to encapsulate code, allow abstractions, and hide information. For function calling in MIPS we use the jal command, which is like a jump but it saves the address after where it was called from into $ra. The jr command can then be used to jump to the address that was stored in $ra.

Time complexity Big O notation

Instead of using exact running time equations we can use approximations, using the upper bound. It gives us a way of describing the growth rates of a methods running time with its input size.

Hash function properties

Hash function properties ● Type-dependent ● Return value in array range ● As fast as possible ● Minimise collisions

Hash Tables define

Hash tables aim to achieve O(1) as the best case for inserting, searching and deleting as much as possible. This is achieved with arrays, but each item needs a key

Python - assigning variables to other variables

If we set a variable to another, we're actually giving the two variables the same reference. If we now change the value of one variable its reference is retained while the other variables reference is preserved

Names and Namespaces

In Python, all identifiers are names. Namespaces are a mapping of names to objects, like a dictionary; each file, or module has its own namespace. So two classes and functions with the same name should not be placed in the same file, class, or function, else one will overwrite the other. Functions have their own namespace while being run too, Python creates a local namespace which is deleted when the function is completed. A name is bound in many ways in Python. If any of these are inside a function it makes the name local to the function

Binary Tree Complexity

In terms of complexity, the height is O(log n) for a balanced tree and O(n) for unbalanced

Algorithm Classifications Incremental Algorithms

Incremental algorithms don't need to recompile everything after a small change. If we need to add an element into a sorted list, bubble will be incremental when inserted into the front; it only needs to iterate once

define invariant

Invariant: property that remains unchanged - At a particular point, or throughout an algorithm, or ... In bubble sort there are many invariants: - Example: after every traversal, the list has the same elements - Also: in each traversal at most n-1 swaps are performed, where n is the length of the list

__init__ method

It is the first method in a class and is called

Stack Operations follows as

Its operations are as follows ● Create a stack (stack) ● Add item to top (Push) ● Take item off top (Pop) ● Look at item on top (Peek) ● Is the stack empty ● Is the stack full ● Empty the stack

Queues operations as follows

Its operations are as follows: ● Create the queue (Queue) ● Add item to back (Append) ● Take item off the front (Serve) ● Is the queue empty ● Is the queue full

MIPS instructions -Control transfer instructions Jump and link to label

Jump and link to label ■ jal label

MIPS instructions -Control transfer instructions Jump and link to register

Jump and link to register ■ jalr $t0

MIPS instructions -Control transfer instructions Jump to address in register

Jump to address in register ■ jr $t0

MIPS instructions -Control transfer instructions Jump to label

Jump to label ■ j label

types of open addressing

Linear probing quadratic probinng doube hasing seperate chainning cluster 5 types

Linear big O explain

Linear: O(n) Each element requires a fixed amount of processing

Linked Data structures define

Linked data structures are a connection of nodes, each node contains a data item and a link to another node

When to use linked list

Linked storage if: ● Unknown list size ● Many insertions and deletions are needed ● Most operations need traversal of the list from the first element

Python - lists

Lists in Python are implemented as arrays but are also objects. A variable is set as a reference to a list, and each item in the list is a reference to an object. Python lists are mutable, the value of each item in the list can actually change (just the reference value, not the value being referenced), almost all other objects are considered immutable, in that only the references can be altered.

MIPS instructions - Load and store Load word

Load word ■ lw $t0, address ■ $t0 = contents(address)

Logarithmic big O explain

Logarithmic: O(log n) Problem is broken up into smaller problems *

MIPS Input/ output

MIPS does Input/Output by asking the OS with the syscall command. To do this: 1. Work out the service required 2. Put the call code in $v0 3. Put arguments in $a0 and $a1 4. Perform syscall 5. Results are stored in $v0

Algorithm Classifications Stable algorithm

Maintains the relative order among elements. Sorting algorithms which can swap elements more than one space may cause a change in order if it swaps over an element with the same key

MIPS allocating space in the heap

Make a syscall with the code 9. In $a0 set it as the number of bytes to allocate in the heap. The address for the start of the heap is kept in $v0

List ADT adding and deleting elements explanation

Most implementations of lists use arrays, however, arrays have a fixed size, so, lists implemented need two things ● An array with a big size ● A count of the number of elements in the array Ab empty list has a length of zero, however, the array would still be large. To implement lists in Python we create a Python list with two elements; the length of the list and an array of fixed size

MIPS instructions - Data Movements Move from Hi

Move from hi ■ mfhi $t0 ■ $t0 = HI

MIPS instructions - Data Movements Move from Lo

Move from lo ■ mflo $t0 ■ $t0 = LO

MIPS Instructions - Arithmetic multiplication

Multiplication ■ mult $t1, $t2 ■ LO = $t1 * $t2, HI = overflow

HI and LO register

Multiplying two 32 bit numbers may require 64 bits to fit the result ○ HI contains the overflow, the large 32 bits ○ LO contains the rest, the small 32 bits Integer division may result in a remainder, after integer division ○ LO is the integer result of the division ○ HI is the remainder of the division

Pqueue Sort

PQueue Sort Using get_next from a priority queue can be used to sort lists quickly 1. Put elements in p-queue 2. Call get_max n times

Python names and namespaces how it searches

Python searches for names as follows 1. In the innermost scope 2. In the scope of enclosing functions 3. In the modules global names 4. In the namespace of in-built names

Quadratic probing

Quadratic Probing ■ Rather than searching linearly, check every step squared until an empty slot is found. This reduces the likelihood of clustering

Quadratic big O explain

Quadratic: O(N2) Processes pairs of data items

Queues implemented with how many elements

Queues are implemented with three elements: ● An array to store the items ● A pointer to the front ● A pointer to the rear

Queues define

Queues are lists that follow first in, first out (FIFO) access. Access to other elements in the list is unnecessary and forbidden

Recusion functions must have

Recursion functions must have ● At least one base case ● At least one recursive call whose result is combined ● Convergence towards the base case

MIPS recursion

Recursive functions end up calling themselves to solve a simpler version of the same problem. Functions calling themselves work the same way as normal function calling; each invocation has its own stack frame ( pretty sure we dont need to know this)

Recursive sorts

Recursive sorts are achieved with divide and conquer algorithms, they split the problem into subproblems. Such algorithms run at higher efficiency.

RISC vs CISC

Reduced Instruction Set Computer All instructions are • Same length (4 bytes, that is, 32 bits - a "word" for us) • Of similar complexity (simple) • (Mostly) able to run in same time (1 clock cycle) • Easily decoded and executed by computer hardware - Advantages: easier to build, cheaper, consumes less power Intel x86 is considered CISC ( Complex instruction set computer) - Instructions vary in length, complexity and execution time - Decoding and running instructions requires hardware-embedded program (microcode) - Advantage: potential for optimisation of complex instructions

Abstract Data Types define/ what do they determine

Refers to a classification that determines: ● The possible values for that type ● The meaning of those values ● The operations that can be done on them ● The way the values are implemented

General Purpose Registers (GPRs)

Registers in assembly are given a "$" prefix to identify them and range from $0 to $31, giving us 32 registers

0x00000000 - 0x003FFFFF

Reserved for OS

0x80000000 - 0xFFFFFFFF

Rserved for OS

MIPS functions - passing data **

Some functions have parameters and some return values. We can use reserved registers to achieve this (●** Use $a0 - $a3 for parameters) ● Use $v0 and $v1 for returns This has its limits, however, as we there may not be enough registers to achieve a functions requirements. Important register values also need to be recorded, since $ra and $fp are going to change, therefore they are stored in the stack upon entry. Upon return, the stack pointer is set to the frame pointer and the old $ra and $fp values are restored.

Stacks are implemented with how many elements

Stacks are implemented with two elements: ● An array to store items ● An integer indicating the top

Stacks define

Stacks are lists that follow the last in, first out (LIFO) access. Access to other elements in the list is unnecessary and forbidden

MIPS instructions - Load and store Store word

Store word ■ sw $t0, address ■ contents(address) = $t0

MIPS Instructions - Arithmetic substraction

Subtraction ■ sub $t0, $t1, $t2 ■ $t0 = $t1 - $t2

0x00400000 - 0x0FFFFFFF

Text segment

System Stack in MIPS - $fp

The $fp register indicates the bottom of the stack. This is useful for returning to old stack pointers, but also, it's easier to access variables with the frame pointer as it gives us a frame of reference from the beginning of the stack, which remains unchanged throughout a function

System Stack in MIPS - $sp

The $sp register indicates the top of the stack, its value changes during the execution of a function. To push elements to the stack you need to subtract the stack pointer by four, allocating 32 bits, then to pop you add four to the stack pointer.

Tree - Root Node

The Node with no parents

Getting data out of main memory

The address to be loaded from goes into the MAR - The memory controller gets told to do a read - The data at that address goes into the MRR - The MRR is copied to the destination register (GPR) specified in the instruction

Tree - nodes

The connections between each branch

Tree - edges

The connections between each node

Put data in main memory

The contents of the GPR specified in the instruction are copied to the MWR - The address to be stored to goes into the MAR - The memory controller gets told to do a write - The data in the MWR gets written to memory

MIPS Accessing main memory

The data lives in the main memory, so we have to load data to a register then back to memory once done Each segment has its own context for the data being used To get data out of memory we use a load instruction and a store instruction to put it back.

Tree - Levels

The different sectiosn where the branches reside

IR (Instruction Register)

The instructions register stores the instruction currently being executed. The first 6 bits are operation code, the code referring to the instruction. The opcode tells the control circuit which microinstructions need to be followed the rest of the bits are operands are the input output values? Where machine code/instructions are held for decoding and execution

Tree - depth

The level of a node

List ADT - what makes it a list

The list ADT is used to store items, what makes it a list is: ● Elements have an order ● Must have access to the first item ● From one position you can always access the next For our own definition of a list, we will use arrays to implement is

PC (Program Counter)

The program counters tell the computer where it's up to in the code. It holds the memory address of the code being executed. Jump writes a new value to the PC to move the execution to a new place in the program. Branch instructions do this if a condition is met.

Python Exceptions

There are two main situations where we need to deal with errors: ● When reading an input ● When a precondition isn't met If an error is detected we usually print an error message. Modern languages use exception handling.

Exception handling code example with explanation

This function will first execute the try clause. If there's no exception, skip the except clause. If there is an exception, skip to the except clause and: ● If the type matches the exception: ○ Execute except clause ○ Continues execution after the try statement ● If it doesn't match: ○ Control is passed to outer try statements ○ If no handler is found, it is an unhandled exception

MIPS Arrays - calc the address of a[n]

To compute the address of a[n] ● Determine the start address ○ Address in a + 4 ○ The numerically smallest address ● Determine the size of an element in a ○ In bytes (usually 4 bytes) ● Compute n address ○ n = start + (size * k)

Heaps to get max item

To get the max item, just select the item at the top of the tree, swap it with the list item in the list and take out the max. Now move the top item down until it's equal to or larger than its children.

Heaps - to insert

To insert an item into a heap you place is at the next space in the tree and then, if the parent is larger, then swap the item and parent until the heap is valid.

Iterators

To traverse a list from outside the class we would have to access the implementation. We need a way of creating an iterator object to start the iterations. ● An object other than the list because ○ It needs to change ○ We might need several iterations ● In Python iterators are returned with __iter__ This means we need an iterator class to create the objects, with this class needing a way to return the next element. We need to create an iterator class for the list

Iterators vs iterables

We have made out List class iterable because it defines __iter__ The iterator object we created, ListIterator, defines __iter__ and __next__. So now we can use for loops to iterate over iterables and iterators. Iterators can also be given methods like any other class.

MIPS Labels and Symbols

We use labels to name memory location in the data or text segment. The assembler uses a symbol table when it sees a label being defined and puts the label and address location into the table. When a label is used it looks the name up in the table to find its address

MIPS Arrays

When translating from lists in Python we assume ● They have a fixed length ● Only have integers ● Initialise as zero ● The data for a list is only ○ It's length ○ It's elements

MIPS Iteration

While tests whether a condition is met before loop entry For is a shorthand for while where it runs depending on the state of a temporary variable

Big O notatioon - Best/worst cases

Worst cases give us a guarantee for all inputs. Best case is correct for at least one condition of the input. When time complexity is unspecified we consider it to be worst case.

Iterative sorting algorithms Insertion sort - complexity and why

Worst: O(n 2 ) Best: O(n) Stable and incremental when added to the back

Tree - Path

a collection of connected branches

what is a word

chunk of bits ( 8.16.32 or 64) we will use 32 bits = 4 BYTES

Linked Data Structure Class Node

class Node: def __init__(self, item=None, link=None): self.item = item self.next = link

Circular queue append

def append(self, item): if self.is_empty(): raise Exception("The queue is full") self.the_array[self.rear] = item self.rear = (self.rear + 1) % len(self.the_array) self.count += 1

Queues implemented with arrays append

def append(self, item): if self.is_full(): raise Exception("Queue is full") self.the_array[self.rear] = item self.rear += 1

List ADT example - get item, length, lin_search

def List(size): return [None]*size def get_item(the_list, index): return the_list[index] def length(the_list): return len(the_list) def lin_search(the_list, item): for index in range(len(the_list)): if item == the_list[item]: return True return False

Linked list implementation __getitem__

def __getitem__(self, i): current = self.top while i > 0: if current.link is None: return False current = current.link i -= 1 return current.item

Linked list implementation initialise

def __init__(self, _=None): self.top = None

Stacks implemented with Linked list __init__

def __init__(self, _=None): self.top = None count = 0

Queues immplemented with linked lists init

def __init__(self, _=None): self.front = None self.rear = None count = 0

Circular queue init

def __init__(self, size): ... ### self.count = 0

Queues implemented with arrays __init__

def __init__(self, size): self.the_array = [None] * size self.front = 0 self.rear = 0

stack implemented with Arrays __init__

def __init__(self, size): self.the_array = [None] * size self.top = 0

Stacks implemented with Linked list __len__

def __len__(self): return self.count

Queues immplemented with linked lists len

def __len__(self): return self.count

stack implemented with Arrays _len_

def __len__(self): return self.top

Linked list implementation __len__

def __len__(self): size = 0 current = self.top while current is not None: size += 1 current = current.link

Linked list implementation __setitem__

def __setitem__(self, i, item): current = self.top while i > 0: if current.link is None: return False current = current.link i -= 1 Current.item = item

Hash function

key ⟶ hash function ⟶ pos ⟶ array[pos]

Why assembly language needed

machine code hard to write Supports comments, variable names, line labels, etc - Has human -readable versions of machine instructions - But is easily converted to machine language • Usually a 1-to-1 relationship between each assembler language instruction and its equivalent machine language instruction

Machine Code

not in Java or Python but in machine language machine code is stores in memory as bit patterns

MIPS control transfer statement

replace the PC value with the address value of the speciifc destination

Tree - Height

the highest level in the tree

Exception handling define 3 parts

● Exception ○ Runtime event that breaks the normal flow of execution ● Exception Handler ○ Block of code that can recover from the event ● Exception Handling ○ Mechanism to transfer control to a handler

MIPS Properties of local variables

● Must be created upon entry ● Must be destroyed on exit ● Other functions can be called between with the same rules So the structure is like a stack; LIFO.

seperate chaining define

● Separate Chaining ○ Each array position contains a linked list of items ○ Upon collision, the cloned element is added to the lis

Recursive notation

● Unary: A single recursive call ● Binary: Two recursive calls ● N-ary: n recursive calls

MIPS instruction execution

●Fetch next instruction from memory ● Decode instruction in the IR to determine type ● Execute instruction, then go to the next instruction

Big O table

▪ If run time depends only on input size: best = worst

Linear probing define

○ Linear Probing ■ When a collision occurs commit a linear search from the key's location until an empty slot is found

MIPS instructions -Shifting Shift left logical

○ Shift left logical ■ sll $t0, $t1, x ■ $t0 = $t1 * 2 x

MIPS instructions -Shifting Shift right arithmetic

○ Shift right arithmetic ■ sra $t0, $t1, x ■ $t0 = $t1/2 x

Hash Tables 3 aspects

● Data ○ Item to be stored ○ The items unique key ● Structure: ○ Large array ● Operations ○ Hash function ■ Maps key to position ○ Insert ○ Search ○ Delete

Direct vs indirect recursion

● Direct: recursive calls are calls to the same function ● Indirect: recursion through two or more methods