Learn basics of algorithms in short time
2.8 (67 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.
1,427 students enrolled
Wishlisted Wishlist

Please confirm that you want to add Learn basics of algorithms in short time to your Wishlist.

Add to Wishlist

Learn basics of algorithms in short time

This course helps you to build a strong foundation in Algorithms starting from basics
2.8 (67 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.
1,427 students enrolled
Created by Sri ., Ramya T
Last updated 10/2016
English
Curiosity Sale
Current price: $10 Original price: $20 Discount: 50% off
30-Day Money-Back Guarantee
Includes:
  • 2.5 hours on-demand video
  • 1 Article
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
What Will I Learn?
  • Master the basics of algorithms.
  • Understand situations where to apply the algorithm concepts.
  • Solve any problem using step by step approach with an algorithm
  • Learn advanced algorithms concepts easily using this course as a foundation.
View Curriculum
Requirements
  • Nothing specific is required for taking this course. It helps if the students have mathematical knowledge.
Description

Hello! Welcome to our course on Introduction to Algorithms. This course is basically designed to serve as an engaging content for an algorithmic course focusing on learning essentials of algorithms which will help to build a strong foundation for you to proceed further with implementing the algorithms and solving problems using programming. Our course serves as the first step in your quest for learning algorithm concepts.

In this course, you will learn all the basic algorithms and the data structures, required while implementing these algorithms.You will also learn how to calculate time complexities and how to approach any problem by applying a step by step algorithm. Some advanced and complex algorithms are also explained with possible simple ways. Though, it is not mandatory to have any expert knowledge of programming in order to learn these algorithms, yet some basic knowledge of mathematics might be a plus to understand them quickly. What is required most is some hard work and some dedication. If you have both; No one can stop you from being a very good programmer. 

 Any kinds of doubts or questions that you may have while doing the course, feel free to post it in the course discussions. The instructors will answer your questions and give you clear explanations as soon as possible. We will keep adding new lectures to this course. Keep checking out regularly

Begin your preparation and take the first step enhance your algorithm skills right away! :)

Who is the target audience?
  • Anyone interested in learning algorithms
  • Those who want to improve problem solving skills using algorithms.
Students Who Viewed This Course Also Viewed
Curriculum For This Course
21 Lectures
02:41:36
+
Introduction
1 Lecture 00:30

This course is basically designed to serve as an engaging content for an algorithmic course focusing on learning essentials of algorithms which will help to build a strong foundation for you to proceed further with implementing the algorithms and solving problems using programming. Our course serves as the first step in your quest for learning algorithm concepts.

In this course, you will learn all the basic algorithms and the data structures, required while implementing these algorithms.You will also learn how to calculate time complexities and how to approach any problem by applying a step by step algorithm. Some advanced and complex algorithms are also explained with possible simple ways. Though, it is not mandatory to have any expert knowledge of programming in order to learn these algorithms, yet some basic knowledge of mathematics might be a plus to understand them quickly. What is required most is some hard work and some dedication. If you have both; No one can stop you from being a very good programmer. 

Preview 00:30
+
Algorithms Basics
2 Lectures 18:44

An algorithm is any well-defined computational procedure that takes some value, or set of values, as input and produces some value, or set of values, as output. An algorithm is thus a sequence of computational steps that transform the input into the output. We can also view an algorithm as a tool for solving a well-specified computational problem. The statement of the problem specifies in general terms the desired input/output relationship. The algorithm describes a specific computational procedure for achieving that input/output relationship.

  A data structure is a way to store and organize data in order to facilitate access and modifications.Data structures are the heart of any sophisticated program. Selecting the right data structure can make an enormous difference in the complexity of the resulting implementation. Pick the right data representation, and your task will be easy to program. Pick the wrong representation, and you may spend enormous amounts of time and code covering up for your lousy initial decision. Data Structures are used to efficiently work with the data being used in our program.

 StackQueueTree etc. are few examples of the data structures having different capabilities and consequently being used for different applications in programming. You can learn more about them in the Data Structures section.

Algorithms and Data Structures are no way related to a particular language in specific. But yes, a language may provide some inbuilt tools or APIs which support any data structure type. But it never means that you can not develop the same APIs in any other language. You may choose any programming language to learn the algorithms and programming.

Preview 03:44

Analyzing an algorithm has come to mean predicting the resources that the algorithm requires. Occasionally, resources such as memory, communication bandwidth, or computer hardware are of primary concern, but most often it is computational time that we want to measure. Generally, by analyzing several candidate algorithms for a problem, a most efficient one can be easily identified. Such analysis may indicate more than one viable candidate, but several inferior algorithms are usually discarded in the process.


Analysis of Algorithms
15:00
+
Useful Algorithm Techniques
2 Lectures 17:50

Backtracking is a refinement of the brute force approach, which systematically searches for a solution to a problem among all available options. It does so by assuming that the solutions are represented by vectors (v1,v2, ..., vm) of values and by traversing, in a depth first manner, the domains of the vectors until the solutions are found.

  When invoked, the algorithm starts with an empty vector. At each stage it extends the partial vector with a new value. Upon reaching a partial vector (v1,v2, ..., vi) which can’t represent a partial solution, the algorithm backtracks by removing the trailing value from the vector, and then proceeds by trying to extend the vector with alternative values.

Examples are Traveling Salesman, N Queens Problem, Convex Hull.


Backtracking
10:02

 This is the most basic problem solving technique. Utilizing the fact that computer is actually very fast.
Complete search exploits the brute force, straight-forward, try-them-all method of finding the answer. This method should almost always be the first algorithm/solution you may consider. If this works within time and space constraints, then do it: it's easy to code and usually easy to debug. This means you'll have more time to work on all the hard problems, where brute force doesn't work quickly enough.

Preview 07:48
+
Data Structures - foundations for building algorithms
11 Lectures 01:37:41

The binary heap data structure is fine for the simple operations of inserting, deleting and extracting elements, but other operations aren't so well supported. One such operation is the Union operation, which joins two heaps together. If the heaps are binary heaps then this requires building up a new heap from scratch, using the elements of the old heaps, which is expensive for large heaps. This chapter presents the data structure known as a binomial heap, which supports Union operations more efficiently. Again, binomial heaps can be minimum heaps or maximum heaps, and in this case, the focus is only on minimum heaps.

Binomial Heap
14:59

B-trees are balanced search trees designed to work well on magnetic disks or other direct-access secondary storage devices. 
B-tree nodes may have many children, from a handful to thousands. That is called the ″branching factor″ of a B-tree. 
Every n-node B-tree has height O(lg n), therefore, B-tree can be used to implement many dynamic-set operations in time O(lg n).
B-trees generalize binary search trees in a natural manner. 
    • If a B-tree node x contains n[x] keys, then x has n[x]+1 children 
  • The keys in node x are used as dividing points separating the range of keys handled by x into n[x]+1 subranges, each handled by one child of x. 
    • When searching for a key in a B-tree, we make an (n[x]+1) way decision based on comparisons with the n[x] keys stored at node x. 

B-Tree
09:47

A linked list is a data structure in which the objects are arranged in a linear order. Unlike an array, though, in which the linear order is determined by the array indices, the order in a linked list is determined by a pointer in each object. Linked lists provide a simple, flexible representation for dynamic sets, supporting (though not necessarily efficiently) all the operations listed below.

  • SEARCH(L, k)
  • INSERT(L, x)
  • DELETE(L, x)
  • SUCCESSOR(L, x)
  • PREDECESSOR(L,x)
  • MINIMUM(L)
  • MAXIMUM(L)
List
09:59

Dictionary
06:15

Hash Tables
14:19

Maps
04:23

Tries
05:04

A queue is a data structure where we add elements at the back and remove elements from the front. In that way a queue is like “waiting in line”: the first one to be added to the queue will be the first one to be removed from the queue. This is also called a FIFO (First In First Out) data structure.

Queues are common in many applications. For example, when we read a book from a file, it would be natural to store the the words in a queue so that when we are finished reading the file the words are in the order they appear in the book. Another common example are buffers for network communication that temporarily store packets of data arriving on a network port. Generally speaking, we want to process them in the order that they arrive.

 The abstract operations on a queue are : 
   1. bool queue_empty(queue Q) - check if queue is empty
   2. queue queue_new() - create new empty queue
   3. void enqueue(queue Q, string s) - add item at back 
   4. string dequeue(queue Q) - remove item from front 
We can write out this interface without committing to an implementation of queues. After the type definition we know only that a queue will be implemented as a pointer to a struct queue.

Queue
03:21

Stacks are the containers where items are retrieved according to the order of insertion, independent of content. Stack is a linear data structure which can store any abstract data type and maintains Last-In First-Out (LIFO) order.Which means the element inserted in the very last will be retrieved very first.

 Stacks naturally model piles of objects, such as dinner plates. After a new plate is washed, it is pushed on the top of the stack. When someone is hungry, a clean plate is popped off the top. A stack is an appropriate data structure for this task since the plates don’t care which one is used next. Thus one important application of stacks is whenever order doesn’t matter, because stacks are particularly simple containers to implement. 
The abstract operations on a stack are :

   1. Push(S,x) - Insert item x at the top of stack S
   2. Pop(S) - Remove the top item from the stack S
   3. Top(S) -Return the top element of the stack S 
   4. Initialize(S) - Create an empty stack S
   5. Full(S) - Test whether stack S can accept more pushes 
   6. Empty(S) - Test whether stack S can accept more pops

Stack
07:11

Tree is a collection of nodes in which there is a root node and all other nodes are recursively children of this root node. What does it mean is that root node has some child nodes, those child nodes have their child nodes and so on.
We represent each node of a tree by an object. As with linked lists, we assume that each node contains a key field. The remaining fields of interest are pointers to other nodes, and they vary according to the type of tree.

Tree
19:16

Red-black tree is a type of self-balancing binary search tree. All red-black trees are based on implementing 2-3 or 2-3-4 trees within a binary tree, using red links to bind together internal nodes into 3-nodes or 4-nodes. The new code is based on combining three ideas:

            •       Use a recursive implementation. 
            •       Require that all 3-nodes lean left. 
            •       Perform rotations on the way up the tree (after the recursive calls)

  Not only do these ideas lead to simple code, but they also unify the algorithms: for example, the leftleaning versions of 2-3 trees and top-down 2-3-4 trees differ in the position of one line of code.

  All of the red-black tree algorithms that have been proposed are characterized by a worst-case search time bounded by a small constant multiple of lg N in a tree of N keys, and the behavior observed in practice is typically that same multiple faster than the worst-case bound, close the to optimal lg N nodes examined that would be observed in a perfectly balanced tree. This performance is also conjectured (but not yet proved) for trees built from random keys, for all the major variants of red-black trees. Specifically, in a left-leaning red-black 2-3 tree built from N random keys:

              •       A random successful search examines lg N – 0.5 nodes. 
            •       The average tree height is about 2 ln N . 
            •       The average size of left subtree exhibits log-oscillating behavior

  Left-leaning red-black trees (LLRB trees) have a number of attractive characteristics: 

            •       Experimental studies have not been able to distinguish these algorithms from optimal. 
            •       They can be implemented by adding just a few lines of code to standard BST algorithms. 
            •       Unlike hashing, they support ordered operations such as select, rank, and range search.

 

Red Black Tree
03:07
+
Graph Algorithms
2 Lectures 15:44

 Graphs are one of the unifying themes of computer science – an abstract representation which describes the organization of transportation systems, electrical circuits, human interactions, and telecommunication networks. That so many different structures can be modeled using a single formalism is a source of great power to the educated programmer.

  In this lecture, we focus on problems which require only an elementary knowledge of graph algorithms, specifically the appropriate use of graph data structures. Later on we will present graph traversal algorithms and problems relying on more advanced graph algorithms that find minimum spanning trees, shortest paths, and network flows. 

Introduction
07:40

There are several possible ways to represent graphs. We discuss four useful representations. We assume the graph G = (V,E) contains n vertices and m edges.

Graph Data Structures
08:04
+
Important Applications of Algorithm Techniques
2 Lectures 11:07

Divide-and-conquer is a top-down technique for designing algorithms that consists of dividing the problem into smaller subproblems hoping that the solutions of the subproblems are easier to find and then composing the partial solutions into the solution of the original problem.

    Little more formally, divide-and-conquer paradigm consists of following major phases: 

    • Breaking the problem into several sub-problems that are similar to the original problem but smaller in size, 
    • Solve the sub-problem recursively (successively and independently), and then 
    • Combine these solutions to subproblems to create a solution to the original problem.

Divide and Conquer
06:34

  Dynamic Programming is a programming technique that can dramatically reduces the runtime of some algorithms (but not all problem has DP characteristics) from exponential to polynomial. Many (and still increasing) real world problems only solvable within reasonable time using DP.

  To be able to use DP, the original problem must have: 
  1. Optimal sub-structure : Optimal solution to the problem contains within it optimal solutions to sub-problems 
  2. Overlapping sub-problems : We accidentally recalculate the same problem twice or more.

  There are 2 types of DP: We can either build up solutions of sub-problems from small to large (bottom up) or we can save results of solutions of sub-problems in a table (top down + memoization).

  Let's start with a sample of Dynamic Programming (DP) technique. We will examine the simplest form of overlapping sub-problems. Remember Fibonacci? A popular problem which creates a lot of redundancy if you use standard recursion fn = fn-1 + fn-2.

  Top-down Fibonacci DP solution will record the each Fibonacci calculation in a table so it won't have to re-compute the value again when you need it, a simple table-lookup is enough (memorization), whereas Bottom-up DP solution will build the solution from smaller numbers.

Dynamic Programming
04:33
+
Useful Information
1 Lecture 00:01
Important Algorithms
00:01
About the Instructor
Sri .
4.0 Average rating
433 Reviews
10,555 Students
5 Courses
Instructor at Udemy

Sri has 5 years of teaching experience where she helped several students to get rid of their fear and in developing an interest for the subject. 

Her aim is to provide students a good learning experience and help them to reach their goals in different subjects. She wants all her students to be highly successful in whatever dream they pursue and strives to work towards making this possible.

Ramya T
2.6 Average rating
189 Reviews
3,497 Students
2 Courses
Instructor at Udemy

Ms. Ramya Talluri has been teaching students from past 6 years and she is also mastered in computer science. Her goal is to help students to overcome their fears and helps them to achieve their goals. I believe practice makes everyone perfect. I hope my lectures will create encouragement for students to learn new concepts and be successful.

I strongly believe "no one and nothing will help you until you start helping yourself"