# Practice things
_just going through the practice midterm problems_


1. Identifying sorting algorithms based on progression(_conceptual_)

_bubble sort_: the bigger the value = the bigger the bubble
	* compare two values from the start always, bubble up the bigger value
		keep compmaring two adjacent values till you get to the end of the list
	* kinda like gladiator m&m's

_insertion sort_: we have the left sublist which maintains a ordered state always
	* we walk along the unsorted list and try to drop our current value into the currently sorted left-hand sublist.
	* Key points: 
		left hand ordered sublist

_quick sort_: here we push things up to the top immediately where they are then sorted against the left hand sub-list

_heap sort_: make a giant heap(list) and just take the largest/smallest value and prepend/append to the """heap"""

__reponse__: insertion sort
Left side of progression is always sorted while the right isn't 
Left side also get progressively larger

2. How you know if a graph is undirected given a matrix(_code_)

_empirically_: check the upper right half of the matrix and check if each coord pair is reflected across the main axis

	1.	Take a coords pair value(_say True_)
	2.	Flip the (x,y) so we have /x,y/
	3.	If the /x,y/ value is the same as (x,y) then those two nodes are bidrectional(i.e. undirected)

The _trick_ here is making sure we don't bother check the divisor axis or below by accident.

3. Binary tree lookup(_code_)

Recursion is the smollest way of doing this so just go with that.

4. Quick sort partition(_code_)

	* Just splitting lists again
	* Checking for partition results as well

5. Graph traversal(_code_)

DFS/BFS is fair game
List/matrix meme allowed so don't even bother with other trash

6. Emperical Graph Traversal(_conceptual_)

Time complexity of either dfs/bfs will be /v\*e/ or something like that

7. Topological sort(_code_)

big meme matrix/list allowed


