A friendly introduction to the most useful algorithms written in simple, intuitive English, including useful algorithms such as: methods for manipulating common data structures, advanced data structures, network algorithms, and numerical algorithms. 

Essential Algorithms: A Practical Approach to Computer Algorithms Using Python and C#, 2nd Edition

Learn the best programming languages and platforms for website and web app development

Back End

Python

Essential Algorithms: A Practical Approach to Computer Algorithms Using Python ® and C#

Preface

Before you jump into the study of algorithms, you need a little background. To begin with, you need to know that, simply stated, an algorithm is a recipe for getting something done. It defines the steps for performing a task in a certain way.

Algorithm Basics

Numerical algorithms calculate numbers. They perform such tasks as randomizing values, breaking numbers into their prime factors, finding greatest common divisors, and computing geometric areas.

Numerical Algorithms

Linked lists are probably the simplest data structures you'll build. However, some of the concepts you use to build them are also used to build the most sophisticated data structures described in this book. To use a linked list, you need to understand cells and links in addition to methods of finding, inserting, and deleting cells. You use those same concepts to build complicated networks, trees, and balanced trees, which can be extremely confusing.

Linked Lists

Arrays are extremely common data structures. They are intuitive, easy to use, and supported well by most programming languages. In fact, arrays are so common and well understood that you may wonder whether there's much to say about them in an algorithms book. Most applications use arrays in a relatively straightforward manner, but special-purpose arrays can be useful in certain cases, so they deserve some attention here.

Arrays

Stacks and queues are relatively simple data structures that store objects in either first-in-first-out order or last-in-first-out order. They expand as needed to hold additional items, much like linked lists can, as described in Chapter 3, “Linked Lists.” In fact, you can use linked lists to implement stacks and queues.

Stacks and Queues

Sorting algorithms are usually covered in great detail in algorithms books for several reasons.

Sorting

The preceding chapter explained how you can sort data. Algorithms such as quicksort and heapsort let you sort large amounts of data quickly. Algorithms such as countingsort and bucketsort let you sort data almost as quickly as a program can examine it, but only under certain special circumstances.

Searching

The preceding chapter explained binary search, an algorithm for locating an item in a sorted list. The algorithm repeatedly examines a test item in the middle of the part of the list where the target item must be. It compares the test item to the target item and then recursively examines the left or right half of the region, depending on whether the test item is greater than or less than the target item.

Hash Tables

Recursion occurs when a method calls itself. The recursion can be direct (when the method calls itself) or indirect (when the method calls some other method that then calls the first method).

Recursion

This chapter explains trees, which are highly recursive data structures that you can use to store hierarchical data and model decision processes. For example, a tree can store a company organizational chart or the parts that make up a complex machine such as a car.

Trees

The previous chapter explained trees in general and some of the algorithms that use trees. Some algorithms, such as tree traversals, have run times that depend on the tree's total size. Other algorithms, such as one for inserting a node in a sorted tree, have run times that depend on the tree's height. If a sorted tree containing N nodes is relatively short and wide, inserting a new node takes steps. However, if the nodes are added to the tree in sorted order, the tree grows tall and thin, so adding a new node takes time, which is much longer.

Balanced Trees

Chapter 10 and Chapter 11 described tree algorithms in general and balanced trees in particular. They explained algorithms that you can use to build and maintain trees, but they didn't describe any algorithms that use trees to solve a particular problem.

Decision Trees

Chapters 10–12 explained trees. This chapter describes a related data structure: the network. Like a tree, a network contains nodes that are connected by links. Unlike the nodes in a tree, however, the nodes in a network don't necessarily have a hierarchical relationship. In particular, the links in a network may create cycles, so a path that follows the links could loop back to its starting position.

Basic Network Algorithms

Chapter 13 focused on network traversal algorithms, including algorithms that use breadth-first and depth-first traversals to find the shortest paths between nodes in the network. This chapter continues the discussion of network algorithms. The first algorithms, which perform topological sorting and cycle detection, are relatively simple. The algorithms described later in the chapter, such as graph coloring and maximal flow calculation, are a bit more challenging.

More Network Algorithms

String operations are common in many programs, so they have been studied extensively, and many programming libraries have good string tools. Because these operations are so important, the tools available to you probably use the best algorithms available, so you are unlikely to beat them with your own code.

String Algorithms

Cryptography is the study of methods for secure communication in the presence of adversaries who want to intercept information. Early cryptography, which was simply writing, worked because only a few people could read. Later forms of cryptography used special alphabets known only to the message sender and recipient. One of the earliest known instances of this form of cryptography used nonstandard hieroglyphics carved on monuments in Egypt circa 1900 BCE.

Cryptography

An algorithm's performance is always important when you try to solve a problem. An algorithm won't do you much good if it takes too long or requires too much memory or other resources to actually run on a computer.

Complexity Theory

In a paper published in 1965, Gordon E. Moore noticed that the number of transistors on integrated circuits roughly doubled every two years between the invention of the integrated circuit in 1958 and 1965. From that observation, he predicted that the trend would continue for at least another 10 years. This prediction, which is now known as Moore's law , has proven amazingly accurate for the last 50 years, but the end may be in sight.

Distributed Algorithms

It's perfectly reasonable for a job interview to include questions that require you to use your skills to solve a problem. Each of this book's chapters contains exercises that might make good interview questions—at least if the candidate is well-versed in algorithms. However, many of those questions would be quite difficult if you hadn't recently been reading about the relevant algorithms.

Interview Puzzles

This appendix summarizes the key concepts covered in each of the book's chapters.

APPENDIX A | Summary of Algorithmic Concepts

APPENDIX B | Solutions to Exercises

2-node — In a 2-3 tree, a node that has two children. 3-node — In a 2-3 tree, a node that has three children. 2-3 tree — A balanced tree structure where every internal node has either two children or three children. 

Glossary

A A2Z Interviews: puzzles (website), 604 accepting states, 497, 711 acyclic networks, 439–440 adaptive quadrature, 50–53, 711 adaptive techniques, 599, 609 adding items, 335–336, 339–341 nodes, 303–305 

Essential Algorithms: A Practical Approach to Computer Algorithms Using Python and C#, 2nd Edition

Details

Description

Creator

Rod Stephens

Content

Reviews

Frequently Asked Questions

Essential Algorithms: A Practical Approach to Computer Algorithms Using Python and C#, 2nd Edition