Section 1 : Introduction

Lecture 1 INTRODUCTION TO BRAINMEASURES PROCTOR SYSTEM Pdf
Lecture 2 About Certification Pdf

Section 2 : Data Structures Overview

Lecture 3 Why to use data structures 4:46
Lecture 4 Data structures and abstract data types 3:30

Section 3 : Installation and Environment Setup

Lecture 5 Installing Python and PyCharm on Windows Text
Lecture 6 Installing Python and PyCharm on Mac Text

Section 4 : Data Structures - Arrays

Lecture 7 What are array data structures 6:52
Lecture 8 Arrays introduction - operations 6:54
Lecture 9 Arrays in Python 8:1
Lecture 10 What are real arrays in Python 3:52

Section 5 : Interview Questions (Arrays)

Lecture 11 Reversing an array in-place overview Text
Lecture 12 Reversing an array in-place solution 4:39
Lecture 13 Palindrome problem overview Text
Lecture 14 Palindrome problem solution 6:29
Lecture 15 Integer reversion problem overview Text
Lecture 16 Integer reversion problem solution 9:57
Lecture 17 Anagram problem overview Text
Lecture 18 Anagram problem solution 5:38
Lecture 19 Duplicates in an array problem overview Text
Lecture 20 Duplicates in an array problem solution 10:34

Section 6 : Data Structures - Linked Lists

Lecture 21 What are linked lists 4:50
Lecture 22 Linked list introduction - operations 11:0
Lecture 23 Linked list implementation I 7:43
Lecture 24 Linked list implementation II 4:17
Lecture 25 Linked list implementation III 8:25
Lecture 26 Comparing linked lists and arrays 6:24
Lecture 27 Practical (real-world) applications of linked lists

Section 7 : Data Structures - Doubly Linked Lists

Lecture 28 What are doubly linked lists 6:55
Lecture 29 Doubly linked list implementation 8:8
Lecture 30 Running time comparison linked lists and arrays 3:54

Section 8 : Interview Questions (Linked Lists)

Lecture 31 Finding the middle node in a linked list overview Text
Lecture 32 Finding the middle node in a linked list solution 5:26
Lecture 33 Reverse a linked list in-place overview Text
Lecture 34 Reverse a linked list in-place solution 6:52

Section 9 : Data Structures - Stacks

Lecture 35 What are stacks 4:32
Lecture 36 Stacks in memory management (stacks and heaps ) 3:41
Lecture 37 Stack memory visualization 6:15
Lecture 38 Stack implementation 8:39
Lecture 39 Practical (real-world) applications of stacks 3:20

Section 10 : Data Structures - Queues

Lecture 40 What are queues 4:11
Lecture 41 Queue implementation 8:34

Section 11 : Interview Questions (Stacks and Queues)

Lecture 42 Max in a stack problem overview Text
Lecture 43 Max in a stack problem solution 7:5
Lecture 44 Queue with stack problem Text
Lecture 45 Queue with stack problem solution 6:4
Lecture 46 Queue with stack problem solution - recursion 3:46

Section 12 : Data Structures - Binary Search Trees

Lecture 47 What are binary search trees 14:33
Lecture 48 Binary search trees theory - search, insert 7:52
Lecture 49 Binary search trees theory - delete 6:12
Lecture 50 Binary search trees theory - in-order traversal 5:28
Lecture 51 Binary search trees theory - running times 4:31
Lecture 52 Binary search tree implementation I 7:54
Lecture 53 Binary Search Tree implementation II 10:26
Lecture 54 Stack memory visualization - finding max (min) items 4:37
Lecture 55 Stack memory visualization - tree traversal 5:55
Lecture 56 Binary Search Tree implementation III 13:50
Lecture 57 Practical (real-world) applications of trees

Section 13 : Interview Questions (Binary Search Trees)

Lecture 58 Compare binary trees overview Text
Lecture 59 Compare binary trees solution 4:25

Section 14 : Data Structures - AVL Trees

Lecture 60 Motivation behind balanced binary search trees 3:23
Lecture 61 What are AVL trees 6:43
Lecture 62 AVL trees introduction - height 12:35
Lecture 63 AVL trees introduction - rotations 9:3
Lecture 64 AVL trees introduction - illustration 5:14
Lecture 65 AVL tree implementation I 9:47
Lecture 66 AVL tree implementation II 8:16
Lecture 67 AVL tree implementation III
Lecture 68 AVL tree implementation IV 7:48
Lecture 69 AVL tree implementation V 2:21
Lecture 70 Practical (real-world) applications of balanced binary search trees 3:37

Section 15 : Data Structures - Red-Black Trees

Lecture 71 What are red-black trees 10:45
Lecture 72 The logic behind red-black trees 5:22
Lecture 73 Red-black trees - recoloring and rotation cases 9:22
Lecture 74 Red-black tree illustrations 7:33
Lecture 75 Red-black tree implementation I 6:51
Lecture 76 Red-black tree implementation II 5:34
Lecture 77 Red-black tree implementation III 9:57
Lecture 78 Red-black tree implementation IV 2:10
Lecture 79 Differences between red-black tree and AVL trees 2:43

Section 16 : Data Structures - Heaps

Lecture 80 What are priority queues 4:29
Lecture 81 Heap introduction - basics 10:11
Lecture 82 Heap introduction - array representation 9:33
Lecture 83 Heap introduction - remove operation 7:8
Lecture 84 Using heap data structure to sort (heapsort) 6:21
Lecture 85 Heap introduction - operations complexities 5:5
Lecture 86 Binomial and Fibonacci heaps 4:15
Lecture 87 Heap implementation I 5:9
Lecture 88 Heap implementation II 10:15
Lecture 89 Heap implementation III 4:27
Lecture 90 Heaps in Python 3:54

Section 17 : Interview Questions (Heaps)

Lecture 91 Interview question #1 - checking heap properties Text
Lecture 92 Interview question #1 - solution 6:44
Lecture 93 Interview question #2 - max heap to a min heap Text
Lecture 94 Interview question #2 - solution 6:54

Section 18 : Data Structures - Associative Arrays (Dictionaries)

Lecture 95 What are associative arrays 5:46
Lecture 96 Hashtable introduction - basics 11:20
Lecture 97 Hashtable introduction - collisions 11:16
Lecture 98 Hashtable introduction - dynamic resizing 7:5
Lecture 99 Linear probing implementation I 6:0
Lecture 100 Linear probing implementation II 6:24
Lecture 101 Linear probing implementation III 2:12
Lecture 102 Dictionaires in Python 3:38
Lecture 103 Practical (real-world) applications of hashing 6:31

Section 19 : Graph Algorithms Overview

Lecture 104 Graph theory overview 3:46
Lecture 105 Adjacency matrix and adjacency list 6:8
Lecture 106 Applications of graphs 4:2

Section 20 : Graph Algorithms - Graph Traversal Algorithms

Lecture 107 Breadth-first search introduction 9:29
Lecture 108 Breadth-first search implementation 7:57
Lecture 109 What are WebCrawlers (core of search engines) 5:47
Lecture 110 WebCrawler basic implementation 9:40
Lecture 111 Depth-first search introduction 10:20
Lecture 112 Depth-first search implementation 5:55
Lecture 113 Depth-first search implementation II Text
Lecture 114 Memory management BFS vs DFS 5:23

Section 21 : Interview Questions (Graph Traversal)

Lecture 115 Interview question #1 - implement DFS with recursion Text
Lecture 116 Interview question #1 - solution 2:52
Lecture 117 Depth-first search and stack memory visualisation 6:2
Lecture 118 Interview question #2 - using BFS to find way out of maze Text
Lecture 119 Interview question #2 - solution 16:15

Section 22 : Graph Algorithms - Shortest Paths with Dijkstra's Algorithm

Lecture 120 What is the shortest path problem 4:44
Lecture 121 Dijkstra algorithm visualization 11:0
Lecture 122 Dijkstra algorithm implementation I - Edge, Node 10:30
Lecture 123 Dijkstra algorithm implementation II - algorithm 13:54
Lecture 124 Dijkstra algorithm implementation III - testing 3:52
Lecture 125 Dijktsra's algorithm with adjacency matrix representation 12:8
Lecture 126 Adjacency matrix representation implementation 12:43
Lecture 127 Shortest path algorithms applications 5:5
Lecture 128 What is the critical path method (CPM) 4:8

Section 23 : Graph Algorithms - Shortest Paths with Bellman-Ford Algorithm

Lecture 129 What is the Bellman-Ford algorithm 13:37
Lecture 130 Bellman-Ford algorithm visualization 5:17
Lecture 131 Bellman-Ford algorithm implementation I - Node, Edge 1:36
Lecture 132 Bellman-Ford algorithm implementation II - the algorithm 7:43
Lecture 133 Bellman-Ford algorithm implementation III - testing 3:18
Lecture 134 Greedy algorithm or dynamic programming approach 5:43

Section 24 : Interview Questions (Shortest Paths)

Lecture 135 Interview question #1 - detecting negative cycles on the FOREX Text
Lecture 136 How to use Bellman-Ford algorithm on the FOREX 6:25
Lecture 137 Interview question #1 - solution

Section 25 : Graph Algorithms - Spanning Trees with Kruskal Algorithm

Lecture 138 What is the disjoint set data structure 14:11
Lecture 139 Disjoint sets visualization 5:50
Lecture 140 Kruskal's algorithm introduction 10:5
Lecture 141 Kruskal algorithm implementation I - basic classes 6:22
Lecture 142 Kruskal algorithm implementation II - disjoint set 13:0
Lecture 143 Kruskal algorithm implementation III - algorithm 5:12
Lecture 144 Kruskal algorithm implementation VI - testing 3:22

Section 26 : Graph Algorithms - Spanning Trees with Prims Algorithm

Lecture 145 What is the Prim-Jarnik algorithm 9:34
Lecture 146 Prims-Jarnik algorithm implementation I 10:23
Lecture 147 Prims-Jarnik algorithm implementation II 3:11
Lecture 148 Applications of spanning trees 6:3

Section 27 : Basic Sorting Algorithms

Lecture 149 Sorting introduction 7:34
Lecture 150 Visualizing sorting algorithms with Algorhyme Text
Lecture 151 What is stability in sorting 6:6
Lecture 152 What is adaptive sorting 3:10
Lecture 153 Bogo sort introduction 3:11
Lecture 154 Bogo sort implementation 7:50
Lecture 155 Bubble sort introduction 5:24
Lecture 156 Bubble sort implementation 5:29
Lecture 157 Selection sort introduction 5:14
Lecture 158 Selection sort implementation 5:27
Lecture 159 Insertion sort introduction 8:32
Lecture 160 Insertion sort implementation 5:21
Lecture 161 Exercise - sorting custom objects with insertion sort Text
Lecture 162 Solution - sorting custom objects with insertion sort Text
Lecture 163 Shell sort introduction 6:15
Lecture 164 Shell sort implementation 6:24
Lecture 165 Quicksort introduction 12:11
Lecture 166 Quicksort introduction - example 7:41
Lecture 167 Quicksort implementation 11:33
Lecture 168 Hoare's partitioning and Lomuto's partitioning Text
Lecture 169 What is the worst-case scenario for quicksort 7:18
Lecture 170 Merge sort introduction
Lecture 171 Merge sort implementation 8:20
Lecture 172 Stack memory and merge sort visualization 7:46
Lecture 173 Hybrid algorithms introduction 6:6
Lecture 174 Non-comparison based algorithms 2:11
Lecture 175 Counting sort introduction 10:14
Lecture 176 Measure running time differences Text
Lecture 177 Counting sort implementation 9:46
Lecture 178 Radix sort introduction 13:0
Lecture 179 Radix sort implementation 13:34

Section 28 : Interview Questions (Sorting)

Lecture 180 Interview question #1 - implementing TimSort algorithm Text
Lecture 181 Interview question #1 - solution Text
Lecture 182 Interview question #2 - implement quicksort with iteration Text
Lecture 183 Interview question #2 - solution Text
Lecture 184 Interview question #3 - implementing selection sort with recursion Text
Lecture 185 Interview question #3 - solution Text

Section 29 : Next Steps

Lecture 186 About Proctor Testing Pdf

Section 30 : Course Materials (DOWNLOADS)

Lecture 187 Download course materials (slides and source code) Text