DATA ABSTRACTION AND PROBLEM SOLVING WITH JAVA

Transcription

1 DATA ABSTRACTION AND PROBLEM SOLVING WITH JAVA WALLS AND MIRRORS First Edition Frank M. Carrano University of Rhode Island Janet J. Prichard Bryant College Boston San Francisco New York London Toronto Sydney Tokyo Singapore Madrid Mexico City Munich Paris Cape Town Hong Kong Montreal

2 Contents Preface iii Chapter Dependency Chart v»mmwm mm>m:mmm» wmmmmmwm> wmmmmi wm<mmmmmmmmmmmmm~mmwmmmm;m«m& Part I Problem-Solving Techniques 1 CHAPTER 1 Principles of Programming and Software Engineering 3 Problem Solving and Software Engineering 4 What Is Problem Solving? 4 The Life Cycle of Software 5 What Is a Good Solution? 14 Achieving a Modular Design 16 Abstraction and Information Hiding 16 Object-Oriented Design 18 Top-Down Design 20 General Design Guidelines 22 A Summary of Key Issues in Programming 22 Modularity 23 Modifiability 25 Ease of Use 26 Fail-Safe Programming 27 Style 33 Debugging 37 Summary 40 Cautions 41 Self-Test Exercises 41 Exercises 42 Programming Problems 44 CHAPTER 2 Recursion: The Mirrors 47 Recursive Solutions 48 A Recursive Valued Method: The Factorial of n 51 A Recursive void Method: Writing a String Backward 59 Counting Things 68 Multiplying Rabbits (The Fibonacci Sequence) 69 Organizing a Parade 72 Mr. Spock's Dilemma (Choosing k out of n Things) 73

3 xvi CONTENTS Searching An Array 76 Finding the Largest Item in an Array 76 Binary Search 77 Finding the k th Smallest Item in an Array 81 Organizing Data 85 The Towers of Hanoi 85 Recursion and Efficiency 92 Summary 95 Cautions 95 Self-Test Exercises 96 Exercises 97 Programming Problems 103 CHAPTER 3 Data Abstraction: The Walls 105 Abstract Data Types 106 Specifying ADTs 111 The ADT List 112 The ADT Sorted List 117 Designing an ADT 118 Axioms (Optional) 122 Implementing ADTs 124 Java Classes 126 Java Interfaces 134 Java Exceptions 135 An Array-Based Implementation of the ADT List 137 Summary 144 Cautions 145 Self-Test Exercises 146 Exercises 147 Programming Problems 149 CHAPTER 4 Linked Lists 151 Preliminaries 152 Object References 153 Resizeable Arrays 158 Reference-Based Linked Lists 159 Programming with Linked Lists 163 Displaying the Contents of a Linked List 163 Deleting a Specified Node from a Linked List 165 Inserting a Node into a Specified Position of a Linked List 167 A Reference-Based Implementation of the ADT List 174 Comparing Array-Based and Reference-Based Implementations 178 Passing a Linked List to a Method 180 Processing Linked Lists Recursively 181

4 CONTENTS Variations of the Linked List 186 Tail References 186 Circular Linked Lists 187 Dummy Head Nodes 189 Doubly Linked Lists 191 Application: Maintaining an Inventory 194 Summary 200 Cautions 202 Self-Test Exercises 203 Exercises 204 Programming Problems 207 CHAPTER 5 Recursion as a Problem-Solving Technique 211 Backtracking 212 The Eight Queens Problem 212 Defining Languages 217 The Basics of Grammars 218 Two Simple Languages 220 Algebraic Expressions 222 The Relationship between Recursion and Mathematical Induction 231 The Correctness of the Recursive Factorial Method 232 The Cost of Towers of Hanoi 233 Summary 234 Cautions 235 Self-Test Exercises 235 Exercises 236 Programming Problems 239 Part II Problem Solving with Abstract Data Types 245 CHAPTER 6 Stacks 247 The Abstract Data Type 248 Developing an ADT during the Design of a Solution 248 Simple Applications of the ADT Stack 254 Checking for Balanced Braces 254 Recognizing Strings in a Language 257 Implementations of the ADT Stack 258 An Array-Based Implementation of the ADT Stack 260 A Reference-Based Implementation of the ADT Stack 263 An Implementation That Uses the ADT List 264 Comparing Implementations 265 Application: Algebraic Expressions 266 Evaluating Postfix Expressions 266 Converting Infix Expressions to Equivalent Postfix Expressions 268

5 xviii CONTENTS Application: A Search Problem 271 A Nonrecursive Solution That Uses a Stack 272 A Recursive Solution 280 The Relationship between Stacks and Recursion 283 Summary 286 Cautions 286 Self-Test Exercises 286 Exercises 288 Programming Problems 290 CHAPTER 7 Queues 297 The Abstract Data Type Queue 298 Simple Applications of the ADT Queue 300 Reading a String of Characters 300 Recognizing Palindromes 301 Implementations of the ADT Queue 302 A Reference-Based Implementation 302 An Array-Based Implementation 306 An Implementation That Uses the ADT List 312 Comparing Implementations 313 A Summary of Position-Oriented ADTs 314 Application: Simulation 315 Summary 325 Cautions 325 Self-Test Exercises 326 Exercises 327 Programming Problems 329 CHAPTER 8 Class Relationships 333 Inheritance Revisited 334 Java Packages 340 Java Access Modifiers 341 Is-a and Has-a Relationships 342 Dynamic Binding and Abstract Classes 345 Abstract Classes 348 Java Interfaces Revisited 352 The ADTs LIST and Sorted List Revisited 354 Implementation of a List Iterator 355 Implementations of the ADT Sorted List That Use the ADT List 359 The Advantages of an Object-Oriented Approach 363 Summary 364 Cautions 365 Self-Test Exercises 365 Exercises 366 Programming Problems 367

6 CONTENTS xix CHAPTER 9 Algorithm Efficiency and Sorting 371 Determining the Efficiency of Algorithms 372 The Execution Time of Algorithms 374 Algorithm Growth Rates 375 Order-of-Magnitude Analysis and Big O Notation 376 Keeping Your Perspective 381 The Efficiency of Searching Algorithms 383 Sorting Algorithms and Their Efficiency 384 Selection Sort 385 Bubble Sort 388 Insertion Sort 390 Mergesort 393 Quicksort 398 Radix Sort 410 A Comparison of Sorting Algorithms 412 Summary 413 Cautions 413 Self-Test Exercises 414 Exercises 415 Programming Problems 418 CHAPTER 10 Trees 421 Terminology 423 The ADT Binary Tree 429 Basic Operations of the ADT Binary Tree 429 General Operations of the ADT Binary Tree 430 Traversals of a Binary Tree 432 Possible Representations of a Binary Tree 435 A Reference-Based Implementation of the ADT Binary Tree 438 Tree Traversals Using an Iterator 444 The ADT Binary Search Tree 452 Algorithms for the Operations of the ADT Binary Search Tree 456 A Reference-Based Implementation of the ADT Binary Search Tree 471 The Efficiency of Binary Search Tree Operations 474 Treesort 478 Saving a Binary Search Tree in a File 479 General Trees 482 Summary 484 Cautions 484 Self-Test Exercises 485 Exercises 486 Programming Problems 492

7 CONTENTS CHAPTER 11 Tables and Priority Queues 497 The ADT Table 498 Selecting an Implementation 504 A Sorted Array-Based Implementation of the ADT Table 512 A Binary Search Tree Implementation of the ADT Table 514 The ADT Priority Queue: A Variation of the ADT Table 517 Heaps 520 A Heap Implementation of the ADT Priority Queue 528 Heapsort 530 Summary 534 Cautions 534 Self-Test Exercises 535 Exercises 536 Programming Problems 538 CHAPTER 12 Advanced Implementations of Tables 541 Balanced Search Trees Trees Trees 562 Red-Black Trees 569 AVL Trees 572 Hashing 578 Hash Functions 582 Resolving Collisions 584 The Efficiency of Hashing 592 What Constitutes a Good Hash Function? 595 Table Traversal: An Inefficient Operation under Hashing 597 Data with Multiple Organizations 598 Summary 604 Cautions 605 Self-Test Exercises 605 Exercises 606 Programming Problems 608 CHAPTER 13 Graphs 611 Terminology 612 Graphs as ADTs 615 Implementing Graphs 616 Graph Traversals 619 Depth-First Search 620 Breadth-First Search 622

8 CONTENTS XXI Applications of Graphs 623 Topological Sorting 623 Spanning Trees 628 Minimum Spanning Trees 631 Shortest Paths 633 Circuits 637 Some Difficult Problems 640 Summary 642 Cautions 643 Self-Test Exercises 643 Exercises 644 Programm ing Problems 647 CHAPTER 14 External Methods 649 A Look at External Storage 650 Sorting Data in an External File 653 External Tables 660 Indexing an External File 663 External Hashing 667 B-Trees 671 Traversals 680 Multiple Indexing 682 Summary 683 Cautions 684 Self-Text Exercises 684 Exercises 685 Programming Problems 687 Appendices APPENDIX A Review of Java Fundamentals 689 Program Structure 690 Packages 690 Classes 692 Data Fields 693 Methods 694 How to Access Members of an Object 696 Language Basics 696 Comments 697 Identifiers and Keywords 697 Variables 697 Primitive Data Types 697 References 698 Literal Constants 699 Named Constants 699 Assignments and Expressions 700 Arrays 702

9 Useful Java Classes 706 The object Class 706 String Classes 707 Java Exceptions 712 Catching Exceptions 712 Throwing Exceptions 718 Text Input and Output 720 Input 720 Output 721 Selection Statements 722 The if Statement 722 The switch Statement 723 Iteration Statements 724 The while Statement 724 The for Statement 726 The do Statement 728 File Input and Output 728 Text Files 730 Object Serialization 736 A Comparison to C Summary 742 Cautions 744 APPENDIX B Unicode Character Codes (ASCII Subset) 747 APPENDIX C Java Resources 749 APPENDIX D Mathematical Induction 751 GLOSSARY 757 ANSWERS TO SELF-TEST EXERCISES 775 INDEX 791