Holczer Balazs – Algorithms and Data Structures in Java – Part I | Available Now !

Stacks in memory management ( stacks, heaps ) (7:23)

Stacks and recursive method calls (7:02)

Stack implementation with linked list I (7:28)

Stack implementation with linked list II (3:38)

Stack implementation with arrays (11:01)

Dijkstra’s interpreter introduction (1:18)

Dijkstra’s interpreter implementation (9:12)

Java built in java.util.Stack (5:09)

Queues introduction (5:12)

Queue implementation with linked list (9:43)

Java built in java.util.Queue (6:31)

Binary search trees theory – basics (10:23)

Binary search trees theory – search, insert (4:25)

Binary search trees theory – delete (6:08)

Binary search trees theory – in-order traversal (4:25)

Binary search trees theory – running times (2:10)

Binary search trees implementation I – Node, Tree (7:02)

Binary search trees implementation II – insertion (9:55)

Binary search tree implementation III – maximum, minimum (7:24)

Binary search tree implementation IV – traversal (5:41)

Binary search tree implementation V – remove (9:25)

Binary search tree implementation VI – remove II (5:54)

Custom objects in a tree (6:44)

AVL trees introduction – motivation (4:13)

AVL trees introduction – basics (5:21)

AVL trees introduction – height (8:44)

AVL trees introduction – rotations cases (10:17)

AVL trees introduction – illustration (10:50)

AVL trees introduction – sorting (3:38)

AVL implementation – Node and Tree (3:21)

AVL implementation – balance and height parameters (4:45)

AVL implementation – implementing the rotations (7:36)

AVL implementation – insertion I (6:03)

AVL implementation – insertion II (8:52)

AVL implementation – testing (3:19)

AVL tree remove introduction (6:35)

AVL tree remove implementation I (8:31)

AVL tree generic implementation (3:55)

Red-black trees introduction – basics (10:38)

The logic behind red-black trees (4:15)

Red-black trees rotations- cases I (5:10)

Red-black trees rotations- cases II (4:25)

Red-black trees rotations- cases III (3:17)

Red-black trees rotations- cases IV (2:45)

Red-black trees introduction – example I (4:47)

Red-black trees introduction – example II (4:19)

Red-black tree versus AVL tree (3:25)

Red-black tree implementation I – Node class (4:28)

Red-black tree implementation II – traverse (2:06)

Red-black tree implementation III – insert (3:40)

Red-black tree implementation IV – rotate left / right (5:48)

Red-black tree implementation V – fixing the violations (9:52)

Red-black tree implementation VI – fixing the violations (5:52)

Red-black tree implementation VII – testing (1:59)

Splay tree introduction I – basics (12:49)

Splay tree introduction II – example (3:52)

Splay tree implementation I – find, rotate (9:44)

Splay tree implementation II – spalying (3:34)

Splay tree implementation III – testing (5:50)

Priority queues introduction (8:13)

Heap introduction – basics (8:14)

Heap introduction – array representation (9:17)

Heap introduction – remove operation (4:43)

Heap introduction – heapsort (5:13)

Heap introduction – running times (5:05)

Other types of heaps: binomial and Fibonacci heap (2:59)

Heap implementation I (8:28)

Heap implementation II (6:38)

Heap implementation III (5:00)

Heaps in java.util.PriorityQueue (8:33)

B-tree introduction – basics (13:01)

B-tree and external memory (4:07)

Disk access times (5:41)

B-tree introduction – search (2:46)

B-tree introduction – insertion (7:10)

B-tree introduction – deletion (5:30)

In-order traversal (4:06)

Associative array ADT (2:37)

Hashtables introduction – basics (9:04)

Hashtables introduction – collisions (6:59)

Hashtables introduction – load factor & dynamic resizing (6:03)

Chaining method summary (4:05)

Chaining implementation I – put (9:16)

Chaining implementation II – get (4:27)

Chaining implementation III – testing

Linear probing summary (3:59)

Linear probing implementation I – put (5:32)

Linear probing implementation II – get (2:57)

Linear probing implementation III – testing (4:44)

Generic linear probing implementation I – basics (6:44)

Generic linear probing implementation II – get (4:14)

Generic linear probing implementation III – put (5:35)

Generic linear probing implementation IV – remove (6:26)

Generic linear probing implementation V – resize (5:30)

Generic linear probing implementation VI – testing (2:39)

Generic linear probing implementation – hashCode (2:05)

Maps in Java Collections (5:52)

Why to use cache? (3:25)

LRU cache introduction (8:06)

LRU cache implementation I (4:22)

LRU cache implementation II (11:18)

Slides

Source code