**Data Structures and Algorithms: Deep Dive Using Java**

English | MP4 | AVC 1280×720 | AAC 48KHz 2ch | 16 Hours | 1.76 GB

Learn about Arrays, Linked Lists, Trees, Hashtables, Stacks, Queues, Heaps, Sort algorithms and Search algorithms

This is a hands-on course! If you want to try understand things at a deep level, and work on implementations, rather than theory, then again, this is the course for you.

Topics covered:

- Arrays
- Linked Lists
- Trees
- Hashtables
- Stacks
- Queues
- Heaps
- Sort algorithms
- Search algorithms

The course also spends more time than most other courses of its kind looking at what’s available in the JDK. Students wanting to understand how things work “under the hood” will benefit enormously from this course.

The reality is, the more you learn about data structures and algorithms, the better a programmer you become.

After completing this course, you will have a solid understanding of data structures and algorithms (both the theory, and the implementation).

What Will I Learn?

- Learn the strengths and weaknesses of a variety of data structures, so you can choose the best data structure for your data and applications
- Code an implementation of each data structure, so you understand how they work under the covers
- Learn many of the algorithms commonly used to sort data, so your applications will perform efficiently when sorting large datasets
- Learn what’s available in the JDK for storing and sorting data, so you won’t waste time reinventing the wheel

**Table of Contents**

**Introduction**

1 Introduction to the Course

2 JDK8 for Windows

3 JDK8 for MAC

4 JDK8 for Linux

5 IntelliJ for Windows

6 IntelliJ for MAC

7 IntelliJ for Linux

8 Introduction to Data Structures

9 Introduction to Algorithms

**Arrays and Big-O Notation**

10 Introduction to Arrays

11 Big-O Notation

12 A Quick Review of Arrays in Java

13 Arrays in Memory

14 Big-O Values for Array Operations

**Sort Algorithms**

15 Introduction to Sort Algorithms

16 Bubble Sort (Theory)

17 Bubble Sort (Implementation)

18 Stable vs. Unstable Sort Algorithms

19 Selection Sort (Theory)

20 Selection Sort (Implementation)

21 Insertion Sort (Theory)

22 Insertion Sort (Implementation)

23 Shell Sort (Theory)

24 Shell Sort (Implementation)

25 Recursion

26 Merge Sort (Theory)

27 Merge Sort (Implementation)

28 Quick Sort (Theory)

29 Quick Sort (Implementation)

30 Counting Sort (Theory)

31 Counting Sort (Implementation)

32 Radix Sort (Theory)

33 Stable Counting Sort (Theory)

34 Radix Sort (Implementation)

35 Sorting Arrays Using the JDK

36 Sort Algorithms Challenge 1

37 Sort Algorithms Challenge 1 Solution

38 Sort Algorithms Challenge 2

39 Sort Algorithms Challenge 2 Solution

40 Sort Algorithms Challenge 3

41 Sort Algorithms Challenge 3 Solution

**Lists**

42 Introduction to Lists

43 Abstract Data Types

44 Array Lists

45 Vectors

46 Singly Linked Lists (Theory)

47 Singly Linked Lists (Implementation)

48 Doubly Linked Lists (Theory)

49 Doubly Linked Lists (Implementation)

50 The JDK LinkedList Class

51 Linked Lists Challenge 1

52 Linked Lists Challenge 1 Solution

53 Linked Lists Challenge 2

54 Linked Lists Challenge 2 Solution

**Stacks**

55 Introduction to Stacks

56 Stacks (Theory)

57 Stacks Implementation (Array)

58 Stacks Implementation (Linked List)

59 Stacks Challenge

60 Stacks Challenge Solution

**Queues**

61 Introduction to Queues

62 Queues (Theory)

63 Queues (Array Implementation)

64 Circular Queue Implementation (Part One)

65 Circular Queue Implementation (Part Two)

66 Queues and the JDK

67 Queues Challenge

68 Queues Challenge Solution

**Hashtables**

69 Introduction to Hashtables

70 Hashtables (Theory)

71 Hashtables (Array Implementation)

72 Linear Probing

73 Linear Probing – Removing Items

74 Linear Probing – Rehashing

75 Chaining

76 Hashtables and the JDK

77 Bucket Sort (Theory)

78 Bucket Sort (Implementation)

79 Hashtables Challenge 1

80 Hashtables Challenge 1 Solution

81 Hashtables Challenge 2

82 Hashtables Challenge 2 Solution

**Search Algorithms**

83 Introduction to Search Algorithms

84 Linear Search Algorithm

85 Binary Search Algorithm

86 Binary Search (Implementation)

**Trees**

87 Introduction to Trees

88 Trees (Theory)

89 Binary Search Trees (Theory)

90 Binary Search Trees (Insertion)

91 Binary Search Trees (Traversal)

92 Binary Search Trees (Get Min Max)

93 Binary Search Trees (Delete Cases 1 and 2)

94 Binary Search Trees (Implement Cases 1 and 2)

95 Binary Search Trees (Delete Case 3)

96 Binary Seach Trees (Implement Case 3)

97 Trees and the JDK

98 Binary Search Trees Challenge 1

99 Binary Search Trees Challenge 1 Solution

100 Binary Search Trees Challenge 2

**Heaps**

101 Introduction to Heaps

102 Heaps (Theory)

103 Storing Heaps as Arrays

104 Heaps (Insert)

105 Heaps (Delete Theory)

106 Heaps (Delete)

107 Heaps (Peek)

108 Priority Queues

109 Heapsort (Theory)

110 Heapsort (Implementation)

**Course Wrap-Up**

111 Sets

112 Course Wrap-Up

**Bonus Material**

113 Bonus – Please Watch

114 All Courses

115 Source Codes

Resolve the captcha to access the links!