Description:
Explore implementing trees and graphs in Python in this 14-video, hands-on course that contains only labs. In this course, learners will use Python 3 and Jupyter Notebooks as their IDE (integrated development environment). In the course labs, you will implement a binary search, define a binary search tree, and use code functions to work with those data structures. Next, you will implement algorithms to traverse trees, including how to perform a breadth-first traversal and depth-first traversal of the tree. Continue by examining graph data structure, and implementing different representations of graphs in Python by using an abstract class for a graph to represent graphs as both an adjacency set and an adjacency matrix. You will implement algorithms to traverse such graphs, including a breadth-first traversal and a depth-first traversal. This course then demonstrates how to run a test to check its implementation. Finally, learners observe how to implement a topological sort for a specific type of graph which is both directed as well as acyclic.
Target Audience:
Duration: 01:27
Description:
This 13-video course explores the theory of graph and tree data structures in Python. Learners will examine a specific type of tree: the binary search tree, its structures and properties. You will then observe how to execute common tasks in binary tree; examine the binary search algorithm; and review data structures of linked lists, stacks, and queues. Next, learners will examine how a binary tree structure offers several applications that cannot be done by using stacks or queues. The course demonstrates different depth first traversals, including pre-order, in-order traversals, and post-order traversals. Explore graphs, which are data structures used to model relationships, and different representations of a graph, and learn to model a vertex. Learners continue by observing how to represent an adjacency list as a graph, and examining the adjacency matrix, the adjacency list, and the adjacency set. Then you will explore graph traversal algorithms, including the topological sort. Finally, learn how to traverse through each of the vertices in a graph.
Target Audience:
Duration: 01:34
Description:
Examine the Python implementation of common sorting algorithms such as selection sort, bubble sort, and insertion sort, as well as divide and conquer sorts such as shell sort, merge sort, and quicksort, in this 10-video course. Key concepts covered in this course include how to write the code to implement a selection sort; how to implement the bubble sort algorithm in Python; and how to code a function to implement the insertion sort algorithm. Next, you will observe how to write the code to implement the divide-and-conquer shell sort algorithm; how to invoke the shell sort algorithm on an array of integers and examine the output at each iteration to understand how it works; and how to code a function to implement the merge sort algorithm and test it on an array of integers. Finally, learn how to write the partition and quicksort functions in order to implement a quicksort; and how to apply quicksort on an array of integers and analyze the results at each iteration to understand how the algorithm works.
Target Audience:
Duration: 01:11
Description:
In this 11-video course, learners explore workings of some of the most widely used sorting algorithms in Python and examine how their performance affects various measures. Key concepts covered here include various properties of sorting algorithms when selecting the right one for your data; the operations involved when sorting a list of values by using the selection sort algorithm; and the process of a bubble sort when applied to a list of values. Next, you will learn about the performance of the bubble sort on various measures such as time, space, and number of swaps; how to describe the steps involved in performing an insertion sort and compare it to the bubble sort; and learn the workings of the shell sort and the performance metrics of this divide and conquer algorithm. Finally, you will learn the process of sorting a list of elements using merge sort and list the complexity of this algorithm on various measures; and learn how the quicksort algorithm partitions and sorts a list of elements.
Target Audience:
Duration: 01:16
Description:
Examine operations that have different values of time complexity and delve into implementation of basic data structures, such as linked lists, stacks, and queues in Python, in this 13-video course. Key concepts covered here include operations that run in constant time regardless of input; code whose time complexity varies directly with value of input; and tasks whose time complexity varies linearly with size of input. Next, you will learn about operations whose time complexity varies as the square of input size; how to use native queue class of Python and perform standard queue operations; and how to code a queue class for many standard queue operations, such as enqueue and dequeue. Then, learn how a Python list can be used as a stack by loading and unloading elements, and how to implement a custom stack class for common stack operations. Finally, study code functions to perform search and delete operations in linked lists and reverse the ordering of its nodes; and create a linked list and test out various operations that have been defined.
Target Audience:
Duration: 01:30
Description:
Explore Python data structures and delve into the details of some of the basic structures, such as linked lists, stacks, and queues. Key concepts covered in this 12-video course include the metrics on which algorithms and operations on data are evaluated; learning how the performance of operations and algorithms is expressed in terms of size of input; and learning about linked lists and their contents and structure. Next, study different ways in which nodes can be added to a linked list and how search operations work on this data structure; learn methods to remove nodes from a linked list and the process of reversing the order of nodes in this data structure; and learn techniques used to keep track of numbers of elements in linked lists. You will examine workings of a stack data structure, including the addition and removal of elements; learn some of the operations on stacks, such as ISEMPTY and ISFULL, and the complexities of different stack operations; and learn the queue data structure and how to compare it to stacks.
Target Audience:
Duration: 01:20