Starting Out with Programming Logic and Design: Pearson New International Edition

Series
Pearson
Author
Tony Gaddis  
Publisher
Pearson
Cover
Softcover
Edition
3
Language
English
Total pages
442
Pub.-date
November 2013
ISBN13
9781292042251
ISBN
1292042257
Related Titles


Product detail

Product Price CHF Available  
9781292042251
Starting Out with Programming Logic and Design: Pearson New International Edition
81.40 approx. 7-9 days

eBook

You'll find the eBook here.:

Free evaluation copy for lecturers


Description

Starting Out with Programming Logic and Design, Third Edition, is a language-independent introductory programming book that orients students to programming concepts and logic without assuming any previous programming experience. In the successful, accessible style of Tony Gaddis’ best-selling texts, useful examples and detail-oriented explanations allow students to become comfortable with fundamental concepts and logical thought processes used in programming without the complication of language syntax. Students gain confidence in their program design skills to transition into more comprehensive programming courses.

The book is ideal for a programming logic course taught as a precursor to a language-specific introductory programming course, or for the first part of an introductory programming course.

Features

  • A language-independent approach allows students to gain confidence and build skills before moving on to a more comprehensive language-specific course.
  • Contemporary coverage and Gaddis’ renowned writing style appeals to today’s students.
  • Program design, selection structures, and repetition structures—key topics that beginners need to master—are covered slowly using multiple examples.
  • Functions are covered early but with enough flexibility to be moved later in the course.
  • Menu-driven programming and input validation are covered in separate chapters, allowing instructors to reorder coverage.
  • An appendix, Getting Started with Alice, presents an overview of the Alice programming environment.
  • Student Online Resources are available on the Gaddis Series resource page at www.pearsonhighered.com/gaddis:

  •  

    • VideoNotes are step-by-step video tutorials specifically designed to enhance the programming concepts presented in Gaddis: Starting Out with Programming Logic and Design, 3e. Students can view the entire problem-solving process outside of the classroom—when they need help the most. VideoNotes are available with the purchase of a new copy of select titles. Go to www.pearsonhighered.com/videonotes for a brief VideoNotes demo.

    • Access to the Programming Language Companions for Python, Java, Visual Basic, and C++ specifically designed to accompany the Third Edition of this textbook are available for download. The companions introduce the Java™, Python®, Visual Basic®, and C++ programming languages, and correspond on a chapter-by-chapter basis with the textbook. Many of the pseudocode programs that appear in the textbook also appear in the companions, implemented in a specific programming language.

       

    • A link to download the RAPTOR flowcharting environment. RAPTOR is a flowchart-based programming environment developed by the US Air Force Academy of Computer Science.

    • Appendix D: Answers to Checkpoint Questions provides answers to the Checkpoint questions that appear throughout the text.

  • Starting Out with Programming Logic and Design is compatible with the Starting Out with series, which includes books on Alice, Visual Basic®, C++, and Java. View other titles in the series here.

New to this Edition

This book’s pedagogy, organization, and clear writing style remain the same as in the previous edition. Many improvements have been made, which are summarized here:

  • Detailed guidance for students designing their first program
    A new section titled Designing Your First Program has been added to Chapter 2. This section takes the student through the process of analyzing a problem and determining its requirements. The student sees an example of how a program's input, processing, and output can be determined, as a prelude to writing pseudocode and drawing flowcharts.
    Also, a new InThe Spotlight section has been added to Chapter 2 to show the student how to examine the steps that are taken to manually perform a calculation (determining cell phone overage fees), and then convert those steps to a computer algorithm.
  • New Debugging Exercises
    A new set of Debugging Exercises have been added to most of the chapters. The student examines a set of pseudocode algorithms and identifies logical errors.
  • Greater consistency between flowcharts and pseudocode
    Throughout the book, many of the flowcharts have been revised so they appear more consistent with the pseudocode
  • Expanded coverage of nested repetition structures
    In Chapter 5 the section on nested loops has been expanded with an additional example
  • Additional VideoNotes for repetition structures
    New VideoNotes have been added for the Do-While and For loops in Chapter 5.
  • File specification documentation and print spacing charts
    File specification documentation and print spacing charts are now discussed in Chapter 10
  • New pseudocode quick reference guide
    A quick reference guide to the pseudocode used in the book has been added as Appendix C
  • New Programming Language Companions
    New language companions have been added for Python 3 and C++. All of the book's language companions are available on the book's resource site at www.pearsonhighered.com/gaddis.

Table of Contents

Preface xiii
Chapter 1 Introduction to Computers and Programming 1
1.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2 Hardware . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.3 How Computers Store Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.4 How a Program Works . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.5 Types of Software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
Review Questions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Chapter 2 Input, Processing, and Output 29
2.1 Designing a Program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.2 Output, Input, and Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
2.3 Variable Assignment and Calculations . . . . . . . . . . . . . . . . . . . . . . . . . . 43
IN THE SPOTLIGHT: Calculating a Percentage . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
IN THE SPOTLIGHT: Calculating an Average . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
IN THE SPOTLIGHT: Converting a Math Formula to a
Programming Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
2.4 Variable Declarations and Data Types . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
2.5 Named Constants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
2.6 Hand Tracing a Program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
2.7 Documenting a Program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
IN THE SPOTLIGHT: Using Named Constants, Style Conventions,
and Comments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
Review Questions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
Programming Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
Chapter 3 Modules 75
3.1 Introduction to Modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
3.2 Defining and Calling a Module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
IN THE SPOTLIGHT: Defining and Calling Modules . . . . . . . . . . . . . . . . . . . . . . . 84
3.3 Local Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
3.4 Passing Arguments to Modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
IN THE SPOTLIGHT: Passing an Argument to a Module . . . . . . . . . . . . . . . . . . . . 95
IN THE SPOTLIGHT: Passing an Argument by Reference . . . . . . . . . . . . . . . . . . . 100
3.5 Global Variables and Global Constants . . . . . . . . . . . . . . . . . . . . . . . . . 104
IN THE SPOTLIGHT: Using Global Constants . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
Review Questions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
Programming Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
Chapter 4 Decision Structures and Boolean Logic 115
4.1 Introduction to Decision Structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
IN THE SPOTLIGHT: Using the If-Then Statement . . . . . . . . . . . . . . . . . . . . . . . 122
4.2 Dual Alternative Decision Structures . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
IN THE SPOTLIGHT: Using the If-Then-Else Statement . . . . . . . . . . . . . . . . . . 126
4.3 Comparing Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
4.4 Nested Decision Structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
IN THE SPOTLIGHT: Multiple Nested Decision Structures . . . . . . . . . . . . . . . . . 138
4.5 The Case Structure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
IN THE SPOTLIGHT: Using a Case Structure . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
4.6 Logical Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
4.7 Boolean Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
Review Questions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
Programming Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
Chapter 5 Repetition Structures 163
5.1 Introduction to Repetition Structures . . . . . . . . . . . . . . . . . . . . . . . . . . 163
5.2 Condition-Controlled Loops: While, Do-While, and Do-Until . . . . . . 164
IN THE SPOTLIGHT: Designing a While Loop . . . . . . . . . . . . . . . . . . . . . . . . . . 169
IN THE SPOTLIGHT: Designing a Do-While Loop . . . . . . . . . . . . . . . . . . . . . . . . 178
5.3 Count-Controlled Loops and the For Statement . . . . . . . . . . . . . . . . . 183
IN THE SPOTLIGHT: Designing a Count-Controlled Loop
with the For Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
5.4 Calculating a Running Total . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201
5.5 Sentinels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205
IN THE SPOTLIGHT: Using a Sentinel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
5.6 Nested Loops . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209
Review Questions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211
Programming Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214
Chapter 6 Functions 217
6.1 Introduction to Functions: Generating Random Numbers . . . . . . . . . . 217
IN THE SPOTLIGHT: Using Random Numbers . . . . . . . . . . . . . . . . . . . . . . . . . . 221
IN THE SPOTLIGHT: Using Random Numbers to Represent Other Values . . . . . 223
6.2 Writing Your Own Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225
IN THE SPOTLIGHT: Modularizing with Functions . . . . . . . . . . . . . . . . . . . . . . . 232
6.3 More Library Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240
Review Questions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251
Programming Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253
Chapter 7 Input Validation 257
7.1 Garbage In, Garbage Out . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257
7.2 The Input Validation Loop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 258
IN THE SPOTLIGHT: Designing an Input Validation Loop . . . . . . . . . . . . . . . . . . 260
7.3 Defensive Programming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265
Review Questions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266
Programming Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268
Chapter 8 Arrays 269
8.1 Array Basics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269
IN THE SPOTLIGHT: Using Array Elements in a Math Expression . . . . . . . . . . . 276
8.2 Sequentially Searching an Array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283
8.3 Processing the Contents of an Array . . . . . . . . . . . . . . . . . . . . . . . . . . . 289
IN THE SPOTLIGHT: Processing an Array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 296
8.4 Parallel Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303
IN THE SPOTLIGHT: Using Parallel Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304
8.5 Two-Dimensional Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307
IN THE SPOTLIGHT: Using a Two-Dimensional Array . . . . . . . . . . . . . . . . . . . . 311
8.6 Arrays of Three or More Dimensions . . . . . . . . . . . . . . . . . . . . . . . . . . . 316
Review Questions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317
Programming Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320
Chapter 9 Sorting and Searching Arrays 323
9.1 The Bubble Sort Algorithm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323
IN THE SPOTLIGHT: Using the Bubble Sort Algorithm . . . . . . . . . . . . . . . . . . . . 330
9.2 The Selection Sort Algorithm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337
9.3 The Insertion Sort Algorithm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343
9.4 The Binary Search Algorithm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349
IN THE SPOTLIGHT: Using the Binary Search Algorithm . . . . . . . . . . . . . . . . . . . 353
Review Questions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355
Programming Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 358
Chapter 10 Files 361
10.1 Introduction to File Input and Output . . . . . . . . . . . . . . . . . . . . . . . . . . 361
10.2 Using Loops to Process Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 373
IN THE SPOTLIGHT: Working with Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378
10.3 Using Files and Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383
10.4 Processing Records . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 384
IN THE SPOTLIGHT: Adding and Displaying Records . . . . . . . . . . . . . . . . . . . . . 388
IN THE SPOTLIGHT: Searching for a Record . . . . . . . . . . . . . . . . . . . . . . . . . . . . 392
IN THE SPOTLIGHT: Modifying Records . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 394
IN THE SPOTLIGHT: Deleting Records . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 398
10.5 Control Break Logic . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 401
IN THE SPOTLIGHT: Using Control Break Logic . . . . . . . . . . . . . . . . . . . . . . . . .403
Review Questions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 407
Programming Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 410
Chapter 11 Menu-Driven Programs 413
11.1 Introduction to Menu-Driven Programs . . . . . . . . . . . . . . . . . . . . . . . . . 413
11.2 Modularizing a Menu-Driven Program . . . . . . . . . . . . . . . . . . . . . . . . . 424
11.3 Using a Loop to Repeat the Menu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 429
IN THE SPOTLIGHT: Designing a Menu-Driven Program . . . . . . . . . . . . . . . . . . 434
11.4 Multiple-Level Menus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 448
Review Questions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 454
Programming Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 456
Chapter 12 Text Processing 459
12.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 459
12.2 Character-By-Character Text Processing . . . . . . . . . . . . . . . . . . . . . . . . 461
IN THE SPOTLIGHT: Validating a Password . . . . . . . . . . . . . . . . . . . . . . . . . . . . 464
IN THE SPOTLIGHT: Formatting and Unformatting Telephone Numbers . . . . . . 470
Review Questions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 475
Programming Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 477
Chapter 13 Recursion 481
13.1 Introduction to Recursion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .481
13.2 Problem Solving with Recursion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .484
13.3 Examples of Recursive Algorithms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .488
Review Questions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .498
Programming Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .501
Chapter 14 Object-Oriented Programming 503
14.1 Procedural and Object-Oriented Programming . . . . . . . . . . . . . . . . . . . 503
14.2 Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 507
14.3 Using the Unified Modeling Language to Design Classes . . . . . . . . . . . 518
14.4 Finding the Classes and Their Responsibilities in a Problem . . . . . . . . . 521
IN THE SPOTLIGHT: Finding the Classes in a Problem . . . . . . . . . . . . . . . . . . . . 521
IN THE SPOTLIGHT: Determining Class Responsibilities . . . . . . . . . . . . . . . . . . . 525
14.5 Inheritance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 531
14.6 Polymorphism . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 539
Review Questions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 543
Programming Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 547
Chapter 15 GUI Applications and Event-Driven Programming 549
15.1 Graphical User Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 549
15.2 Designing the User Interface for a GUI Program . . . . . . . . . . . . . . . . . . 552
IN THE SPOTLIGHT: Designing a Window . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 557
15.3 Writing Event Handlers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 559
IN THE SPOTLIGHT: Designing an Event Handler . . . . . . . . . . . . . . . . . . . . . . . . 562
Review Questions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 564
Programming Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 566

Appendix A ASCII/Unicode Characters 569
Appendix B Flowchart Symbols 570
Appendix C Answers to Checkpoint Questions (located on the CD that accompanies this book)
Index 573