कीजिये तैयारी Programming & Coding Interviews की

Course Curriculum

Chapter 1: Introduction

Lecture 1: Introduction

Lecture 2: Coding interviews are tough – but beatable

Chapter 2: Pointer and Arrays

Lecture 1: Introduction to pointers

Lecture 2: Pointer problems and arrays

Lecture 3: Pointer arithmetic

Lecture 4: Practice makes perfect – pointer problems

Chapter 3: Strings are just pointers at heart

Lecture 1: Working with strings

Lecture 2: Pointer as arguments to functions

Lecture 3: Practice makes perfect – string problems

Chapter 4: Linked lists can be fun!

Lecture 1: Pointers to pointers – bend your mind

Lecture 2: Pointers to pointers – reassignment and modification

Lecture 3: Get started with linked lists

Lecture 4: Warming up – Linked List get Tricky Quickly -1

Lecture 5: Warming up to – Linked List get tricky Quickly -2

Lecture 6: Cruising along – linked lists are fun aren't they?

Lecture 7: Autopilot – linked lists are easy after all

Chapter 5: Bit Manipulation

Lecture 1: Bit Manipulation – I

Lecture 2: Bit Manipulation – II

Lecture 3: Useful Bit Manipulation Techniques

Lecture 4: Get And Set The Nth Bit

Lecture 5: Print And Count Bits

Lecture 6: Reverse The Bits In An Integer

Chapter 6: General programming problems – practice makes perfect

Lecture 1: Starting up – palindromes and points within a distance

Lecture 2: Play the Game Of Life

Lecture 3: Break A Document Into Chunks

Lecture 4: Run Length Encoding And Adding Numbers Digit By Digit

Lecture 5: Sudoku Board Validation and Incrementing A Number In Another Number System

Chapter 7: Big-O Notation, Sorting And Searching Algorithms

Lecture 1: Performance and Complexity

Lecture 2: Big O Notation

Lecture 3: Big O Notation More Examples

Lecture 4: Sorting Trade-Offs

Lecture 5: Selection Sort

Lecture 6: Bubble Sort

Lecture 7: Insertion Sort

Lecture 8: Shell Sort

Lecture 9: Merge Sort

Lecture 10: Quick Sort

Lecture 11: Binary Search – search quickly through a sorted list

Chapter 8: Recursion and the recursive sense

Lecture 1: What is recursion – why is it so hard?

Lecture 2: Binary search – implemented recursively

Lecture 3: Find all subsets of a set

Lecture 4: Check whether 2 binary trees are the same

Lecture 5: Implement paint fill to color a region on screen

Lecture 6: Build A car Given Tasks And Dependencies

Lecture 7: Generate Anagrams Of A Word

Lecture 8: Help A Rat Find It's Way Through a Maze

Lecture 9: Place 8 Queens On A Board Safely

Chapter 9: Stacks And Queues

Lecture 1: Meet The Stack – Simple But Powerful

Lecture 2: Building A Stack Using Java

Lecture 3: Match Parenthesis To Check A Well Formed Expression

Lecture 4: Find The Minimum Element In A Stack In Constant Time

Lecture 5: Meet The Queue – A Familiar Sight In Everyday Life

Lecture 6: The Circular Queue – Tricky But Fast

Lecture 7: Build A Queue With Two Stacks

Chapter 10: Binary Trees

Lecture 1: Meet The Binary Tree – A Hierarchical Data Structure

Lecture 2: Breadth First Traversal

Lecture 3: Depth First – Pre-OrderTraversal

Lecture 4: Depth First – In-Order and Post-Order Traversal

Chapter 11: Binary Search Trees

Lecture 1: The Binary Search Tree – an introduction

Lecture 2: Insertion and Lookup in a Binary Search Tree

Chapter 12: Binary Tree Problems

Lecture 1: Minimum Value, Maximum Depth And Mirror

Lecture 2: Count Trees, Print Range and Is BST

Lecture 3: Has Path Sum, Print Paths, Least Common Ancestor

Chapter 13: Heaps

Lecture 1: The Heap Is Just The Best Way to Implement a Priority Queue

Lecture 2: Meet The Binary Heap – It's A Tree At Heart

Lecture 3: The Binary Heap – Logically A Tree Really An Array

Lecture 4: The Binary Heap – Making It Real With Code

Lecture 5: Heapify!

Lecture 6: Insert And Remove From A Heap

Chapter 14: Revisiting Sorting – The Heap Sort

Lecture 1: Heap Sort Phase I – Heapify

Lecture 2: Heap Sort Phase II – The Actual Sort

Chapter 15: Heap Problems

Lecture 1: Maximum Element In A Minimum Heap and K Largest Elements In A Stream

Lecture 2: Merge K Sorted Lists Into One Sorted List Using A Heap

Lecture 3: Find The Median In A Stream Of Elements

Chapter 16: Graphs

Lecture 1: Introducing The Graph

Lecture 2: Types Of Graphs

Lecture 3: The Directed And Undirected Graph

Lecture 4: Representing A Graph In Code

Lecture 5: Graph Using An Adjacency Matrix

Lecture 6: Graph Using An Adjacency List And Adjacency Set

Lecture 7: Comparison Of Graph Representations

Lecture 8: Graph Traversal – Depth First And Breadth First