note update

- dsa

Author: xy-241

content/Data Structure/Array.md

@@ -6,7 +6,7 @@ Author Profile:
 tags:
   - dsa
 Creation Date: 2023-10-08T20:10:00
-Last Date: 2024-03-17T15:13:20+08:00
+Last Date: 2024-03-18T18:47:10+08:00
 References: 
 ---
 ## Abstract
@@ -29,14 +29,18 @@ References:
 > $O(n)$ to search for a value.
 
 >[!note]- Indexing
-> It is $O(1)$  to index any elements in an array. The indexing formula is `elementAddr = firtstElementAddr + elementLength * elementIndex`, `elementIndex` is $0$ when we try to access the first element
+> It is $O(1)$  to index any elements in an array. The indexing formula is `elementAddr = firtstElementAddr + elementLength * elementIndex`, `elementIndex` is $0$ when we try to access the first element.
+> 
+> ![[array_indexing.png]]
 
 >[!note]- Insert, Delete
 > $O(1)$ at the 2 ends of the array
 > 
 > $O(n)$ in the middle of the array
 > - For insert, we have to move all the elements next to the new element one step to right
 > - For delete, we have move all element next to the deleted element one step to left
+> 
+> ![[array_delete.gif]]
 
 >[!info]- Performance comparison with Linked List when going through all elements
 > Array is much faster if there is [[CPU Cache]], otherwise it may be slightly slower. Because Array has to calculate the address of the next element, while [[Linked List]] is already calculated.
@@ -51,15 +55,24 @@ References:
 ---
 ![[dyanmic_array_memory_allocation.png|500]]
 - Also known as **List**
-- Resizable [[Array]], achieved by building an [[Abstraction (抽象)]] above the Array
+- A [[Datatype]] that contains a [[Pointer]] to the underlying [[Array]] and other metadata like the capacity of the array and the current size of the array. As shown above, the purple blocks contain the metadata of the dynamic array. The yellow blocks are the actually array that hold the elements
+
+
+>[!bigbrain] Dynamic array mechanism visualisation
+> ![[dyanamic_array_visual.gif]]
 
 
 >[!success] Convenient
 > Developers don't need to re-write battle-tested logic of re-sizeing Array etc, battery-packed with best practices.
 
+>[!success] Secure
+> With the built-in expansion mechanism and `length` metadata, we are sure new elements aren't added into [[Memory Address]] that belong to other parts of the [[Process (进程)]]. Thus, ensuring [[Memory Safety]].
+
 >[!attention] More Resource Intense
-> We can't fine tune every Array operations because the implementation details are abstracted away. We only have a limited interface to interact with it.
+> We can't fine tune every Array operations because the implementation details are abstracted away. We only have a limited interface to interact with it. And Dynamic array comes with metadata to support the different functionalities it offers.
 
+>[!tip] Minimise re-sizing
+> If you know how big an array you want, it is usually recommended to set it as the capacity of your dynamic array. This reduce the need of frequent **re-sizing operations** which mean fewer allocation on [[Address Space#Heap Segment]]. Thus, better performance.
 ## Circular Array
 ---
 - Connect the start and end of the [[Array]] to form a loop

content/Data Structure/Linked List.md

@@ -7,13 +7,32 @@ tags:
   - dsa
   - java
 Creation Date: 2023-08-05T14:45:43+08:00
-Last Date: 2024-03-17T15:04:51+08:00
+Last Date: 2024-03-18T18:52:31+08:00
 References: 
 ---
 ## Abstract
 ---
+![[linked_list.png|700]]
 - A [[Data Structure#Linear]] collection of elements of the same [[Datatype]] that stored in [[Data Structure#Discrete Memory]]. Each node contains a [[Pointer]] to the next node
 
+
+>[!success] Adjustable size with minimal impact
+> If we want to add in a new node, we just need to modify the pointer of the previous node & the pointer of the next node - in **constant time**. Since the connection between the 2 nodes are via **Pointer**, we can have nodes all around the [[Main Memory]]. This means we can add more nodes as long as there is free memory size that can fit a single node.
+> 
+> ![[linked_list_memory_operation.gif]]
+
+
+
+>[!attention] Cache Miss!!!
+> Since the connection between 2 nodes are via Pointer, the nodes are scattered around the Main Memory. This means we can't make use of [[CPU Cache#Cache Locality]] and this results in [[CPU Cache#Cache Miss]].
+> 
+> ![[linked_list_cache_miss.gif]]
+
+>[!caution] Memory Leak
+> For languages like [[C]] which doesn't come with a [[Garbage Collector]], we need to manually release deleted node from the [[Address Space#Heap Segment]] to prevent [[Address Space#Memory leak]].
+
+
+
 >[!code]- Linked list node implemented with Java
 > ```java
 > public class Node {
@@ -44,24 +63,14 @@ References:
 
 >[!tip]- Virtual Node
 > O(1) to access either the **head node** or the **tail node**, this makes handling edge cases & reverting linked list easier.
-
->[!success]- Adjustable size with great efficiency
-> If we want to expand, we just need to modify the pointers of the previous node & the pointers of the next node. **Consistent performance**.
-
->[!success]- Can be stored in memory in a flexible way
-> Since the connection between 2 nodes are via [[Pointer]], we can have nodes all around the [[Main Memory]]. This means we can add more nodes when there is free memory size that can fit a single node.
-
->[!attention]- Cache Miss!!!
-> Since the connection between 2 nodes are via Pointer, the nodes are scattered around the Main Memory. This means we can't make use of [[CPU Cache#Cache Locality]] and resulting in [[CPU Cache#Cache Miss]].
-
->[!caution]- Memory Leak
-> For languages like [[C]] which doesn't come with a [[Garbage Collector]], we need to manually release deleted node from the [[Address Space#Heap Segment]] to prevent [[Address Space#Memory leak]].
 ### Time Complexity
 >[!note]- Search
 > $O(n)$ to search for a value. 
 
 >[!node]- Indexing
-> $O(n)$, because the desired [[Memory Address]] can't be obtained by simply incrementing the index like what we can do with [[Array]]. what we have at the start of every indexing is the memory address of the next node, we need to traverse n-1 nodes in order to access nth node.
+> It takes $O(n)$ to obtain the node at a particular position, because the desired [[Memory Address]] can't be obtained by simply incrementing the index like what we can do with [[Array]]. what we have at the start of every indexing is the memory address of the next node, we need to traverse n-1 nodes in order to access nth node.
+> 
+> ![[linked_list_indexing.png]]
 
 >[!note]+ Insert, Delete
 > $O(1)$, we only need the node's previous node and next node, make the corresponding pointer changes.