This is a graduate course on the design and analysis of algorithms, covering several advanced topics not studied in typical introductory courses on algorithms. It is especially designed for doctoral students interested in theoretical computer science.

This course is a first-year graduate course in algorithms. Emphasis is placed on fundamental algorithms and advanced methods of algorithmic design, analysis, and implementation. Techniques to be covered include amortization, randomization, fingerprinting, word-level parallelism, bit scaling, dynamic programming, network flow, linear programming, fixed-parameter algorithms, and approximation algorithms. Domains include string algorithms, network optimization, parallel algorithms, computational geometry, online algorithms, external memory, cache, and streaming algorithms, and data structures.

Data structures play a central role in modern computer science. You interact with data structures even more often than with algorithms (think Google, your mail server, and even your network routers). In addition, data structures are essential building blocks in obtaining efficient algorithms. This course covers major results and current directions of research in data structure.
Acknowledgments
Thanks to videographers Martin Demaine and Justin Zhang.

This textbook is an introductory coverage of algorithms and data structures with application to graphics and geometry.

Chapter 1 Introduction for Data Structures and Algorithms Courses
Chapter 2 Object Oriented Programming
Chapter 3 List Interface & Array based Lists
Chapter 4 Algorithm Analysis
Chapter 5 Introduction to Pointers in Java
Chapter 6 Stacks
Chapter 7 Recursion
Chapter 8 Sorting
Chapter 9 Queues
Chapter 10 Linked Lists
Chapter 11 Binary Trees

This course covers concepts of computation used in analysis of engineering systems. It includes the following topics: data structures, relational database representations of engineering data, algorithms for the solution and optimization of engineering system designs (greedy, dynamic programming, branch and bound, graph algorithms, nonlinear optimization), and introduction to complexity analysis. Object-oriented, efficient implementations of algorithms are emphasized.

This is a foundation subject in modern software development techniques for engineering and information technology. The design and development of component-based software (using C# and .NET) is covered; data structures and algorithms for modeling, analysis, and visualization; basic problem-solving techniques; web services; and the management and maintenance of software. Includes a treatment of topics such as sorting and searching algorithms; and numerical simulation techniques. Foundation for in-depth exploration of image processing, computational geometry, finite element methods, network methods and e-business applications. This course is a core requirement for the Information Technology M. Eng. program.
This class was also offered in Course 13 (Department of Ocean Engineering) as 13.470J. In 2005, ocean engineering subjects became part of Course 2 (Department of Mechanical Engineering), and the 13.470J designation was dropped in lieu of 2.159J.

This course will provide a gentle introduction to programming using Python™ for highly motivated students with little or no prior experience in programming computers. The course will focus on planning and organizing programs, as well as the grammar of the Python programming language. Lectures will be interactive featuring in-class exercises with lots of support from the course staff.
This course is offered during the Independent Activities Period (IAP), which is a special 4-week term at MIT that runs from the first week of January until the end of the month.

Tell your story and show it with data, using free and easy-to-learn tools on the web. This introductory book teaches you how to design interactive charts and customized maps for your website, beginning with easy drag-and-drop tools, such as Google Sheets, Datawrapper, and Tableau Public. You’ll also gradually learn how to edit open-source code templates built with Chart.js, Highcharts, and Leaflet on GitHub.

Hands-On Data Visualization takes you step-by-step through tutorials, real-world examples, and online resources. This book is ideal for students, educators, community activists, non-profit organizations, small business owners, local governments, journalists, researchers, or anyone who wants to take data out of spreadsheets and turn it into lively interactive stories. No coding experience is required.

Learn more about this open-access web edition, based on the book manuscript we submitted to our publisher, O’Reilly Media, Inc., which we have permission to freely share under the terms of our contract. Readers may purchase the publisher’s improved and copyedited version, in print or ebook editions. Figure numbering and other details vary between this open-access web edition and the publisher’s editions.

This course is intended to assist undergraduates with learning the basics of programming in general and programming MATLAB® in particular.

This course provides an introduction to mathematical modeling of computational problems. It covers the common algorithms, algorithmic paradigms, and data structures used to solve these problems. The course emphasizes the relationship between algorithms and programming, and introduces basic performance measures and analysis techniques for these problems.

This course presents the fundamentals of object-oriented software design and development, computational methods and sensing for engineering, and scientific and managerial applications. It cover topics, including design of classes, inheritance, graphical user interfaces, numerical methods, streams, threads, sensors, and data structures. Students use Java programming language to complete weekly software assignments.
How is 1.00 different from other intro programming courses offered at MIT?
1.00 is a first course in programming. It assumes no prior experience, and it focuses on the use of computation to solve problems in engineering, science and management. The audience for 1.00 is non-computer science majors. 1.00 does not focus on writing compilers or parsers or computing tools where the computer is the system; it focuses on engineering problems where the computer is part of the system, or is used to model a physical or logical system.
1.00 teaches the Java programming language, and it focuses on the design and development of object-oriented software for technical problems. 1.00 is taught in an active learning style. Lecture segments alternating with laboratory exercises are used in every class to allow students to put concepts into practice immediately; this teaching style generates questions and feedback, and allows the teaching staff and students to interact when concepts are first introduced to ensure that core ideas are understood. Like many MIT classes, 1.00 has weekly assignments, which are programs based on actual engineering, science or management applications. The weekly assignments build on the class material from the previous week, and require students to put the concepts taught in the small in-class labs into a larger program that uses multiple elements of Java together.

This course focuses on introducing the language, libraries, tools and concepts of Javaᵀᴹ. The course is specifically targeted at students who intend to take 6.170 in the following term and feel they would struggle because they lack the necessary background. Topics include: Object-oriented programming, primitives, arrays, objects, inheritance, interfaces, polymorphism, hashing, data structures, collections, nested classes, floating point precision, defensive programming, and depth-first search algorithm.

In this activity, students explore the importance of adequate sampling strategies when conducting a scientific investigation. They are tasked with determining the average temperature of the Earth, using data sets easily found on the Internet, and determine the kind and size of sample necessary to calculate a representative average. The resource includes a student data sheet and an authentic assessment for the module, where students discuss the establishment of a habitation site on Mars. This is Activity C in module 2, titled "Modeling Hot and Cold Planets," of the resource, Earth Climate Course: What Determines a Planet's Climate? The course aims to help students to develop an understanding of our environment as a system of human and natural processes that result in changes that occur over various space and time scales.

15.082J/6.855J/ESD.78J is a graduate subject in the theory and practice of network flows and its extensions. Network flow problems form a subclass of linear programming problems with applications to transportation, logistics, manufacturing, computer science, project management, and finance, as well as a number of other domains. This subject will survey some of the applications of network flows and focus on key special cases of network flow problems including the following: the shortest path problem, the maximum flow problem, the minimum cost flow problem, and the multi-commodity flow problem. We will also consider other extensions of network flow problems.

Complément d’exercices théoriques et pratiques en complement du livre Algorithms, 4th Edition de Robert Sedgewick and Kevin Wayne pour une classe inversée.

This course examines how randomization can be used to make algorithms simpler and more efficient via random sampling, random selection of witnesses, symmetry breaking, and Markov chains. Topics covered include: randomized computation; data structures (hash tables, skip lists); graph algorithms (minimum spanning trees, shortest paths, minimum cuts); geometric algorithms (convex hulls, linear programming in fixed or arbitrary dimension); approximate counting; parallel algorithms; online algorithms; derandomization techniques; and tools for probabilistic analysis of algorithms.

This book is about complexity science, data structures and algorithms, intermediate programming in Python, and the philosophy of science. This book focuses on discrete models, which include graphs, cellular automata, and agent-based models. They are often characterized by structure, rules and transitions rather than by equations. They tend to be more abstract than continuous models; in some cases there is no direct correspondence between the model and a physical system.

Data structures and algorithms are among the most important inventions of the last 50 years, and they are fundamental tools software engineers need to know. But in my opinion, most of the books on these topics are too theoretical, too big, and too bottom-up:

*Too theoretical: Mathematical analysis of algorithms is based on simplifying assumptions that limit its usefulness in practice. Many presentations of this topic gloss over the simplifications and focus on the math. In this book I present the most practical subset of this material and eliminate the rest.

*Too big: Most books on these topics are at least 500 pages, and some are more than 1000. By focusing on the topics I think are most useful for software engineers, I kept this book under 250 pages.

*Too bottom-up: Many data structures books focus on how data structures work (the implementations), with less about how to use them (the interfaces). In this book, I go “top down”, starting with the interfaces. Readers learn to use the structures in the Java Collections Framework before getting into the details of how they work.

Finally, many present this material out of context and without motivation: it’s just one damn data structure after another!

I try to alleviate the boredom by organizing the topics around an application—web search—that uses data structures extensively, and is an interesting and important topic in its own right.

This application also motivates some topics that are not usually covered in an introductory data structures class, including persistent data structures, with Redis, and streaming algorithms.

I have made difficult decisions about what to leave out, but I have made some compromises. I include a few topics that most readers will never use, but that they might be expected to know, possibly in a technical interview. For these topics, I present both the conventional wisdom as well as my reasons to be skeptical.

This book also presents basic aspects of software engineering practice, including version control and unit testing. Each chapter ends with an exercise that allows readers to apply what they have learned. Each exercise includes automated tests that check the solution. And for most exercises, I present my solution at the beginning of the next chapter.

This book is intended for college students in computer science and related fields, as well as professional software engineers, people training in software engineering, and people preparing for technical interviews.

I assume that the reader knows Java at an intermediate level, but I explain some Java features along the way, and provide pointers to supplementary material.

People who have read Think Java or Head First Java are prepared for this book.