- Shopping Bag ( 0 items )
A unique, practical approach to working with collection classes in Java 2
Software developers new to Java will find the practical, software-engineering based approach taken by this book extremely refreshing. With an emphasis more on software design and less on theory, Java Collections explores in detail Java 2 collection classes, helping programmers choose the best collection classes for each application they work on. Watt and Brown explore abstract data types (ADTs) that turn up again and again in software design, using them to provide context for the data structures required for their implementation and the algorithms associated with the data structures. Numerous worked examples, several large case studies, and end-of-chapter exercises are also provided.
In Section 1.1 we encountered a variety of algorithms. In this section we briefly discuss some fundamental issues concerned with problems, algorithms, and notation.
Concerning problems, we can state the following principles:
EXAMPLE 2.1 The halting problem
The problem is to predict whether a given computer program, with given input data, will eventually halt.
This is a very practical problem for us programmers: we all occasionally write a program that gets into a never-ending loop. One of the most famous results in computer science is that this problem cannot be solved by any algorithm. It turns out that any 'algorithm' that purports to solve this problem will itself get into a never-ending loop, for at (cast some programs that might be given to it. As we shall see later in this section, we insist that every algorithm must eventually terminate.
If we can never find an algorithm to predict whether a given program halts with given input data, we clearly can never find an algorithm to prove whether a given program behaves correctly fen- all possible input data.
It may still be possible for a human to prove that a particular program is correct. Indeed. this has been done for some important small programs and subprograms. But we can never automate such proofs of correctness.
In fact, many problems in mathematics and computer science are unsolvable by algorithms. In a way, this is rather reassuring: we can be sure that mathematicians and computer scientists will never be made redundant by machines!
From now on, we shall consider only problems that are solvable by algorithms.
Concerning al-orithirns themselves, we can state the following principles:
An algorithm is an automatic procedure for solving a stated problem, a procedure that could (at least in principle) be performed by a machine.
The principle that the algorithm must be expressed in steps that can be performed by the processor should now be clear. If the processor has to work out for itself what steps to follow, then what we have is not an algorithm. The principle that every algorithm must eventually terminate should also be clear. If it never terminates, it never produces an answer, therefore it is not an algorithm! So an algorithms must avoid getting into a never-ending loop...
The Array Data Structure.
Linked-List Data Structures.
Abstract Data Types.
Stack Abstract Data Types.
Queue Abstract Data Types.
List Abstract Data Types.
Set Abstract Data Types.
Binary Tree Data Structures.
Map Abstract Data Types.
Hash-Table Data Structures.
Priority-Queue Abstract Data Types.
Tree Abstract Data Types.
Graph Abstract Data Types.
Balanced Search Treet Data Structures.
Appendix A: Summary of Mathematics for Algorithm Analysis.
Appendix B: Summary of Java.
Appendix C: Summary of the Java Collections Framework.
Posted October 21, 2001
It's all written back to front and it doesnt explain things clearly. If you're SUPER intellegent then this book might be ok, but if you're like me and just want to learn without headach, then find another book. This one is a joke...Was this review helpful? Yes NoThank you for your feedback. Report this reviewThank you, this review has been flagged.