Please enable JavaScript.

Coggle requires JavaScript to display documents.

Study (Binary Tree (Formulas (Maximum number of nodes at level ‘l’ is 2l…

- - - - LL have this vantages over Array 1. Dynamic Size; 2 - Fast Insertion and Delition
    - - Finding/Acessing O(n) Its proportional to the LL size
      - Insert / Deleting Head O(1) as it already in the head
      - Inserting/Deleting O(n) as you have to run over the LL to find
    - - Merge Sort : A divide and conquer Algorithm
        
        Sort()
        
        FindMiddle
        
        MergeSort()
        
        If head or next ar null
        
        Find the middle
        
        pick the middle.next value to a new var. set middle.next as null
        
        REscursio to MergeSort using Head and result set to Left var
        
        Use MiddleNext var to recursion and set result to right
        
        Call Sort Alg
    - - 1 they should be sorted first.
      - Create an object Node to be returned and create an Var to be your tail, set new object node next to new var tail
      - While is tru. Validate if you A node is null and validate if B node is null
      - When Not null, validate if A is lesser than B (vlues)
      - If a lesser, set a to tail, and set a to a.next.
      - if b is lesser set b to tail and set b to b.next
      - move tail as tail = tail.next
      - at the end return the node object.next (the tail reference)