Kyle Loudon - Mastering Algorithms with C
Here you can read online Kyle Loudon - Mastering Algorithms with C full text of the book (entire story) in english for free. Download pdf and epub, get meaning, cover and reviews about this ebook. year: 1999, publisher: OReilly Media, genre: Computer. Description of the work, (preface) as well as reviews are available. Best literature library LitArk.com created for fans of good reading and offers a wide selection of genres:
Romance novel
Science fiction
Adventure
Detective
Science
History
Home and family
Prose
Art
Politics
Computer
Non-fiction
Religion
Business
Children
Humor
Choose a favorite category and find really read worthwhile books. Enjoy immersion in the world of imagination, feel the emotions of the characters or learn something new for yourself, make an fascinating discovery.
- Book:Mastering Algorithms with C
- Author:
- Publisher:OReilly Media
- Genre:
- Year:1999
- Rating:4 / 5
- Favourites:Add to favourites
- Your mark:
Mastering Algorithms with C: summary, description and annotation
We offer to read an annotation, description, summary or preface (depends on what the author of the book "Mastering Algorithms with C" wrote himself). If you haven't found the necessary information about the book — write in the comments, we will try to find it.
Kyle Loudon: author's other books
Who wrote Mastering Algorithms with C? Find out the surname, the name of the author of the book and a list of all author's works by series.
Mastering Algorithms with C — read online for free the complete book (whole text) full work
Below is the text of the book, divided by pages. System saving the place of the last page read, allows you to conveniently read the book "Mastering Algorithms with C" online for free, without having to search again every time where you left off. Put a bookmark, and you can go to the page where you finished reading at any time.
Font size:
Interval:
Bookmark:
Copyright 2009 O'Reilly Media, Inc.
Supplemental files and examples for this book can be found at http://examples.oreilly.com/9781565924536/. Please use a standard desktop web browser to access these files, as they may not be accessible from all ereader devices.
All code files or examples referenced in the book will be available online. For physical books that ship with an accompanying disc, whenever possible, weve posted all CD/DVD content. Note that while we provide as much of the media content as we are able via free download, we are sometimes limited by licensing restrictions. Please direct any questions or concerns to .
When I first thought about writing this book, I immediately thought of O'Reilly & Associates to publish it. They were the first publisher I contacted, and the one I most wanted to work with because of their tradition of books covering "just the facts." This approach is not what one normally thinks of in connection with books on data structures and algorithms. When one studies data structures and algorithms, normally there is a fair amount of time spent on proving their correctness rigorously. Consequently, many books on this subject have an academic feel about them, and real details such as implementation and application are left to be resolved elsewhere. This book covers how and why certain data structures and algorithms work, real applications that use them (including many examples), and their implementation. Mathematical rigor appears only to the extent necessary in explanations.
Naturally, I was very happy that O'Reilly & Associates saw value in a book that covered this aspect of the subject. This preface contains some of the reasons I think you will find this book valuable as well. It also covers certain aspects of the code in the book, defines a few conventions, and gratefully acknowledges the people who played a part in the book's creation.
This book is divided into three parts. The first part consists of introductory material that is useful when working in the rest of the book. The second part presents a number of data structures considered fundamental in the field of computer science. The third part presents an assortment of algorithms for solving common problems. Each of these parts is described in more detail in the following sections, including a summary of the chapters each part contains.
presents the analysis of algorithms. The techniques in this chapter are used to analyze algorithms throughout the book.
presents graphs and two fundamental algorithms from which many graph algorithms are derived: breadth-first and depth-first search.
presents geometric algorithms, including methods for testing whether line segments intersect, computing convex hulls, and computing arc lengths on spherical surfaces.
There are a number of special features that I believe together make this book a unique approach to covering the subject of data structures and algorithms:
Every chapter (excluding those in the first part of the book) follows a consistent format. This format allows most of the book to be read as a textbook or a reference, whichever is needed at the moment.
Clearly identified topics and applicationsEach chapter (except ) begins with a brief introduction, followed by a list of clearly identified topics and their relevance to real applications.
Analyses of every operation, algorithm, and exampleAn analysis is provided for every operation of abstract datatypes, every algorithm in the algorithms chapters, and every example throughout the book. Each analysis uses the techniques presented in .
Real examples, not just trivial exercisesAll examples are from real applications, not just trivial exercises. Examples like these are exciting and teach more than just the topic being demonstrated.
Real implementations using real codeAll implementations are written in C, not pseudocode. The benefit of this is that when implementing many data structures and algorithms, there are considerable details pseudocode does not address.
Questions and answers for further thoughtAt the end of each chapter (except ), there is a series of questions along with their answers. These emphasize important ideas from the chapter and touch on additional topics.
Lists of related topics for further explorationAt the end of each chapter (except ), there is a list of related topics for further exploration. Each topic is presented with a brief description.
Numerous cross references and call-outsCross references and call-outs mark topics mentioned in one place that are introduced elsewhere. Thus, it is easy to locate additional information.
Insightful organization and application of topicsMany of the data structures or algorithms in one chapter use data structures and algorithms presented elsewhere in the book. Thus, they serve as examples of how to use other data structures and algorithms themselves. All dependencies are carefully marked with a cross reference or call-out.
Coverage of fundamental topics, plus moreThis book covers the fundamental data structures and algorithms of computer science. It also covers several topics not normally addressed in books on the subject. These include numerical methods, data compression (in more detail), data encryption, and geometric algorithms.
All implementations in this book are in C. C was chosen because it is still the most general-purpose language in use today. It is also one of the best languages in which to explore the details of data structures and algorithms while still working at a fairly high level. It may be helpful to note a few things about the code in this book.
There is also a focus on efficiency, but the primary purpose of all code is to teach the topic it addresses in a clear manner.
All code has been fully tested on four platformsThe platforms used for testing were HP-UX 10.20, SunOs 5.6, Red Hat Linux 5.1, and DOS/Windows NT/95/98. See the readme file on the accompanying website http://examples.oreilly.com/masteralgoc/) for additional information.
Headers document all public interfacesEvery implementation includes a header that documents the public interface. Most headers are shown in this book. However, headers that contain only prototypes are not. (For instance, includes sort.h , but this header is not shown because it contains only prototypes to various sorting functions.)
Static functions are used for private functionsStatic functions have file scope, so this fact is used to keep private functions private. Functions specific to a data structure or algorithm's implementation are thus kept out of its public interface.
Naming conventions are applied throughout the codeDefined constants appear entirely in uppercase. Datatypes and global variables begin with an uppercase character. Local variables begin with a lowercase character. Operations of abstract datatypes begin with the name of the type in lowercase, followed by an underscore, then the name of the operation in lowercase.
All code contains numerous commentsAll comments are designed to let developers follow the logic of the code without reading much of the code itself. This is useful when trying to make connections between the code and explanations in the text.
Font size:
Interval:
Bookmark:
Similar books «Mastering Algorithms with C»
Look at similar books to Mastering Algorithms with C. We have selected literature similar in name and meaning in the hope of providing readers with more options to find new, interesting, not yet read works.
Discussion, reviews of the book Mastering Algorithms with C and just readers' own opinions. Leave your comments, write what you think about the work, its meaning or the main characters. Specify what exactly you liked and what you didn't like, and why you think so.