Data Structures And Algorithm Analysis In C
In this second edition of his successful book, experienced teacher and author Mark Allen Weiss continues to refine and enhance his innovative approach to algorithms and data structures. Written for the advanced data structures course, this text highlights theoretical topics like abstract data types and the efficiency of algorithms, as well as performance and running time. Before covering algorithms and data structures, the author provides a brief introduction to C++ for programmers unfamiliar with the language. All of the source code will be available over the Internet. Dr. Weiss also distinguishes the book with his clear, friendly writing style, logical organization of topics, and extensive use of figures and examples that show the successive stages of an algorithm.
Data Structures and Algorithm Analysis in C
This book describes data structures, methods of organizing large amounts of data, and algorithm analysis, the estimation of the running time of algorithms. As computers become faster and faster, the need for programs that can handle large amounts of input becomes more acute. Paradoxically, this requires more careful attention to efficiency, since inefficiencies in programs become most obvious when input sizes are large. By analyzing an algorithm before it is actually coded, students can decide if a particular solution will be feasible. For example, in this text students look at specific problems and see how careful implementations can reduce the time constraint for large amounts of data from 16 years to less than a second. Therefore, no algorithm or data structure is presented without an explanation of its running time. In some cases, minute details that affect the running time of the implementation are explored.
Once a solution method is determined, a program must still be written. As computers have become more powerful, the problems they must solve have become larger and more complex, requiring development of more intricate programs. The goal of this text is to teach students good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amount of efficiency.
This book is suitable for either an advanced data structures (CS7) course or a first-year graduate course in algorithm analysis. Students should have some knowledge of intermediate programming, including such topics as pointers and recursion, and some background in discrete math. Approach
I believe it is important for students to learn how to program for themselves, not how to copy programs from a book. On the other hand, it is virtually impossible to discuss realistic programming issues without including sample code. For this reason, the book usually provides about one-half to three-quarters of an implementation, and the student is encouraged to supply the rest. Chapter 12, which is new to this edition, discusses additional data structures with an emphasis on implementation details.
Chapter 2 deals with algorithm analysis. This chapter explains asymptotic analysis and its major weaknesses. Many examples are provided, including an in-depth explanation of logarithms running time. Simple recursive programs are analyzed by intuitively converting them into iterative programs. More complicated divide-and-conquer programs are introduced, but some of the analysis (solving recurrence relations) is implicitly delayed until Chapter 7, where it is performed in detail.
Chapter 3 covers lists, stacks, and queues. The emphasis here is on coding these data structures using ADTs, fast implementation of these data structures, and an exposition of some of their uses. There are almost no programs (just routines), but the exercises contain plenty of ideas for programming assignments.
Chapter 7 covers sorting. It is very specific with respect to coding details and analysis. All the important general-purpose sorting algorithms are covered and compared. Four algorithms are analyzed in detail: insertion sort, Shellsort, heapsort, and quicksort. The analysis of the average-case running time of heapsort is new to this edition. External sorting is covered at the end of the chapter.
Chapter 9 covers graph algorithms. Algorithms on graphs are interesting, not only because they frequently occur in practice but also because their running time is so heavily dependent on the proper use of data structures. Virtually all of the standard algorithms are presented along with appropriate data structures, pseudocode, and analysis of running time. To place these problems in a proper context, a short discussion on complexity theory (including NP-completeness and undecidability) is provided.
Chapters 1-9 provide enough material for most one-semester data structures courses. If time permits, then Chapter 10 can be covered. A graduate course on algorithm analysis could cover Chapters 7-11. The advanced data structures analyzed in Chapter 11 can easily be referred to in the earlier chapters. The discussion of NP-completeness in Chapter 9 is far too brief to be used in such a course. Garey and Johnson's book on NP-completeness can be used to augment this text.
In this second edition of his best-selling book, Data Structures and Algorithm Analysis in C, Mark Allen Weiss, continues to refine and enhance his innovative approach to algorithms and data structures. Using a C implementation, he highlights conceptual topics, focusing on ADTs and the analysis of algorithms for efficiency as well as performance and running time. Dr. Weiss also distinguishes Data Structures and Algorithm Analysis in C with the extensive use of figures and examples showing the successive stages of an algorithm, his engaging writing style, and a logical organization of topics.
Presents current topics and newer data structures such as Fibonacci heaps, skew heaps, binomial queues, skip lists, and splay trees Contains a chapter on amortized analysis that examines the advanced data structures presented earlier in the book Provides a new chapter on advanced data structures and their implementation covering red black trees, top down splay trees, treaps, k-d trees, pairing heaps, and more Incorporates new results on the average case analysis of heapsort Offers source code from example programs via anonymous FTP 0201498405B04062001 From inside the book if (window['_OC_autoDir']) _OC_autoDir('search_form_input'); What people are saying - Write a reviewUser ratings5 stars44 stars13 stars02 stars11 star0Reviews aren't verified, but Google checks for and removes fake content when it's identifiedUser Review - Flag as inappropriateThis is the best book for learning algorithm.
The course covers data structures and associated algorithms. Relationships among data structures, their utility in various situations, and factors affecting their performance in algorithms will be considered. You will learn to analyze the demands of algorithms, how to choose appropriate data structures, and how to integrate data structures into algorithms.
Data Structures and Algorithm Analysis by Clifford Shaffer, Prentice-Hall, 1996. This book has good coverage of data structures and algorithm analysis in C++. It has excellent descriptions of a number of data structures.
Data Structures and Algorithms by Alfred Aho, John Hopcroft, and Jeffrey Ullman, Addison-Wesley, 1983. This is one of the all-time classics, written in Pascal.
Fundamentals of Data Structures in C++ by Ellis Horowitz, Sartaj Sahni, and Dinesh Mehta, 2006. Update of another classic.
PrerequisitesWe will assume that you have mastered the material from CMSC 201,CMSC 202, and CMSC 203.We will not review material that has been covered in the prerequisitecourses. We assume prior experience with C++ (CMSC 202). We do cover a few of the concepts from CMSC 202, but from a deeperpoint-of-view. If you are not familiar with C++, please seek help fromTA office hours.
In design and analysis of algorithms, usually the second method is used to describe an algorithm. It makes it easy for the analyst to analyze the algorithm ignoring all unwanted definitions. He can observe what operations are being used and how the process is flowing.
We shall learn about a priori algorithm analysis. Algorithm analysis deals with the execution or running time of various operations involved. The running time of an operation can be defined as the number of computer instructions executed per operation.
A data structure is a named location that can be used to store and organize data. And, an algorithm is a collection of steps to solve a particular problem. Learning data structures and algorithms allow us to write efficient and optimized computer programs.
This book provides a thorough and comprehensive treatment of fundamental data structures and the principles of algorithm analysis. Focuses on the principles required to select or design the data structure that will best solve the problem.
Cliff Shaffer is Professor of Computer Science at Virginia Tech, where he has been since 1987. He received his PhD from University of Maryland in 1986. Over his career, Dr. Shaffer's research efforts have spanned three major themes: Data structures and algorithms for spatial applications, integrated problem-solving environments for engineering and science applications (most notably for systems biology), and simulation and visualization for education (including Computer Science, Statistics, and Geography). 041b061a72