
Will give you an overview of the course
You must be strong in arithmetic, geometric and logarithmic series before continuing to other lectures.
What is algorithm and why we are analyzing algorithms?
Explore how space complexity measures memory needs, from zero for simple ABC to O(n) for summing an array, and how dynamic versus static memory affects the analysis.
Explore elementary operations and the computation time required for algorithms, learn how time complexity is measured, and analyze constant versus variable running times across machine architectures.
Analyze time complexity with two examples: a loop where i doubles until 2^i reaches n, yielding O(log n); and a j-driven accumulation where i grows as i+j, leading to O(sqrt(n)).
Explore best, average, and worst case time complexity with a linear search example. Identify bounds and show best case as O(1) and worst and average cases as O(n).
derive recurrence equations for recursive algorithms and solve them to reveal the factorial's running time, illustrating how T(n)=T(n-1)+1 yields the asymptotic complexity.
Explore the recursive approach to computing the nth fibonacci number, with base cases fib(1)=1 and fib(2)=1, and the recurrence fib(n)=fib(n-1)+fib(n-2) and its time recurrence T(n)=T(n-1)+T(n-2)+1.
Learn how to solve a recurrence equation using the iterative method in example 3, tracing base conditions and substitutions to reveal the recurrence pattern and squaring step.
Explore the benefits and limits of binary search on sorted data, showing fast log-time search but costly insertions and deletions, and motivate using a binary search tree for efficient updates.
Examine the disadvantages of binary search trees, showing how sorted insertions create degenerate trees with height n, causing search, insert, delete to degrade to O(n) time.
Explore self-balancing binary trees with a balance factor of -1, 0, or 1 and rotations to keep height low. Learn how insertion and deletion run in logarithmic time.
Explore AVL tree deletion through step-by-step examples, deleting leaves and nodes, updating balance factors, and applying rotations to restore balance after removals.
Explore insertion in red-black trees, learning how new nodes are colored red, how properties like black height and root color are preserved, and how rotations restore balance.
Explore red-black tree deletion, including locating the in-order successor or predecessor, replacing nodes, and maintaining red-black properties and black height through color adjustments.
Explain the b-tree, its order m, and its core properties: internal nodes have 2 to m children, leaves are on the same level, with minimum and maximum keys per node.
Learn b-tree deletion strategies to maintain tree properties, using deletions, merging nodes, moving keys up and down to preserve node order and balance.
Explore the union operation in disjoint sets, merging two sets and forming a new set of their elements, with notes on when the operation can run in constant time.
Explains depth-first search on a graph by initializing all vertices as white, recursively visiting unvisited neighbors, updating colors, and establishing the time complexity as O(V+E).
//As you know behind every efficient software there will be an efficient algorithm.
But how do you build an efficient algorithm?
You can choose any of the design techniques such as Divide and Conquer, Dynamic Programming, Greedy Approach, Back Tracking & Branch and Bound.
From the technique listed above which one is suitable for your program/problem?
Take this course then you will be able to choose the right one.
/* This course is for both students and professionals */