数据结构与算法分析--Java 语言描述（英文影印版·第2版）[按需印刷]

　　本书是国外数据结构与算法分析方面的标准教材，使用最卓越的java编程语言作为实现工具讨论了数据结构(组织大量数据的方法)和算法分析(对算法运行时间的估计)。.
　　 随着计算机速度的不断增加和功能的日益强大，人们对有效编程和算法分析的要求也在增长。本书把算法分析与最有效率的java程序的开发有机地结合起来，深入分析每种算法，内容全面、缜密严格，并细致讲解精心构造程序的方法。...
　　 第2版的特色如下：
　　 ·全面阐述新的java 5,0编程语言和java collections库。.
　　 ·改进内部设计，用图和实例阐述算法的实施步骤。
　　 ·第3章对表、栈和队列的讨论进行了全面修订。..
　　 ·用一章专门讨论摊还分析和一些高级数据结构的实现。
　　 ·每章末尾的大量练习按照难易程度编排，以增强对关键概念的理解。...

chapter 1 introduction.
1.1 what's the book about?
1.2 mathematics review
1.3 a brief introduction to recursion
1.4 implementing generic components pre java 5
1.5 implementing generic components using java 5 generics
1.6 function objects
chapter 2 algorithm analysis
2.1 mathematical background
2.2 model
2.3 what to analyze
2.4 running time calculations
summary
exercises
references
chapter 3 lists, stacks, and queues
3.1 abstract data types (adts)
3.2 the list adt
3.3 lists in the java collections apl
3.4 implementation of arraylist

　　Purpose/Goals
　　This new Java edition describes data structures, methods of organ/zing 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 intermedi.ate programming, including such topics as object-based programming and recursion, and some background in discrete math.
　　Approach
　　Although the material in this text is largely language independent, programming requires the use of a specific language. As the title implies, we have chosen Java for this book.
　　Java is a relatively new language that is often examined in comparison with C++. Java offers many benefits, and programmers often view Java as a safer, more portable, and easier-to-use language than C++. As such, it makes a fine core language for discussing and implementing fundamental data structures. Other important parts of Java, such as threads and its GUI, although important, are not needed in this text and thus are not discussed.
　　Complete versions of the data structures, in both Java and C++, are available on the Intemet. We use similar coding conventions to make the parallels between the two languages more evident.
　　The second edition incorporates numerous bug fixes, and many parts of the book haveundergone revision to increase clarity of presentation. In addition:
　　·Throughout the text, the code has been updated as appropriate to use modern features from Java 5.0.
　　·Chapter 3 has been significantly revised and contains a discussion of the use of the standard ArrayList and LinkedList classes (and their iterators) as well as an implementation of the standard ArrayLi st and Li nkedLi st classes.
　　·Chapter 4 has been revised to include a discussion of the TreeSet and TreeMap classes, along with an extensive example illustrating their use in the design of efficient algorithms. Chapter 9 also includes an example that makes use of the standard TreeMap to implement a shortest path algorithm.
　　·Chapter 7 contains a discussion of the standard sort algorithms, including anillustration of the techniques involved in implementing the overloaded standard sort algorithms.
　　Overview
　　Chapter i contains review materiat on discrete math and recursion. I believe the only way to be comfortable with recursion is to see good uses over and over. Therefore, recursion is prevalent in this text, with examples in every chapter except Chapter 5. Chapter I also presents material that serves as a review of. inheritance in Java. Included is a discussion of Java 5 generics.
　　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 logarithmic 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. This chapter has been significantly revised from prior editions. It now includes a discussion of the Collections APl ArrayList and Linked L i st classes, and it provides implementations of a significant subset of the collections APl ArrayLi st and Li nkedLi st classes.
　　Chapter 4 covers trees, with an emphasis on search trees, including external search trees (B-trees). The UNIX file system and expression trees are used as examples. AVL trees and splay trees are introduced. More careful treatment of search tree implementation details is found in Chapter 12. Additional coverage of trees, such as file compression and game trees, is deferred until Chapter 10. Data structures for an external medium are considered as the final topic in several chapters. New to this edition is a discussion of the Collections APl TreeSet and TreeMap classes, including a significant example that illustrates the use of three separate maps to efficiently solve a problem. ..
　　Chapter 5 is a relatively short chapter concerning hash tables. Some analysis is performed, and extendible hashing is covered at the end of the chapter.
　　Chapter 6 is about priority queues. Binary heaps are covered, and there is additional material on some of the theoretically interesting implementations of priority queues, The Fibonacci heap is discussed in Chapter 11, and the pairing heap is discussed in Chapter 12.