Ch 1-25

Author: Amokhalad

.DS_Store

@@ -0,0 +1 @@
+*.idea

.gitignore

@@ -0,0 +1,55 @@
+# Lecture 1
+_Jan 18, 2023_
+
+Instructors: 
+- Josh Hug -- hug@cs.berkeley.edu -- 779 Soda
+- Justin Yokota -- jyokota@berkeley.edu -- 329 Soda
+
+# Lecture Notes
+1. Unlike python, you can concatenate ints and strings together. But Why? 
+2. if functions are defined in the same class of main and are used in main must be defined as ``static``. But why?
+3. Running Java code: compile first with `javac` then interpret the .class file with `java`
+   1. The .class file has been type checked, and 'simpler' for machine to execute.
+4. 
+
+
+### Questions
+1. What does var do in Java.
+   1. initialized the type of the variable at run-time. Like `auto` in C++.
+
+# Objects
+## Static vs. Non-Static Methods
+Instance methods are actions that can be taken only by a specific instance of a class. Static methods are actions 
+that are taken by the class itself.
+
+
+**Static Variables** are properties inherent to the class itself, rather than the instance. Static variables 
+should be accessed using the name of the class rather than a specific instance, e.g. you should use `Dog.binomen`, not `d.binomen`.
+
+
+## Java Lists
+There are [multiple types](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html) of `List` 
+objects in Java. To create an `ArrayList` of strings:
+```java
+import java.util.List;
+import java.util.ArrayList;
+
+List<String> lst = new ArrayList<>();
+```
+
+## Java Arrays
+Java arrays are like Java Lists but more restirected in that:
+1. The size of the collection must be declared at the time the array is created
+2. Size cannot change
+3. No methods.
+4. Syntax for accessing elements is similar to Python (e.g. `arr[0]`)
+
+Arrays are more performant than lists (more in 61C):
+- Reading and writing from them is faster.
+- Use less memory.
+
+## Maps
+In programming languages, a map is collection of key-value pairs. Each key is guaranteed to be unique. Also called: Dictionary (in Python).
+
+
+

Ch 01: Intro To Java.md

@@ -0,0 +1,31 @@
+# Lecture 3: References, Recursion, and Lists
+_Jan 23, 2023_
+
+## Declaring a Variable 
+When you declare a var of a certain type in Java, Java maps the variable name to their location in
+memory where the information is stored in bits. 
+
+## Reference Types
+When instantiating an Object: 
+- Java first allocates a box of bits for each instance variable of the class and fills them with a default value(e,g, 0, null)
+- The constructor then usually fills every such box with some other value.
+
+`new`: you can think of it as a function that takes a parameter (Object), and returns the address of that object which is 64 bits.
+- note `new`: does not return the bits of what the object contains, only the address of where the object is stored in memory.
+
+
+Therefore, when you do Object assignment:
+```Java
+Obj a;
+Obj b;
+a = new Obj();
+b = a;
+```
+`a` contains the address of the location of where the new object is, and when we assign `b = a`, the address the object is copied over. This is why they point to the same object
+
+**C++ Note: For function calls, Java is a language that always does pass by value, even for objects. When passing in objects, it's the address that's passed in to a function.**
+
+
+# Lecture 4: SLLists, Nested Classes, Sentinel Nodes
+_Jan 25, 2023_
+

Ch 02: Lists.md

@@ -0,0 +1,65 @@
+# Ch 04. Inheritance, Implements
+
+### Hypernyms, Hyponyms, and Interface Inheritance
+
+**Hypernyms:** “<blank> is what’s called a *hypernym* of …” means hypernym is the **********************superclass********************** of (…)
+
+********************Hyponyms:******************** the (…) above are the *hyponyms* of <blank>, or ******************subclass.******************
+
+As an example from lecture, we created two different data structures `SLList` and `AList`. These are hyponyms of a more general list, we’ll call it `List61B`
+
+using **interfaces**: 
+
+```java
+public interface List61B<Item> {
+	public void addFirst(Item x);
+	public int size();
+	...
+}
+```
+
+************************************interface************************************ defines a type for a general list hypernym. It is essentially a contract that specifies what a list must be able to do, *but it doesn’t provide any implementation for those behaviors.* 
+
+Now to tell Java that `AList` and `SLList` are hyponyms, we use a relationship-defining word: ******************`**implements**`******************
+
+```java
+public class AList<Item> implements List61B<Item>{...}
+```
+
+`implements List61B<Item>` is essentially a promise. `AList` is saying “I promise I will have and  define all the attributes and behaviors specified in the `List61B` interface”
+
+### Overriding
+
+When fulfilling the promise in the subclass to implement the methods defined in the interface, it’s useful (and actually required in this class) to include `@Override` tag above the method signature. ***********Note if you don’t include this tag, you’re still overriding the method.***********
+
+## Implementation Inheritance
+
+Unlike an interface inheritance which just tells the subclass ***what*** to do, we can do something called implementation inheritance which allows to tell the subclasses *********how******* how to behave,
+
+To do this, we must include `default` keyword in the method signature we define in the super class, where if the subclasses don’t override it, it will default to use its parent method.
+
+Now, when we call an overridden method from an instance of the subclass, Java able know which method to call due to something called **************************************************dynamic method selection.**************************************************
+
+## Dynamic method selection
+
+`List61B<String> lst = new SLList<String>();`
+
+in the above declaration, `lst` is of type `List61B` . This is called the “static type”.
+
+However, object themselves have types as well. The object that `lst` points to is of type `SLList` . (**********Note it’s also a `List61B` because of the “is-a” relationship).* But because the object itself was instantiated using the `SLList` constructor, we call this its “dynamic type.”
+
+We say it’s dynamic type because should `lst` be reassigned to point to an object of another type, say `AList` object, `lst` dynamic type would now be `AList` and not `SLList`! it’s dynamic because it changes based on the type of the object it’s currently referring to.
+
+When Java runs a method that is overridden, it searched for the appropriate method signature in its **dynamic type** and runs it.
+
+However for overloaded methods, Java checks to see which method to call by checking the **********************static type********************** and calls the method with the **parameter of the same type.**
+
+## Questions
+
+- [ ]  What happens when we pass in a superclass to an argument that’s suppose to take a subclass?
+- [ ]  What about when we pass in a subclass into an argument that takes in a parent class?
+    - This is fine because when you pass in the subclass to a function, it shares an “************is-a************” relationship with it’s parent class, which means that it should be able to fit into the parents box.
+- [ ]  What happens when you use `Parent p = new Child();`
+- [ ]  What about when you use `Child c = new Parent();`
+- [ ]  Or finally? `Child c = new Child();`
+- [ ]  Can you use `implements` on a superclass that’s not an interface?

Ch 04 Inheritance, Implements 7534a751682a4910b64a8b947a5209b6.md

@@ -0,0 +1,83 @@
+# Ch 12. Exceptions, Iterators, Object Methods
+
+
+## 12.2 Exceptions:
+
+to throw an exception, you can make your own exception by throwing an ****************************actual object,**************************** so you need to instantiate something. If you don’t handle this exception with a ********************************************try catch statement ()********************************************, this will make your program crash/terminate. For example:
+
+`throw new IllegalArguementException("message here")`
+
+With this however, if you have an app and an exception is thrown, you don’t want to your app to crash. You can ************handle************ an exception with a ******************try catch****************** statement (not covered in this chapter.)
+
+## 12.4 Object Methods
+
+all java object **inherit** from the overarching `Object` class. There is a good number of inherited methods but here we focus on only two (`toString`, `equals`)
+
+### `String toString()`
+
+when you call `System.out.print()` on an object, it implicitly calls the objects `toString` and prints the string returned. 
+
+Here is one (bad) implementation of `toString()` for a List:
+
+```java
+public String toString() {
+    String returnString = "{";
+    for (int i = 0; i < size - 1; i += 1) {
+        returnString += keys[i];
+        returnString += ", ";
+    }
+		returnString += items[size - 1];
+    returnString += "}";
+    return returnString;
+}
+```
+
+Although it seems elegant and simple in that we are “appending” to `returnString` , this is actually not the case. We are creating an entirely new string, making this incredibly inefficient since creating a new string object takes time too. 
+
+To remedy this, Java has a special class called `StringBuilder` , it creates a string that is *mutable* so that we can actually append to it instead of creating a new object each time.
+
+Lets rewrite the above implementation using `StringBuilder`
+
+```java
+@Override
+public String toString() {
+		StringBuilder returnSB = new StringBuilder("{");
+		for (int i = 0; i < size - 1; i += 1) {
+		    returnSB.append(items[i].toString());
+		    returnSB.append(", ");
+		}
+		returnSB.append(items[size - 1]);
+		returnSB.append("}");
+		return returnSB.toString();
+}
+```
+
+## `boolean equals(Object obj)`
+
+`equals()` and `==` have different behaviors in Java. `==` Checks if two objects are actually the same object in memory. Remember, pass-by-value! `==` checks if two boxes hold the same thing. For primitives, this means checking if the values are equal. For objects, this means checking if the address/pointer is equal.
+
+Lets implement `equals` for a `Set` object.
+
+```java
+@Override
+public boolean equals(Object other) {
+		if (other == null) { return false; }
+		if (other == this) { return true; }
+	
+		if (other instanceof ArraySet otherSet) {
+				if (otherSet.getClass() != this.getClass()) { return false; }
+				for (T item : this) {
+						if (!otherSet.contains(item)) {
+								return false;
+						}
+				}
+				return true;
+		}
+		return false;
+}
+
+```
+
+***Note:*** the parameter must be of type object otherwise we won't be overriding anything. Moreover this gives us the chance to use `.equals` on iterables of different types, like sets or linked lists. 
+
+the 3rd if statement is added because otherwise if other is not an `instanceOf` `ArraySet` , we should return false immediately. The if statement implicitly does the casting of `other` to the  casting will fail. `getClass` returns the runtime class of an object.

Ch 12 Exceptions, Iterators, Object Methods 363dccc6592e491d98ac5ffb42e9f86c.md

@@ -0,0 +1,21 @@
+# Ch 13. Asymptotics I
+
+Class: CS 61B
+Created: March 2, 2023 1:36 PM
+Priority: Priority 4
+Status: Done
+Type: Reading
+
+## Big-Theta
+
+Thought of as the order of growth
+
+## Big-0
+
+Instead of equality on the order of growth, it can be thought of as “less than or equal to”. 
+
+So a program that has order of growth $N$,  $\Theta (N)$ , it’s Big-O can can be greater than or equal to $N$
+
+i.e., $O(N), O(N^2),$ etc…
+
+People sometimes prefer Big-O Instead of Big-Theta because an algorithm might be faster than the actual order of growth, i.e., it’s less than….

Ch 13 Asymptotics I db1753d2c7324bc2b617ccbba4f886fa.md

@@ -0,0 +1,24 @@
+# Ch 17: B-Trees
+
+# B-Trees
+
+## Invariants:
+
+because of the way B-Trees are constructed, they have two invariants:
+
+1. All leaves are the same distance from the root.
+2. A non-leaf node with k items must have exactly k + 1 children.
+
+## 2-3 Trees
+
+the maximum number of values a node can contain is 2, which will make a non-leaf node with 2 items have exactly 3 children (2-3 tree).
+
+When the node gets full (has 3 items), push the middle value up to the parent and split the full node in half. This will increase the number of children the parent has. 
+
+If the parent also gets full, repeat the process.
+
+## 2-3-4 Trees
+
+Similar idea to 2-3 trees but now a node can contain at most 3 values, and a non-leaf node with 3 values must have 4 children. Moreover, we push the 2nd element from the left up to the parent, and split the node where that element is.
+
+************Question:************ What about if a node on the left branch gets full? do we push the right element from the middle up?

Ch 17 B-Trees 82e77cb0b66c4b3498c686f5991d41f9.md

@@ -0,0 +1,23 @@
+# Ch 18. Red Black Trees
+
+## Rotations:
+
+rotateLeft(N) brings down the Node, making the right child it’s parent, and the right child left node it’s child.
+
+rotateRight(N) does the inverse of rortateLeft.
+
+## A One-To-One Mapping with 2-3 Trees
+
+- When inserting: Use a red link
+- If there is a right leaning “3-node”, we have a ************Left Leaning Violation************
+    - ************************rotate left the appropriate node to fix.************************
+- if There are two consecutive left links, we have an incorrect 4 node violation.
+    - rotate right the appropriate node to fix.
+- If there are any nodes with two red children, we have a temporary 4 node.
+    - color flip the node to emulate the splitting operation in 2-3 trees.
+
+One last detail: Cascading operations.
+
+- It’s possible that a rotation or flip operation will cause an additional violation that needs fixing.
+
+##

Ch 18 Red Black Trees d534df007ce5437bbbf0a5619b53f64e.md

@@ -0,0 +1,36 @@
+# Ch 21. Heaps and PQs
+
+
+A data structure that allows you to interact only with the smallest item (or largest) in the collection.
+
+## Heaps
+
+Binary tree that is a **complete** and obeys ************************************min-heap property************************************
+
+- **Min-Heap property**: Every node is less than or equal to both of its children
+- **complete**: missing items only a the bottom level (if any), all nodes are as far left as possible.
+
+Examples Trees:
+
+![Untitled](images/Ch%2021%20Heaps%20and%20PQs%20619daa83184e422abfe5e122c7c9f7ba/Untitled.png)
+
+## **Insertion:**
+
+- Temporarily place node in left as possible in the bottom level
+- “percolate” up the tree by swapping the node with it’s parent if the min-heap property is violated.
+- note this operation is $O(logN)$ because the height of the tree of N items is $**log(N)$,** so in the worst case, the new node is the new minimum, so it percolates up the levels.
+
+## **********************Delete Min:**********************
+
+- Temporarily swap the left most node in the bottom level with the root (min node)
+- Then percolate the new root down to the appropriate position by swapping with it’s smallest child until it can’t percolate down anymore.
+
+### Tree Implementation
+
+There is a number of ways to represent Trees, we will use an array based heap because it takes advantage of the completeness property. (and also takes less memory)
+
+********************************************Array Based Implementation:********************************************
+
+![Untitled](images/Ch%2021%20Heaps%20and%20PQs%20619daa83184e422abfe5e122c7c9f7ba/Untitled%201.png)
+
+Note that at index zero, it’s empty because it makes computation of the parent, leftChild, rightChild easier. However, you don’t need to do it this way.