Computer Science Programming Fundamentals and Algorithms

Comprehensive vocabulary flashcards covering programming fundamentals, data structures, constructs, algorithms, and file processing based on the lecture transcript.

Variable

A container that stores data that can change, designated as mutable.

Constant

A container that stores data that should not change, designated as immutable.

Operator

A symbol used for arithmetic or comparisons, such as $, +, -, *, /,$.

Data Type

Defines the kind of data stored, such as Boolean, Character, Decimal/Float, Integer, or String.

Local variable

A variable defined inside a function that is only accessible within that specific function.

Global variable

A variable defined outside of functions that is accessible anywhere within the program.

Trace tables

A tool used to manually follow the flow of code step by step to track how variable values change over time.

String

A sequence of characters, for example, "Alice Smith".

Substring

A smaller part of a string, such as $name[0:5]$ resulting in "Alice".

Exception

An unexpected event that disrupts program flow, such as a divide by $0$ error.

Exception handling

The process of using try/except/finally blocks to prevent program crashes during unexpected events.

Bug

An error that causes a program to produce unexpected results.

Debugging

The process of finding and fixing bugs within a program.

Static data structure

A data structure with a fixed size stored in contiguous memory, such as arrays in Java, which offers faster access but less flexibility.

Dynamic data structure

A data structure that can grow or shrink at runtime and may be non-contiguous, such as lists in Python, which is more memory efficient.

Array

A structure that stores multiple values in an indexed format, which can be $1D$ or $2D$.

Parallel arrays

Two or more arrays of equal length used to store related data.

Tuples

Fixed, immutable data collections used in Python.

Lists

Dynamic, flexible arrays in Python that support methods like $.append()$, $.pop()$, and $.remove()$.

Stack

A Last-In, First-Out ($\text{LIFO}$) data structure, similar to a stack of plates, supporting operations like $push()$, $pop()$, and $peek()$.

Queue

A First-In, First-Out ($\text{FIFO}$) data structure, similar to a line at a store, supporting operations like $enqueue()$ and $dequeue()$.

Sequence

A programming construct where code executes in the exact order it is written.

Selection

A programming construct for choosing between different paths based on conditions, implemented as if/elif/else in Python.

Looping

The process of repeating code until a specific condition is met, including conditional (while) and counted (for) loops.

Function

A named block of reusable code.

Modularization

The practice of breaking code into smaller parts to improve clarity, reusability, testing, and maintenance.

Big O notation

A notation used to describe how quickly operations increase as input size ($n$) grows, measuring an algorithm's scalability.

Time complexity

A measure of how the runtime of an algorithm changes as the size of the input increases.

Linear Search

A retrieval algorithm with complexity $O(n)$ that checks items one-by-one; it works on both sorted and unsorted data.

Binary Search

A retrieval algorithm with complexity $O(\log n)$ that repeatedly checks the middle item and discards half the list, requiring sorted data.

Bubble Sort

An inefficient sorting algorithm with complexity $O(n^2)$ that works by swapping adjacent items until larger values "bubble" to the end.

Selection Sort

A sorting algorithm with complexity $O(n^2)$ that repeatedly selects the smallest item and places it into the correct position.

Recursion

A programming concept where a function calls itself to solve smaller versions of a problem, requiring a base case and a recursive case.

Absolute Path

The full location of a file or folder starting from the root directory.

Relative Path

The location of a file or folder expressed relative to the current working directory.