Byte-Sized-Chunks: Sorting and Searching Algorithms
4.4 (6 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
128 students enrolled
Wishlisted Wishlist

Please confirm that you want to add Byte-Sized-Chunks: Sorting and Searching Algorithms to your Wishlist.

Add to Wishlist

Byte-Sized-Chunks: Sorting and Searching Algorithms

A visual way to master basic algorithms for strong fundamentals!
4.4 (6 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
128 students enrolled
Created by Loony Corn
Last updated 6/2016
English
Current price: $10 Original price: $20 Discount: 50% off
1 day left at this price!
30-Day Money-Back Guarantee
Includes:
  • 3.5 hours on-demand video
  • 22 Supplemental Resources
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
What Will I Learn?
  • Design and implement software that use sorting and searching algorithms
  • Understand the trade-offs, complexity and use-cases for different types of sort and search algorithms
  • Visualise - really vividly imagine - the common data structures, and the algorithms applied to them
View Curriculum
Requirements
  • Basic knowledge of programming is assumed, preferably in Java
Description

Note: This course is a subset of our 20+ hour course 'From 0 to 1: Data Structures & Algorithms' so please don't sign up for both:-)

This is an animated, visual and spatial way to learn data structures and algorithms

  • Our brains process different types of information differently - evolutionarily we are wired to absorb information best when it is visual and spatial i.e. when we can close our eyes and see it
  • More than most other concepts, Data Structures and Algorithms are best learnt visually. These are incredibly easy to learn visually, very hard to understand most other ways
  • This course has been put together by a team with tons of everyday experience in thinking about these concepts and using them at work at Google, Microsoft and Flipkart

What's Covered:

  • Big-O notation and complexity
  • Sorts: Quick, heap, merge, bubble, selection
  • Search: Binary searching a sorted list


Using discussion forums

Please use the discussion forums on this course to engage with other students and to help each other out. Unfortunately, much as we would like to, it is not possible for us at Loonycorn to respond to individual questions from students:-(

We're super small and self-funded with only 2-3 people developing technical video content. Our mission is to make high-quality courses available at super low prices.

The only way to keep our prices this low is to *NOT offer additional technical support over email or in-person*. The truth is, direct support is hugely expensive and just does not scale.

We understand that this is not ideal and that a lot of students might benefit from this additional support. Hiring resources for additional support would make our offering much more expensive, thus defeating our original purpose.

It is a hard trade-off.

Thank you for your patience and understanding!


Who is the target audience?
  • Nope! Please don't enroll for this class if you have already enrolled for our 15-hour course 'From 0 to 1: Data Structures and Algorithms'
  • Yep! Computer Science and Engineering grads who are looking to really visualise data structures, and internalise how they work
  • Yep! Experienced software engineers who are looking to refresh important fundamental concepts
Students Who Viewed This Course Also Viewed
Curriculum For This Course
Expand All 14 Lectures Collapse All 14 Lectures 03:25:52
+
Needle In A Haystack: Sorting and Searching!
14 Lectures 03:25:52

What is the performance of your code? How do you measure this? What is complexity and what is its relationship with performance?

Preview 16:02

The Big O notation is used to express complexity based on the size of the input specified for any algorithm. How is Big O expressed, how is it calculated and many examples to drive the concepts home!
Big O Notation
16:46

The Big O notation becomes much clearer when you practice find the complexity of some sample pieces of code. Let's see how many of these you get right!

Big O Notation More Examples
19:13

A sorting algorithm is not just defined by its complexity, there are a whole bunch of other characteristics which can be used to determine which sorting algorithm is the right one for a system. Let's understand what these characteristics are and what are the trade offs we might make.

Sorting Trade-Offs
10:52

The simplest and most naive sorting algorithm.

Selection Sort
15:24

Closely allied with selection sort is bubble sort. Its an adaptive sort with the same time complexity as selection sort.
Bubble Sort
14:42

Insertion sort is an improvement over both bubble sort and selection sort. Let's see how exactly it works and why it's preferred in many cases.
Insertion Sort
14:32

Shell sort builds on top of insertion sort, it improves the complexity of it's running time by partitioning the list in a clever way.
Shell Sort
14:24

This belongs to a class of algorithms which uses divide and conquer to break the problem set into smaller pieces. This also makes a time-space trade off to get a faster running time.
Merge Sort
19:23

Quick sort is the sort of choice for developers of programming libraries. Let's see what makes it so attractive.

Quick Sort
15:30

Binary search is a pretty nifty way to search through a sorted list in O(Log N) time. It's also an interview favorite so make sure you understand it well!

Binary Search - search quickly through a sorted list
11:09

Back to sorting. The Heap Sort uses a heap to transform an unsorted array into a sorted array. Phase I is converting the unsorted array into a heap.
Heap Sort Phase I - Heapify
19:06

Phase II actually outputs the final sorted array. It involves removing the elements from the heap and placing it in a sorted array. The cool thing is that all of this can be done in-place.
Heap Sort Phase II - The Actual Sort
17:42
About the Instructor
Loony Corn
4.3 Average rating
3,506 Reviews
27,685 Students
65 Courses
A 4-person team;ex-Google; Stanford, IIM Ahmedabad, IIT

Loonycorn is us, Janani Ravi, Vitthal Srinivasan, Swetha Kolalapudi and Navdeep Singh. Between the four of us, we have studied at Stanford, IIM Ahmedabad, the IITs and have spent years (decades, actually) working in tech, in the Bay Area, New York, Singapore and Bangalore.

Janani: 7 years at Google (New York, Singapore); Studied at Stanford; also worked at Flipkart and Microsoft

Vitthal: Also Google (Singapore) and studied at Stanford; Flipkart, Credit Suisse and INSEAD too

Swetha: Early Flipkart employee, IIM Ahmedabad and IIT Madras alum

Navdeep: longtime Flipkart employee too, and IIT Guwahati alum

We think we might have hit upon a neat way of teaching complicated tech courses in a funny, practical, engaging way, which is why we are so excited to be here on Udemy!

We hope you will try our offerings, and think you'll like them :-)