Udemy
    •  
    •  
    •  
    •  
    •  
    •  
    •  
    •  
Subscribe
Turn what you know into an opportunity and reach millions around the world.
Learn More
Your cart is empty.
Keep shopping
Byte-Sized-Chunks: Sorting and Searching Algorithms
Rating: 4.6 out of 5(26 ratings)
2,648 students

Byte-Sized-Chunks: Sorting and Searching Algorithms

A visual way to master basic algorithms for strong fundamentals!
Created byLoony Corn
Last updated 6/2016
English

What you'll 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

Course content

1 section • 14 lectures • 3h 25m total length

  • You, This Course, and Us!1:07
  • Performance and Complexity16:02

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

  • Big O Notation16:46
    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 More Examples19:13

    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!

  • Sorting Trade-Offs10:52

    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.

  • Selection Sort15:24

    The simplest and most naive sorting algorithm.

  • Bubble Sort14:42
    Closely allied with selection sort is bubble sort. Its an adaptive sort with the same time complexity as selection sort.
  • Insertion Sort14:32
    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.
  • Shell Sort14:24
    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.
  • Merge Sort19:23
    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.
  • Quick Sort15:30

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

  • Binary Search - search quickly through a sorted list11:09

    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!

  • Heap Sort Phase I - Heapify19:06
    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 II - The Actual Sort17:42
    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.

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

Who this course is for:

  • 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

Report abuse