Final Exam: Developer

Intermediate
  • 1 Video | 32s
  • Includes Assessment
  • Earns a Badge
Final Exam: Developer will test your knowledge and application of the topics presented throughout the Developer track of the Skillsoft Aspire Developer to App Architect Journey.

WHAT YOU WILL LEARN

  • explain depth-first, in-order traversal in a binary tree
    explain depth-first, pre-order traversal in a binary tree
    summarize depth-first traversal in a binary tree
    explain what is meant by the topological sorting of graph nodes
    recognize how the recursive algorithm to count nodes works
    write code to implement bubble sort
    create a task to be executed within a Java thread by implementing the Runnable interface
    implement semaphores in a multi-threaded Java application where each thread is treated equally
    use the tryLock() method of a ReentrantLock to prevent a potentially long wait for a resource
    identify the behavior of producer and consumer threads when working with a shared bounded buffer
    write code to implement the count nodes algorithm
    recognize directed and undirected graphs and their use cases
    define the adjacency list representation of a graph
    identify a sequential execution plan as well as its limitations
    write code to implement insertion sort
    describe the original binary tree and its mirror
    define the insertion sort algorithms
    describe how a graph can be represented as an adjacency matrix
    describe how an ExecutorService instance can be shut down while still allowing submitted tasks to run
    explain depth-first, post-order traversal in a binary tree
    enable atomic operations on integer variables using an AtomicInteger object
    identify when the shortest path to a node needs to be updated
    recognize how the maximum depth of a binary tree is calculated
    recognize the behavior of producer and consumer threads when working with a shared bounded buffer
    explain the array implementation of a binary heap
    recognize the situations where a race condition could occur in Java
    use the join() method to synchronize one thread with the execution of another
    implement the mirroring of a binary tree
    recognize the trade-offs involved in choosing sorting algorithms
    introduce a ReentrantLock in your program to enable exclusive access to a shared resource
  • recognize the options available to monitor the execution of a task using a Future object
    explain weighted graphs and their use cases
    summarize breadth-first traversal in a binary tree
    compare the graceful and immediate shutdown of an ExecutorService instance
    describe how lookup works in a binary search tree
    recognize the conditions under which concurrent threads may become deadlocked and how this can be prevented
    recognize the characteristics of binary trees
    contrast the algorithms for shortest path in unweighted and weighted graphs
    recall the conditions under which concurrent threads could encounter a deadlock in Java
    explain how insertion works in a binary search tree
    recognize the effects of updates to shared variables in a multi-threaded Java applications
    distinguish between the graceful and immediate shutdown of an ExecutorService instance
    explain the common operations to be performed on a priority queue
    explain the shortest path algorithm for unweighted graphs
    describe a multi-threaded approach to tackling multiple tasks
    describe the binary search algorithm
    recognize how to insert and to remove works on a binary heap
    calculate the maximum depth of a binary tree
    use semaphores in a multi-threaded Java application where different threads require varying levels of permits to access a shared resource
    define a producer task that can run concurrently with a consumer using a shared queue
    perform operations on an adjacency matrix graph
    define a task to be executed within a Java thread by implementing the Runnable interface
    identify use cases for semaphores and describe how they can be used
    recognize the effect of the start() method in kicking off Java threads
    describe how a binary heap data structure functions
    explain the bubble sort algorithm
    define the structure and components of a graph
    define the quick sort algorithm
    summarize the heapify operation on a binary heap
    describe the selection sort algorithm

IN THIS COURSE

  • Playable
    1. 
    Developer
    33s
    UP NEXT

EARN A DIGITAL BADGE WHEN YOU COMPLETE THIS COURSE

Skillsoft is providing you the opportunity to earn a digital badge upon successful completion of this course, which can be shared on any social network or business platform

Digital badges are yours to keep, forever.

YOU MIGHT ALSO LIKE