# Algorithms and Data Structures in Java – Part I Algorithms and Data Structures in Java – Part I
English | MP4 | AVC 1280×720 | AAC 48KHz 2ch | 11.5 Hours |1.46 GB

AVL tree, red-black tree, B-tree, binary search tree, array, linked list, stack, queue and splay tree

This course is about data structures and algorithms. We are going to implement the problems in Java, but I try to do it as generic as possible: so the core of the algorithms can be used in C++ or Python. The course takes approximately 11 hours to complete. I highly recommend typing out these data structures several times on your own in order to get a good grasp of it.

In the first part of the course we are going to learn about basic data structures such as linked lists, stacks and queues, heaps and some advanced ones such as AVL trees, red-black trees or hash tables. We will try to optimize each data structure ( for example avoiding obsolete references ) as much as possible.

In each chapter I am going to talk about the theoretical background of each algorithm or data structure, then we are going to write the code on a step by step basis in Eclipse, Java.

Most of the advanced algorithms relies heavily on these topics so it is definitely worth understanding the basics. These principles can be used in several fields: in investment banking, artificial intelligence or electronic trading algorithms on the stock market.

Introduction
1 Introduction
2 Why to use data structures
3 Data structures and abstract data types
4 Complexity theory

Arrays
5 Arrays introduction - basics
6 Arrays introduction - operations
7 Using arrays
8 ArraysLists in Java

9 Linked lists theory - basics
10 Linked list theory - operations

Stacks & Queues
18 Stack introduction
19 Stacks in memory management ( stacks_ heaps )
20 Stacks and recursive method calls
21 Stack implementation with linked list I
22 Stack implementation with linked list II
23 Stack implementation with arrays
24 Dijkstra's interpreter introduction
25 Dijkstra's interpreter implementation
26 Java built in java_util_Stack
27 Queues introduction
28 Queue implementation with linked list
29 Java built in java_util_Queue

Binary Search Trees
30 Binary search trees theory - basics
31 Binary search trees theory - search_ insert
32 Binary search trees theory - delete
33 Binary search trees theory - in-order traversal
34 Binary search trees theory - running times
35 Binary search trees implementation I - Node_ Tree
36 Binary search trees implementation II - insertion
37 Binary search tree implementation III - maximum_ minimum
38 Binary search tree implementation IV - traversal
39 Binary search tree implementation V - remove
40 Binary search tree implementation VI - remove II
41 Custom objects in a tree

Balanced Trees_ AVL Trees
42 AVL trees introduction - motivation
43 AVL trees introduction - basics
44 AVL trees introduction - height
45 AVL trees introduction - rotations cases
46 AVL trees introduction - illustration
47 AVL trees introduction - sorting
48 AVL implementation - Node and Tree
49 AVL implementation - balance and height parameters
50 AVL implementation - implementing the rotations
51 AVL implementation - insertion I
52 AVL implementation - insertion II
53 AVL implementation - testing
54 AVL tree remove introduction
55 AVL tree remove implementation I
56 AVL tree generic implementation

Balanced Trees_ Red-Black Trees
57 Red-black trees introduction - basics
58 The logic behind red-black trees
59 Red-black trees rotations- cases I
60 Red-black trees rotations- cases II
61 Red-black trees rotations- cases III
62 Red-black trees rotations- cases IV
63 Red-black trees introduction - example I
64 Red-black trees introduction - example II
65 Red-black tree versus AVL tree
66 Red-black tree implementation I - Node class
67 Red-black tree implementation II - traverse
68 Red-black tree implementation III - insert
69 Red-black tree implementation IV - rotate left _ right
70 Red-black tree implementation V - fixing the violations
71 Red-black tree implementation VI - fixing the violations
72 Red-black tree implementation VII - testing

Splay Trees
73 Splay tree introduction I - basics
74 Splay tree introduction II - example
75 Splay tree implementation I - find_ rotate
76 Splay tree implementation II - spalying
77 Splay tree implementation III - testing

B-Trees
78 B-tree introduction - basics
79 B-tree and external memory
80 Disk access times
81 B-tree introduction - search
82 B-tree introduction - insertion
83 B-tree introduction - deletion
84 In-order traversal

Binary Heaps
85 Priority queues introduction
86 Heap introduction - basics
87 Heap introduction - array representation
88 Heap introduction - remove operation
89 Heap introduction - heapsort
90 Heap introduction - running times
91 Other types of heaps_ binomial and Fibonacci heap
92 Heap implementation - insertion
93 Heap implementation - get the minimum_maximum
94 Heap implementation - heapsort
95 Heap implementation - testing
96 Heaps in java_util_PriorityQueue

Hashtables
98 Hashtables introduction - basics
99 Hashtables introduction - collisions
100 Hashtables introduction - load factor & dynamic resizing
101 Chaining
102 Chaining method summary
103 Chaining implementation I - put
104 Chaining implementation II - get
105 Chaining implementation III - testing
106 Linear Probing
107 Linear probing summary
108 Linear probing implementation I - put
109 Linear probing implementation II - get
110 Linear probing implementation III - testing
111 Generic Linear Probing
112 Generic linear probing implementation I - basics
113 Generic linear probing implementation II - get
114 Generic linear probing implementation III - put
115 Generic linear probing implementation IV - remove
116 Generic linear probing implementation V - resize
117 Generic linear probing implementation VI - testing
118 Generic linear probing implementation - hashCode
119 Maps in Java Collections

Source Code & Slides
120 Slides
121 Source code
122 DISCOUNT FOR OTHER COURSES!
122 FINAL-COUPONS