18 Matching Annotations
  1. Jul 2023
  2. dsc-courses.github.io dsc-courses.github.io
    1. , undirected edges allow for movement in either direction whereas directed edges only allow movement in the specified direction.

      what are the instances of using undirected graph instead of directed graph and vice versa?

    1. First, identify affordances for the specific outcomes that they make more likely.

      do you find the affordance with your intuition first? or is there specific way of finding a object's affordance?

    2. Implementing removeMin, however, requires more work to maintain the completeness property.

      is it because all the nodes in the tree have to be connected to each other?

    1. The binary search tree on the right shows the result of inserting each element in the left-to-right

      I would like to know searching with this method is efficient. It seems like it is taking extra steps and could be more efficient.

    2. For example, the ABCDEFG tree depicted above has a height of 2 because there are only two edges from the overall root to any of the deepest leaf nodes.

      I think I still need some more explanation about what the height represents and how it affects the runtime.

    1. The best case (most efficient or fastest) occurs when the target is the same as the A[0]—even when the array is very large

      I think I need an extra explanation of why target being the first element in the array makes the case most efficient.

    2. Node<Integer> n2 = new Node<>(2, n3); n1.next = n2;

      in my understanding, there are two ways to define the next value, which is by putting it next to the previous value in a same parentheses, or define the next one by using .next.

    3. each linked node contains its own element and a “link” or reference to the next node

      In my understanding, all the elements in linked node are separated, but each value contains information about node's element and what is the next element

    4. Asymptotic analysis is a way of evaluating the efficiency of an algorithm on large inputs.

      In what occasion, asymptotic analysis is useful. Why do we need to evaluate the efficiency of the code?