An introductory guided tour to the field of data structures, algorithms, and complexity analysis. This course is loaded with a ton of practical examples, and focuses on intuition, rather than formulas and mathematical proofs.
The phrase "Get Great Performance for Free!" sounds like a quote from bad commercial, but when it comes to algorithms and data structures, that may actually be the case. This introductory course shows how the use of common data structures may simplify and even significantly impact performance of solutions to typical real-life everyday programming problems. The course gently introduces the viewer for "complexity analysis" which makes it possible to spot a poorly (and a great) performing program, even without the need for executing it. Complexity analysis is an invaluable tool or "language" for discussing performance with colleagues - and it's not even difficult. After having covered the most common data structures, the course continues to describe some general strategies (algorithms) to efficiently solve more high-level problems. Like with data structures, it is shown how a careful choice of problem solving strategy can dramatically reduce computation time. The last part of the course shifts the focus a bit and shortly teases a few popular theoretical subjects and explains, at a purely intuitive level, what the complexity classes P, NP, and the famous problem, P = NP, is all about.
Rasmus is a software developer and architect, an entrepreneur and an idealist, with a background as PhD in the field of computer science, databases, and algorithms and with a long standing passion for teaching.
Looking Ahead to Some Very Hard Problems I'm Rasmus Resen Amossen, and this is the last module in the introductory course about data structures and algorithms. What we have seen so far has been relatively directly applicable in real world scenarios. In this module, I'll change the focus a bit and try to put some of the things learned into perspective. We will dive closer into three areas. In the clip about solving the 0/1 knapsack problem using dynamic programming, I shortly noted that there was a minor twist on the complexity we deduced for the algorithm. First, in the upcoming clip about measuring input size in a number of bits, I'll explain what that was all about. So far we have looked at a variety of problems and ways to solve them. There's actually a whole research field within theoretical computer signs about categorizing computational problems by the complexity. Some problems are easy and some may be simple to understand, but incredibly hard to solve. When considering this complexity categorization, something interesting happens. In the mysteriously named clip P vs NP, I'll shortly describe what this categorization is all about, and even give you a hint on how to win no less than $1, 000, 000. Last, we shall briefly see a number of strategies for dealing with hard problems in situations where it makes sense to trade accuracy or precision in the found solution with computation speed.