**Data Structures and Algorithms in JavaScript**

English | MP4 | AVC 1920×1080 | AAC 48KHz 2ch | 16h 13m | 4.43 GB

Immerse yourself in a course tailored for engineers comfortable with JavaScript, but wanting to better understand the data structures and algorithms necessary to ace job interviews and build better software. Learn topics like recursion, stacks & queues, sorting algorithms, trees, linked lists, Binary Search Trees, Graphs, & Hash Tables, Big-O and Breadth-First and Depth-First Search all in one place! This course is your key to understanding some of the most common data structures and algorithms in Computer Science while reinforcing JavaScript programming techniques. Master these concepts and you can approach your next job interview or coding challenge with confidence!

**Table of Contents**

**Object Oriented JavaScript**

1 Introduction

2 Agenda and Scope

3 How to Succeed

4 Pseudoclassical JavaScript

5 Defining a Class

6 Using a Class

7 Exercise - Creating a Constructor

8 Creating a Constructor Solution

**Stacks and Queues**

9 Stacks

10 Stacks Interface

11 Implementing a Stack

12 Queues

13 Exercise - Creating Stacks and Queues

14 Exercise - Creating Stacks and Queues Solution

**Recursion**

15 Why Recursion _

16 Tracing Recursive Execution

17 Template for a Recursive Function

18 Looping

19 Factorial with Loop

20 Factorial with Recursion

21 Exercise - Recursion Interview Questions

22 Recursive Reverse Solution

23 Recursive Multiplier Solution

24 minStack Solution

25 Implementing a Queue with Two Stacks Solution

**Time Complexity**

26 Space vs Time Complexity

27 Calculating Time Complexity

28 Understanding Big-O

29 Calculating Big-O of JS Operations

30 Calculating Big-O of Loops

31 Exercise - Calculating Time Complexity

32 Calculating Time Complexity Solution

**Elementary Sorting**

33 Bubble Sort

34 Stability and Adaptability

35 Selection and Insertion Sort

36 Exercise - Bubble, Inspection and Selection Sort

37 Bubble, Insertion, and Selection Sort Solution

**Sorting Algorithms**

38 Merge Sort

39 Pseudocoding the Merge Routine

40 Pseudocoding the Merge Sort

41 Time Complexity for Merge Sort

42 Quick Sort Overview

43 Understanding the Qucik Sort Partition

44 Pseudocoding Quick Sort Part 1

45 Pseudocoding Quick Sort Part 2

46 Reviewing the Pseudocode

47 Debugging the Quick Sort Algorithm

48 Quick Sort Review Part 1

49 Quick Sort Review Part 2

**Trees and Searching**

50 Trees

51 Linked Lists

52 Pseudocoding a Linked Lists

53 Exercise - Implement a Linked List

54 Exercise - Implement a Linked List Solution

55 Implementing a Tree

**Reviewing Core Concepts**

56 Review - Time Complexity

57 Review - Elementary Sorting

58 Review - Recursion

59 Review - Merge Sort

60 Review - Quick Sort Part 1

61 Review - Quick Sort Part 2

62 Review - Stacks and Queues

63 Review - Linked Lists

64 Review - Trees Part 1

65 Review - Trees Part 2

**Binary Trees**

66 Binary Search Tree Overview

67 Excercise - Binary Search Trees

68 Pseudocoding a Binary Search Tree

69 BST Search Procedure

70 BST Review and Scping Discussion

71 Pseudocoding the BST contains() Method

72 Binary Search Tree Exercise Solution

73 In-Order Traversal

74 Pseudocoding In-Order Traversal Part 1

75 Pseudocoding In-Order Traversal Part 2

76 Pre-Order Traversal

77 Post-Order Traversal

78 Initial Time Complexity for a BST

79 Deleting Min_Max Nodes

80 BST Review

81 Pseudocoding MIn_Max Deletion

82 Reviewing the Min_Max Pseudocode Part 1

83 Reviewing the Min_Max Pseudocode Part 2

84 Exercise - Deleting Single-Child Nodes

85 Deleting BST Nodes Solution Part 1

86 Deleting BST Nodes Solution Part 2

87 Exercise Deleting Two Children

88 Deleting Two Children Solution

89 Analysis of Time Complexity

**Graphs and Paths**

90 Graph Vocabulary and Representations

91 Pseudocoding the Matrix Constructor

92 Pseudocoding the addNode() Method

93 Pseudocoding the addEdges() Method

94 Excercise - Adding Nodes and Edges

95 Adding Nodes and Edges Solution

96 Adjacency List

97 Pseudocoding an Adjacency List

98 Excercise - Implement a Graph

99 Implement a Graph Solution

**Depth and Breadth-First Search**

100 Graph Traversing and Depth-First Search

101 Pseudocoding DFS Part 1

102 Pseudocoding DFS Part 2

103 Breadth-First Search

104 Pseudocoding BFS

105 Depth-First Search with a Graph Solution

106 DFS Graph Stack Trace Part 1

107 DFS Graph Stack Trace Part 2

108 Depth-First Search with a tree Solution

109 Breadth-First Search Solution

110 Breadth-First Search Stack Trace

**Hash Tables**

111 Hash Tables

112 Pseudocoding a Hashing Function

113 Key Components of a Hash Table

114 Pseudocoding set(), get(), and remove()

115 Handling Collisions

116 Exercise - Implementing a Hash Table

117 Implementing a Hash Table Solution

118 Next Steps

Resolve the captcha to access the links!