Study guide
9.2 Arrays, Lists, and Two-Dimensional Arrays
Praxis Computer Science 5652
Track your progress as you read
Finished sections get a check mark.
1 Chapter 1: Praxis 5652 Exam Overview and ETS Pseudocode
1.1 Praxis 5652 Test Facts, Scoring, and Registration 1.2 Official ETS Pseudocode Notation and Tracing Strategy
2 Chapter 2: Impacts of Computing: Innovation, Access, and Effects
2.1 Computing for Creativity, Problem Solving, Communication, and Innovation 2.2 Equal Access, the Digital Divide, and Accessibility 2.3 Beneficial and Harmful Effects of Computing Innovations
3 Chapter 3: Impacts of Computing: Intellectual Property, Ethics, Privacy, and Security
3.1 Intellectual Property: Copyright, Open Source, and Creative Commons 3.2 Ethical and Unethical Computing Practices and Their Implications 3.3 Privacy, Security, Data Collection, and Local vs. Cloud Storage
4 Chapter 4: Algorithms and Computational Thinking: Abstraction, Decomposition, Number Bases, and Representation
4.1 Abstraction and Abstraction Hierarchies 4.2 Decomposition, Pattern Recognition, and Developing Algorithms 4.3 Number Bases: Binary, Octal, Decimal, and Hexadecimal 4.4 Algorithm Formats: Natural Language, Flowcharts, Pseudocode, and Tracing
5 Chapter 5: Algorithms: Efficiency, Limits of Computing, and Randomization
5.1 Algorithm Efficiency: Linear, Quadratic, Exponential, and Logarithmic Growth 5.2 Limits of Computing: Unsolvable Problems, Intractability, and Heuristics 5.3 Randomization, Random vs. Pseudorandom Numbers, and Scaling to a Range
6 Chapter 6: Algorithms: Searching, Sorting, and Recursion
6.1 Searching Algorithms: Linear Search and Binary Search 6.2 Sorting Algorithms: Tracing, Comparisons, Correctness, and Efficiency 6.3 Recursion: Base Cases, Tracing, Errors, and Iterative Equivalents
7 Chapter 7: Programming: Variables, Data Types, Strings, and Expressions
7.1 Variables, Data Types, and Type Conversion 7.2 Strings and String Operations 7.3 Operators, Precedence, Expressions, and Formulas 7.4 Boolean Expressions, Truth Tables, and Boolean Algebra
8 Chapter 8: Programming: Selection, Iteration, and Writing Code
8.1 Sequence and Selection: if, else, Chained and Nested Conditions 8.2 Iteration: for, while, do … while, and repeat … until Loops 8.3 Reading, Completing, and Modifying Code
9 Chapter 9: Programming: Procedures, Arrays, and Data Structures
9.1 Procedures, Parameters, Return Values, Nested Calls, and Scope 9.2 Arrays, Lists, and Two-Dimensional Arrays 9.3 Stacks, Queues, and Dictionaries (Maps)
10 Chapter 10: Programming: Correctness, Errors, Testing, and Code Quality
10.1 Program Correctness: Preconditions, Postconditions, Invariants, and Testing vs. Proof 10.2 Error Types and Debugging Techniques 10.3 Choosing Useful Test Cases: Boundaries, Partitions, Coverage, and Regression 10.4 Extensibility, Modifiability, and Reusability: Constants and Parameterization 10.5 Documentation, Code Reviews, Peer Feedback, and End-User Feedback
11 Chapter 11: Programming: Events, Usability, Input Validation, and APIs
11.1 Event-Driven Programming, Asynchronous Events, and Concurrency 11.2 Usability, Meaningful Error Messages, and Input Validation vs. Verification 11.3 Libraries and APIs: Reading Definitions, Making Calls, and Weighing Trade-offs
12 Chapter 12: Programming: Languages, Tools, Paradigms, and Object-Oriented Design
12.1 Low- and High-Level Languages, Compilers and Interpreters, and IDEs 12.2 Programming Paradigms: Procedural, Object-Oriented, and Others 12.3 Classes, Objects, Instance Variables, Methods, and Encapsulation 12.4 Inheritance, Polymorphism, and Overloading vs. Overriding
13 Chapter 13: Data: Bits, Encoding, Compression, and Encryption
13.1 Bits and Bytes: Why Binary, Storage Calculations, and Signed Integers 13.2 Encoding Text, Images, and Sound 13.3 Lossless and Lossy Compression: Run-Length Encoding, Huffman Coding, and Media Formats 13.4 Encoding vs. Encryption, Symmetric and Public-Key Encryption, and Their Trade-offs
14 Chapter 14: Data: Analysis Tools, Simulation, Storage, and Collection
14.1 Analyzing Data with Spreadsheets: Cleaning, Transforming, and Visualizing 14.2 Simulation and Modeling 14.3 Files, Databases, and Storage Requirements: Scale, Redundancy, and Backup 14.4 Collecting, Aggregating, and Generating Data: Public Data Sets, Surveys, Sensors, and Crowdsourcing
15 Chapter 15: Computing Systems: Hardware, Operating Systems, and Computing Environments
15.1 Hardware Components and the Fetch–Decode–Execute Cycle 15.2 Operating Systems, Software Components, and Resource Issues 15.3 Embedded Systems, the Internet of Things, and Types of Computing Systems 15.4 Local, Network, and Cloud Computing and Storage; How Binary Data Are Stored
16 Chapter 16: Networks, the Internet, the Web, and Cybersecurity
16.1 Network Types and Wired and Wireless Communication 16.2 Network Hardware and Layered Network Models (OSI and TCP/IP) 16.3 Network Performance: Bandwidth, Latency, Load, and Estimating Needs 16.4 How the Internet Works: Protocols, IP Addressing, DNS, URLs, and Reliability 16.5 The Web: HTTP, HTML and Markup Languages, Browsers, Servers, and Clients 16.6 Cybersecurity: The Five Pillars, Strong Passwords, Security Strategies, and Trade-offs
9.2 Arrays, Lists, and Two-Dimensional Arrays
Key Takeaways Explain This Topic AI
An array of length n has valid indexes 0 through n − 1 when the first element is at index 0; index n is out of bounds.
In ETS pseudocode, arrays are declared as int[ ] a ← {1, 2, 3} or int b[0..2] ← {1, 2, 3}, and a two-dimensional array as int[ ][ ] c.
Initialize a running minimum or maximum to the first element, not to 0, or all-positive or all-negative data give wrong answers.
A two-dimensional array is accessed as grid[row][col]; nested loops over R rows and C columns visit R × C cells.
Dynamic lists (such as Java's ArrayList) append in amortized O(1) time but need O(n) time to insert or remove at the front, because elements must shift.
Last updated: September 2026
Where arrays appear on the test
ETS lists arrays/lists among the core data types (Section 7.1), asks you to trace code when arrays are passed to procedures (Section 9.1), and uses arrays in many algorithm questions: finding a maximum, sorting, searching, and counting. The notation table includes both int[ ] and int[ ][ ] .
One-dimensional arrays
An array stores a fixed number of values of one type under one name. Individual elements are reached by index . int[ ] a ← {90, 85, 77, 92} // length 4
- int b[0..2] ← {1, 2, 3} // declaration that shows the index range
- print a[0] // 90
- a[2] ← a[2] + 5 // a is now {90, 85, 82, 92}
With the first element at index 0, an array of length n has indexes 0 through n − 1 . Using index n, or −1, is an out-of-bounds error at run time.
Arrays are stored in consecutive memory locations . That is why any element can be reached directly: its address is base address + index × element size. With a base address of 2048 and 4-byte integers, a[7] is at 2048 + 7 × 4 = 2076 . Access by index is O(1) .
Traversal patterns
Most array code is one of a handful of loops.
- Sum and average int sum ← 0
- for ( int i ← 0; i < n; i ← i + 1 )
- sum ← sum + a[i]
- end for
- double avg ← sum / n // watch for integer division; see Section 7.1
- Minimum (or maximum) int min ← a[0] // start with a real element
- for ( int i ← 1; i < n; i ← i + 1 )
- if ( a[i] < min )
- min ← a[i]
- end if
- end for
Starting min at 0 is a classic bug. If every value is positive, the "minimum" stays 0, which is not in the array. ETS's sample question on finding a maximum completes this pattern with the missing condition numList[i] > max .
- Count matches int count ← 0
- for ( int i ← 0; i < n; i ← i + 1 )
- if ( a[i] ≥ 70 )
- count ← count + 1
- end if
- end for
Reverse in place: swap a[i] with a[n - 1 - i] for i from 0 while i < n / 2 . Going all the way to n would swap everything back.
Shift left (delete at index k): copy a[i + 1] into a[i] for i from k to n − 2. The last slot then holds a duplicate or unused value.
- Two-dimensional arrays
- A 2D array is a grid of rows and columns, accessed as grid[row][col] . col 0 col 1 col 2 col 3
- row 0 [ 10 12 14 16 ]
- row 1 [ 20 22 24 26 ]
- row 2 [ 30 32 34 36 ]
Here grid[1][2] is 24. There are 3 rows and 4 columns.
- Row-by-row traversal (row-major) for ( int r ← 0; r < numRows; r ← r + 1 )
- for ( int c ← 0; c < numCols; c ← c + 1 )
- print grid[r][c] // print a space after each value
- end for
- end for
The inner statement runs numRows × numCols times, 12 in the example. Swapping the loops traverses column by column instead.
Useful 2D patterns
- Task How
- Row sums For each r, sum grid[r][c] over all c
- Column sums For each c, sum grid[r][c] over all r (outer loop over columns)
- Main diagonal (square grid) One loop: grid[i][i]
- Neighbors of a cell Check r − 1 , r + 1 , c − 1 , and c + 1 , staying within bounds
C and C++ store 2D arrays row-major in memory: all of row 0, then row 1, and so on. The cell grid[r][c] is at base + (r × numCols + c) × size. Java and Python build 2D structures as arrays (or lists) of rows, which are also naturally traversed row by row.
Dynamic lists
A fixed-size array cannot grow. Most languages provide a dynamic list , such as Java's ArrayList , Python's list , or C++'s vector . It stores its elements in an internal array that has spare room.
Size: how many elements are stored. Capacity: how many fit before the internal array must grow.
Appending when capacity remains is O(1). When the array is full, the list allocates a larger array (grown by a constant factor; Java's ArrayList grows by about 1.5×) and copies everything over, which is O(n) for that one append. Because growth is geometric, the copying averages out to amortized O(1) per append.
Inserting or removing at index k shifts every element after k. At the front, that is O(n) .
Access by index remains O(1).
- Operation Fixed array Dynamic list
- Read or write by index O(1) O(1)
- Append at end Not possible when full O(1) amortized
- Insert or remove at front O(n) shifting, or not possible O(n)
- Search unsorted O(n) O(n)
- Arrays and procedures
An array passed to a procedure is shared, not copied (Section 9.1). A procedure that sorts, fills, or modifies an array's elements changes the caller's array. A procedure that needs to leave the original alone must make its own copy first.