**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.

**Table of Contents**

**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

**Linked Lists**

9 Linked lists theory - basics

10 Linked list theory - operations

11 Linked list theory - doubly linked lists

12 Linked list theory - linked lists versus arrays

13 Linked list implementation I

14 Linked list implementation II

15 Linked list implementation III

16 Doubly linked list introduction

17 Linked lists in java_util

**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**

97 Associative array ADT

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

Resolve the captcha to access the links!